erhic/ParticleMC.h

Go to the documentation of this file.

 
#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 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 phiPrf;       
 
  TRef event;  
 
  ClassDef(ParticleMCbase, 4)
};
 
// 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_