Particle.h

Go to the documentation of this file.

#ifndef _utl_Particle_h_
#define _utl_Particle_h_

#include <utl/VParticleProperties.h>
#include <utl/Point.h>
#include <utl/TimeInterval.h>
#include <utl/Vector.h>
#include <utl/AugerException.h>

#include <iostream>
#include <string>

#include <boost/shared_ptr.hpp>


namespace utl {

  class Particle {

  public:
    // Enumerations

    enum Source {
      eShower,
      eBackground,
      eShowerFromMuonDecay,
      eShowerFromLocalHadron,  // for universality parametrization
      eCornerClipping  // for UMD injection disctintion
    };

    enum Type {
      eUndefined = 0,
      eElectron = 11, ePositron = -11,
      eNuElectron = 12, eAntiNuElectron = -12,
      eMuon = 13, eAntiMuon = -13,
      eNuMuon = 14, eAntiNuMuon = -14,
      eTau = 15, eAntiTau = -15,
      eNuTau = 16, eAntiNuTau = -16,
      ePhoton = 22,
      // PDG codes 81-100 are reserved for special/pseudo particles
      eDecayedMuon = 96, eDecayedAntiMuon = 95,
      ePiZero = 111,
      eRhoZero = 113,
      ePiPlus = 211, ePiMinus = -211,
      eRhoPlus = 213, eRhoMinus = -213,
      eEta = 221,
      eOmegaMeson = 223,
      eKaon0L = 130, eKaon0S = 310,
      eKaonStarZero = 313, eAntiKaonStarZero = -313,
      eKaonPlus = 321, eKaonMinus = -321,
      eKaonStarPlus = 323, eAntiKaonStarMinus = -323,
      ePhi = 333,
      eDeltaMinus = 1114, eAntiDeltaPlus = -1114,
      eNeutron = 2112, eAntiNeutron = -2112,
      eDeltaZero = 2114, eAntiDeltaZero = -2114,
      eProton = 2212, eAntiProton = -2212,
      eDeltaPlus = 2214, eAntiDeltaMinus = -2214,
      eDeltaPlusPlus = 2224, eAntiDeltaMinusMinus = -2224,
      eLambda = 3122, eAntiLambda = -3122,
      eSigmaPlus = 3222, eSigmaZero = 3212, eSigmaMinus = 3112,
      eAntiSigmaPlus = -3222, eAntiSigmaZero = -3212, eAntiSigmaMinus = -3112,
      eXiZero = 3322, eXiMinus = 3312,
      eAntiXiZero = -3322, eAntiXiMinus = -3312,
      eOmegaMinus = 3332, eAntiOmegaMinus = -3332,
      eLambdac = 4122,
      // Selected nuclei.
      // Note: This is an inconsistency left in for historical reasons only.
      //   Cf. utl::NucleusProperties instead!
      //   Usage example thereof can be found in CONEXFile.cc.
      eIron = 1000026056
    };

    Particle(const int type, const Source& source, const Point& position,
             const Vector& direction, const TimeInterval& time,
             const double weight, const double kineticEnergy);

    Particle(const int type, const Source& source, const Point& position,
             const Vector& momentum, const TimeInterval& time,
             const double weight);

    // why not return by enum??
    int GetType() const { return fProperties->GetType(); }

    std::string GetName() const { return fProperties->GetName(); }

    Source GetSource() const { return fSource; }

    const Point& GetPosition() const { return fPosition; }
    void SetPosition(const utl::Point& position) { fPosition = position; }

    const Vector& GetDirection() const { return fDirection; }
    void SetDirection(const utl::Vector& direction) { fDirection = direction; }

    Vector GetMomentum() const;
    void SetMomentum(const utl::Vector& momentum);

    const TimeInterval& GetTime() const { return fTime; }
    void SetTime(const TimeInterval& time) { fTime = time; }

    double GetWeight() const { return fWeight; }
    void SetWeight(const double weight) { fWeight = weight; }

    double GetKineticEnergy() const { return fKineticEnergy; }

    void SetKineticEnergy(const double ke) { fKineticEnergy = ke; }

    double GetTotalEnergy() const { return fKineticEnergy + GetMass(); }

    void SetTotalEnergy(const double totE) { fKineticEnergy = totE - GetMass(); }

    double GetMass() const { return fProperties->GetMass(); }

    static int NucleusCode(const int charge, const int atomicNumber);

    bool HasParent() const { return bool(fParent); }
    Particle& GetParent() { return *fParent.get(); }
    const Particle& GetParent() const { return *fParent.get(); }
    void SetParent(Particle& parent) { fParent.reset(new Particle(parent)); }

    bool HasProductionPoint() const { return bool(fProductionPoint); }
    const utl::Point& GetProductionPoint() const { return *fProductionPoint.get(); }
    void SetProductionPoint(const utl::Point& point) { fProductionPoint.reset(new utl::Point(point)); }

  private:
    // This is to handle Corsika's history option.
    boost::shared_ptr<Particle> fParent;
    boost::shared_ptr<const utl::Point> fProductionPoint;

    // General information
    ParticlePropertiesPtr fProperties;
    Source fSource = eShower;

    utl::Point fPosition;
    utl::Vector fDirection;

    TimeInterval fTime;
    double fWeight = 0;
    double fKineticEnergy = 0;

  };


  class ParticleTypeException : public AugerException {

  public:
    ParticleTypeException(const std::string message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Unknown Particle Type exception"; }

  };

}


#endif