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 EventMC;
class ParticleMC : public VirtualParticle {
 public:
  explicit ParticleMC(const std::string& = "");

  virtual ~ParticleMC();

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

  virtual UInt_t GetIndex() const;

  virtual UShort_t GetStatus() const;

  virtual UShort_t GetParentIndex() const;

  virtual const ParticleMC* GetParent() const;

  virtual UShort_t GetChild1Index() const;

  virtual UShort_t GetChildNIndex() const;

  virtual UInt_t GetNChildren() const;

  virtual const ParticleMC* GetChild(UShort_t) const;

  virtual Bool_t HasChild(Int_t) 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;            
  Int_t       id;            
  UShort_t    orig;          
  UShort_t    daughter;      
  UShort_t    ldaughter;     

  Double32_t px;           
  Double32_t py;           
  Double32_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;           
  Double32_t xv;           
  Double32_t yv;           
  Double32_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(ParticleMC, 1)
};

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

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

inline UShort_t ParticleMC::GetParentIndex() const {
  return orig;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}  // namespace erhic

#endif  // INCLUDE_EICSMEAR_ERHIC_PARTICLEMC_H_