EventPythia.h

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

#ifndef INCLUDE_EICSMEAR_ERHIC_EVENTPYTHIA_H_
#define INCLUDE_EICSMEAR_ERHIC_EVENTPYTHIA_H_

#include <string>

#include <Rtypes.h>

#include "eicsmear/erhic/EventMC.h"

namespace erhic {

class EventPythia : public EventMC {
 public:
  explicit EventPythia(const std::string& str = "");

  virtual ~EventPythia();

  virtual bool Parse(const std::string&);

  virtual void SetNucleon(int n);

  virtual void SetTargetParton(int n);

  virtual void SetBeamParton(int n);

  virtual void SetGenEvent(int n);

  virtual void SetTargetPartonX(double xB);

  virtual void SetBeamPartonX(double xB);

  virtual void SetBeamPartonTheta(double radians);

  virtual void SetLeptonPhi(double radians);

  virtual void SetF1(double f1);

  virtual void SetF2(double f2);

  virtual void SetSigmaRad(double sr);

  virtual void SetHardS(double s);

  virtual void SetHardT(double t);

  virtual void SetHardU(double u);

  virtual void SetHardQ2(double Q2);

  virtual void SetHardPt2(double pt2);

  virtual void SetSigRadCor(double s);

  virtual void SetEBrems(double e);

  virtual void SetPhotonFlux(double f);

  virtual void SetTrueY(double inelasticity);

  virtual void SetTrueQ2(double Q2);

  virtual void SetTrueX(double x);

  virtual void SetTrueW2(double W2);

  virtual void SetTrueNu(double Nu);

  virtual void SetR(double r);

  virtual int GetGenEvent() const;

  virtual double GetTargetPartonX() const;

  virtual double GetBeamPartonX() const;

  virtual double GetBeamPartonTheta() const;

  virtual double GetLeptonPhi() const;

  virtual double GetF1() const;

  virtual double GetF2() const;

  virtual double GetSigmaRad() const;

  virtual double GetHardS() const;

  virtual double GetHardT() const;

  virtual double GetHardU() const;

  virtual double GetHardQ2() const;

  virtual double GetHardPt2() const;

  virtual double GetSigRadCor() const;

  virtual double GetEBrems() const;

  virtual double GetPhotonFlux() const;

  virtual double GetTrueY() const;

  virtual double GetTrueQ2() const;

  virtual double GetTrueX() const;

  virtual double GetTrueW2() const;

  virtual double GetTrueNu() const;

  virtual double GetR() const;

  virtual const ParticleMC* ScatteredLepton() const;

  // Let them all be public; this access method dances for POD does not make sense;
  //protected:
  // Inline comments after field names will appear in ROOT
  // when EventPythia::Dump() is called.
  Int_t       nucleon;          

  Int_t       tgtparton;        

  Int_t       beamparton;       


  Int_t       genevent;         
  Double32_t  xtgtparton;       

  Double32_t  xbeamparton;      

  Double32_t  thetabeamparton;  


  Double32_t  leptonphi;        

  Double32_t  F1;               
  Double32_t  sigma_rad;        
  Double32_t  t_hat;            

  Double32_t  u_hat;            

  Double32_t  Q2_hat;           

  Double32_t  SigRadCor;        
  Double32_t  EBrems;           

  Double32_t  photonflux;       
  Double32_t  trueY;            

  Double32_t  trueQ2;           

  Double32_t  trueX;            
  Double32_t  trueW2;           
  Double32_t  trueNu;           
  Double32_t  F2;               
  Double32_t  R;                
  Double32_t  pt2_hat;          

  Double32_t  sHat;             

