ParticleMC.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file ParticleMC.h

#ifndef INCLUDE_EICSMEAR_ERHIC_PARTICLEMC_H_
#define INCLUDE_EICSMEAR_ERHIC_PARTICLEMC_H_

#include <string>

#include <TLorentzVector.h>
#include <TRef.h>
#include <TVector3.h>

#include "eicsmear/erhic/Pid.h"
#include "eicsmear/erhic/VirtualParticle.h"

namespace erhic {

  class ParticleMCeA: public TObject {
  public:
    explicit ParticleMCeA() {};
    virtual ~ParticleMCeA() {};
    
    // Let them all be public;
    //added by liang to include add on particle data structure
    Int_t charge; 
    Int_t massNum;
    Int_t NoBam; 


    ClassDef(ParticleMCeA, 1)
};

class EventMC;
class ParticleMCbase : public VirtualParticle {
 public:
  explicit ParticleMCbase();
  virtual ~ParticleMCbase() {};

  virtual void Print(Option_t* = "") const;

  virtual UInt_t GetIndex() const;

  virtual UShort_t GetStatus() const;

  virtual UShort_t GetParentIndex() const;
  virtual UShort_t GetParentIndex1() const;

  virtual UShort_t GetChild1Index() const;

  virtual UShort_t GetChildNIndex() const;

  virtual UInt_t GetNChildren() const;

  virtual Double_t GetPx() const;

  virtual Double_t GetPy() const;

  virtual Double_t GetPz() const;

  virtual Double_t GetM() const;

  virtual Double_t GetPt() const;

  virtual TVector3 GetVertex() const;

  virtual Pid GetParentId() const;

  virtual Double_t GetP() const;

  virtual Double_t GetTheta() const;

  virtual Double_t GetPhi() const;

  virtual Double_t GetRapidity() const;

  virtual Double_t GetEta() const;

  virtual Double_t GetZ() const;

  virtual Double_t GetXFeynman() const;

  virtual Double_t GetThetaVsGamma() const;

  virtual Double_t GetPtVsGamma() const;

  const EventMC* GetEvent() const;

  void SetEvent(EventMC* event);

  virtual TLorentzVector Get4Vector() const;

  virtual TLorentzVector PxPyPzE() const { return Get4Vector(); }

  virtual TLorentzVector Get4VectorInHadronBosonFrame() const;

  virtual Double_t GetE() const;

  virtual void SetE(Double_t);

  virtual void SetM(Double_t);

  virtual void SetP(Double_t);

  virtual void SetPt(Double_t);

  virtual void SetPz(Double_t);

  virtual void SetPhi(Double_t);

  virtual void SetTheta(Double_t);

  virtual void SetStatus(UShort_t);

  virtual Pid Id() const;

  virtual Pid GetPdgCode() const { return Id(); }

  virtual void ComputeDerivedQuantities();

  virtual void ComputeEventDependentQuantities(EventMC&);

  virtual void SetIndex(int i) { I = i; }

  virtual void SetStatus(int i) { KS = i; }

  virtual void SetId(int i) { id = i; }

  virtual void SetParentIndex(int i) { orig = i; }

  virtual void SetParentIndex1(int i) { orig1 = i; }

  virtual void SetChild1Index(int i) { daughter = i; }

  virtual void SetChildNIndex(int i) { ldaughter = i; }

  virtual void Set4Vector(const TLorentzVector&);

  virtual void SetVertex(const TVector3&);

  virtual void SetParentId(int i) { parentId = i; }

// protected:

  UShort_t    I;             
  //UShort_t    KS;            ///< Particle status code: see PYTHIA manual
  //modified by liang to include negative KS values
  Int_t     KS;            
  Int_t       id;            
  // Looks strange (see also access methods); keep like this for sort of 
  // backward compatibility;
  UShort_t    orig;          
  UShort_t    orig1;         
  UShort_t    daughter;      
  UShort_t    ldaughter;     

  // AYK, 2017/04/02: changed {px,py,pz} & {xv,yv,zv} variable types 
  // from Double32_t (float) to Double_t (double);
  Double_t px;           
  Double_t py;           
  Double_t pz;           

  // Reducing file size.
  // The following variables could be removed, at the cost of increased
  // running time to calculate them on-the-fly:
  // p - compute from px/y/z
  // m - accessible via PID with TDatabasePDG
  // E - compute from p and m
  // parentId - accessible via event record and parent index IF a
  //          persistent pointer to the containing event can be stored
  // daughter - IF daughter particles always start immediately after this one
  // pt - from px, py
  // theta - from pt, pz
  // phi - from px, py
  // rapidity - from E, pz
  // eta - from theta
  // xFeynman - if event is accessible
  // thetaGamma - duplicated in pHadronBoson
  // ptVsGamma - duplicated in pHadronBoson
  // phiPrf - duplicated in pHadronBoson

