erhic/EventPythia.h

Go to the documentation of this file.

 
#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_