  ClassDef(erhic::EventPythia, 2)
};

inline void EventPythia::SetNucleon(int n) {
  nucleon = n;
}

inline void EventPythia::SetTargetParton(int n) {
  tgtparton = n;
}

inline void EventPythia::SetBeamParton(int n) {
  beamparton = n;
}

inline void EventPythia::SetGenEvent(int n) {
  genevent = n;
}

inline void EventPythia::SetTargetPartonX(double xB) {
  xtgtparton = xB;
}

inline void EventPythia::SetBeamPartonX(double xB) {
  xbeamparton = xB;
}

inline void EventPythia::SetBeamPartonTheta(double radians) {
  thetabeamparton = radians;
}

inline void EventPythia::SetLeptonPhi(double radians) {
  leptonphi = radians;
}

inline void EventPythia::SetF1(double f1) {
  F1 = f1;
}

inline void EventPythia::SetF2(double f2) {
  F2 = f2;
}

inline void EventPythia::SetSigmaRad(double sr) {
  sigma_rad = sr;
}

inline void EventPythia::SetHardS(double s) {
  sHat = s;
}

inline void EventPythia::SetHardT(double t) {
  t_hat = t;
}

inline void EventPythia::SetHardU(double u) {
  u_hat = u;
}

inline void EventPythia::SetHardQ2(double Q2) {
  Q2_hat = Q2;
}

inline void EventPythia::SetHardPt2(double pt2) {
  pt2_hat = pt2;
}

inline void EventPythia::SetSigRadCor(double s) {
  SigRadCor = s;
}

inline void EventPythia::SetEBrems(double e) {
  EBrems = e;
}

inline void EventPythia::SetPhotonFlux(double f) {
  photonflux = f;
}

inline void EventPythia::SetTrueY(double inelasticity) {
  trueY = inelasticity;
}

inline void EventPythia::SetTrueQ2(double Q2) {
  trueQ2 = Q2;
}

inline void EventPythia::SetTrueX(double xB) {
  trueX = xB;
}

inline void EventPythia::SetTrueW2(double W2) {
  trueW2 = W2;
}

inline void EventPythia::SetTrueNu(double Nu) {
  trueNu = Nu;
}

inline void EventPythia::SetR(double r) {
  R = r;
}

inline int EventPythia::GetGenEvent() const {
  return genevent;
}

inline double EventPythia::GetTargetPartonX() const {
  return xtgtparton;
}

inline double EventPythia::GetBeamPartonX() const {
  return xbeamparton;
}

inline double EventPythia::GetBeamPartonTheta() const {
  return thetabeamparton;
}

inline double EventPythia::GetLeptonPhi() const {
  return leptonphi;
}

inline double EventPythia::GetF1() const {
  return F1;
}

inline double EventPythia::GetF2() const {
  return F2;
}

inline double EventPythia::GetSigmaRad() const {
  return sigma_rad;
}

inline double EventPythia::GetHardS() const {
  return sHat;
}

inline double EventPythia::GetHardT() const {
  return t_hat;
}

inline double EventPythia::GetHardU() const {
  return u_hat;
}

inline double EventPythia::GetHardQ2() const {
  return Q2_hat;
}

inline double EventPythia::GetHardPt2() const {
  return pt2_hat;
}

inline double EventPythia::GetSigRadCor() const {
  return SigRadCor;
}

inline double EventPythia::GetEBrems() const {
  return EBrems;
}

inline double EventPythia::GetPhotonFlux() const {
  return photonflux;
}

inline double EventPythia::GetTrueY() const {
  return trueY;
}

inline double EventPythia::GetTrueQ2() const {
  return trueQ2;
}

inline double EventPythia::GetTrueX() const {
  return trueX;
}

inline double EventPythia::GetTrueW2() const {
  return trueW2;
}

inline double EventPythia::GetTrueNu() const {
  return trueNu;
}

inline double EventPythia::GetR() const {
  return R;
}


class EventBeagle : public EventPythia {
 public:
  explicit EventBeagle(const std::string& str = "");

  ~EventBeagle();

  bool RequiresEaParticleFields() { return true; };

  bool Parse(const std::string&);

  //put in the public region to be easily accessed
  Int_t lepton;  
  Int_t Atarg;   
  Int_t Ztarg;   
  Double32_t pzlep;   
  Double32_t pztarg;    
  Double32_t pznucl;    
  Double32_t crang;     
  Double32_t crori;     
  Double32_t b;   
  Double32_t Phib;    
  Double32_t Thickness; 
  Double32_t ThickScl; 
  Int_t Ncollt; 
  Int_t Ncolli; 
  Int_t Nwound; 
  Int_t Nwdch; 
  Int_t Nnevap; 
  Int_t Npevap; 
  Int_t Aremn; 
  Int_t NINC; 
  Int_t NINCch; 
  Double32_t d1st; 
  Double32_t davg; 
  Double32_t pxf; 
  Double32_t pyf; 
  Double32_t pzf; 
  Double32_t Eexc; 
  Double32_t RAevt; 
  Double32_t User1; 
  Double32_t User2; 
  Double32_t User3; 

  ClassDef(erhic::EventBeagle, 1)
};

}  // namespace erhic

#endif  // INCLUDE_EICSMEAR_ERHIC_EVENTPYTHIA_H_