  Double32_t E;            
  Double32_t m;            
  Double32_t pt;           
  Double_t xv;           
  Double_t yv;           
  Double_t zv;           

  // Can be deprecated if parent particle itself is available
  Int_t parentId;          

  Double32_t p;            
  Double32_t theta;        
  Double32_t phi;          
  Double32_t rapidity;     
  Double32_t eta;          
  Double32_t z;            

  Double32_t xFeynman;     
  Double32_t thetaGamma;   

  Double32_t ptVsGamma;    

  Double32_t thetaGammaHCM;   

  Double32_t ptVsGammaHCM;    

  Double32_t phiPrf;       


  TRef event;  


  ClassDef(ParticleMCbase, 5)
};

// The unfortunate consequence of adding 'eA' pointer to the ParticleMC 
// class is that default copy ctor does not work; the easiest workaround
// (unless somebody would like to copy all the other variables by hand) 
// is to offload these variables to an intermediate base class;
class ParticleMC : public ParticleMCbase {
 public:
  explicit ParticleMC(): eA(0) {};
  explicit ParticleMC(const std::string&, bool eAflag);
  // So this is the evil copy ctor, which is damn simple now;
 ParticleMC(const ParticleMC &src): ParticleMCbase(src) {
    eA = src.eA ? new ParticleMCeA(*src.eA) : 0; //orig1 = src.orig1;
  };

  ~ParticleMC();

  virtual const ParticleMC* GetParent() const;

  virtual const ParticleMC* GetChild(UShort_t) const;

  virtual Bool_t HasChild(Int_t) const;

  // FIXME: let it be public?; NB: TRef (like for ParticleMCbase.event) is 
  // not needed here, since it is just a POD instance with a single reference;
  ParticleMCeA *eA;
  //UShort_t    orig1;          ///< I of parent particle1

  ClassDef(ParticleMC, 2)
};

inline UInt_t ParticleMCbase::GetIndex() const {
  return I;
}

inline UShort_t ParticleMCbase::GetStatus() const {
  return KS;
}

inline UShort_t ParticleMCbase::GetParentIndex() const {
  return orig;
}
inline UShort_t ParticleMCbase::GetParentIndex1() const {
  return orig1;
}

inline UShort_t ParticleMCbase::GetChild1Index() const {
  return daughter;
}

inline UShort_t ParticleMCbase::GetChildNIndex() const {
  return ldaughter;
}

inline Double_t ParticleMCbase::GetPx() const {
  return px;
}

inline Double_t ParticleMCbase::GetPy() const {
  return py;
}

inline Double_t ParticleMCbase::GetPz() const {
  return pz;
}

inline Double_t ParticleMCbase::GetM() const {
  return m;
}

inline Double_t ParticleMCbase::GetPt() const {
  return pt;
}

inline TVector3 ParticleMCbase::GetVertex() const {
  return TVector3(xv, yv, zv);
}

inline erhic::Pid ParticleMCbase::GetParentId() const {
  return erhic::Pid(parentId);
}

inline Double_t ParticleMCbase::GetP() const {
  return p;
}

inline Double_t ParticleMCbase::GetTheta() const {
  return theta;
}

inline Double_t ParticleMCbase::GetPhi() const {
  return phi;
}

inline Double_t ParticleMCbase::GetRapidity() const {
  return rapidity;
}

inline Double_t ParticleMCbase::GetEta() const {
  return eta;
}

inline Double_t ParticleMCbase::GetZ() const {
  return z;
}

inline Double_t ParticleMCbase::GetXFeynman() const {
  return xFeynman;
}

inline Double_t ParticleMCbase::GetThetaVsGamma() const {
  return thetaGamma;
}

inline Double_t ParticleMCbase::GetPtVsGamma() const {
  return ptVsGamma;
}

inline Pid ParticleMCbase::Id() const {
  return Pid(id);
}

inline UInt_t ParticleMCbase::GetNChildren() const {
  if (0 == daughter) return 0;
  if (0 == ldaughter) return 1;
  return ldaughter - daughter + 1;
}

inline Double_t ParticleMCbase::GetE() const {
  return E;
}

inline void ParticleMCbase::SetE(Double_t e) {
  E = e;
}

inline void ParticleMCbase::SetM(Double_t mass) {
  m = mass;
}

inline void ParticleMCbase::SetP(Double_t momentum) {
  p = momentum;
}

inline void ParticleMCbase::SetPt(Double_t momentum) {
  pt = momentum;
}

inline void ParticleMCbase::SetPz(Double_t momentum) {
  pz = momentum;
}

inline void ParticleMCbase::SetPhi(Double_t value) {
  phi = value;
}

inline void ParticleMCbase::SetTheta(Double_t value) {
  theta = value;
}

inline void ParticleMCbase::SetStatus(UShort_t status) {
  KS = status;
}

}  // namespace erhic

#endif  // INCLUDE_EICSMEAR_ERHIC_PARTICLEMC_H_