DPPythia8Generator Class Reference

#include <DPPythia8Generator.h>

Inheritance diagram for DPPythia8Generator:

Collaboration diagram for DPPythia8Generator:

Public Member Functions
	DPPythia8Generator ()
	~DPPythia8Generator () override
Bool_t	ReadEvent (FairPrimaryGenerator *) override
void	SetParameters (char *)
void	Print ()
void	List (int id)
Bool_t	Init () override
Bool_t	Init (const char *inFile) override
Bool_t	Init (const char *inFile, int startEvent) override
void	SetMom (Double_t mom)
Double_t	GetMom ()
void	SetId (Double_t id)
void	SetDPId (Int_t id)
Int_t	GetDPId ()
void	SetLmin (Double_t z)
void	SetLmax (Double_t z)
void	SetSmearBeam (Double_t sb)
void	SetfFDs (Double_t z)
void	UseRandom1 ()
void	UseRandom3 ()
void	SetPbrem (TH2F *pdf)
Bool_t	IsPbrem ()
void	SetDY ()
Double_t	MinDPMass ()
void	SetMinDPMass (Double_t m)
void	UseDeepCopy ()
Int_t	nrOfRetries ()
Int_t	nrOfDP ()
Pythia8::Pythia *	getPythiaInstance ()
Public Member Functions inherited from SHiP::Generator
	Generator ()
virtual	~Generator ()
virtual Bool_t	Init (const char *, int)=0
virtual Bool_t	Init (const char *)=0
virtual Bool_t	Init (const std::vector< std::string > &inFiles, int startNumber)
virtual Bool_t	Init (const std::vector< std::string > &inFiles)
virtual void	UseExternalFile (std::string x, Int_t i)
virtual void	UseExternalFile (std::vector< std::string > &inFiles, Int_t i)

Public Attributes
Pythia8::Pythia *	fPythia

Protected Attributes
Double_t	fMom
Int_t	fDP
Int_t	fId
Bool_t	fUseRandom1
Bool_t	fUseRandom3
Bool_t	fpbrem
TH2F *	fpbremPDF
Bool_t	fdy
Double_t	fDPminM
Double_t	fLmin
Double_t	fLmax
Int_t	fnRetries
Int_t	fnDPtot
Double_t	fctau
Double_t	fFDs
Double_t	fsmearBeam
TFile *	fInputFile
TTree *	fTree
	pointer to a file
Int_t	fNevents
Int_t	fn
Int_t	fShipEventNr
Float_t	hpx [1]
Float_t	hpy [1]
Float_t	hpz [1]
Float_t	hE [1]
Float_t	hM [1]
Float_t	mpx [1]
Float_t	mpy [1]
Float_t	mpz [1]
Float_t	mE [1]
Float_t	hid [1]
Float_t	mid [1]
Bool_t	fDeepCopy
FairLogger *	fLogger
Protected Attributes inherited from SHiP::Generator
std::optional< std::string >	fextFile
Int_t	firstEvent = 0

Private Attributes
std::shared_ptr< Pythia8::RndmEngine >	fRandomEngine

Detailed Description

Definition at line 28 of file DPPythia8Generator.h.

Constructor & Destructor Documentation

DPPythia8Generator()

DPPythia8Generator::DPPythia8Generator

(

)

default constructor

Definition at line 21 of file DPPythia8Generator.cxx.

                                       {
  // fHadDecay = false;
  fId = 2212;           // proton
  fMom = 400;           // proton
  fDP = 9900015;        // DP  pdg code
  fLmin = 5000. * cm;   // mm minimum  decay position z  ROOT units !
  fLmax = 12000. * cm;  // mm maximum decay position z
  fFDs = 7.7 / 10.4;  // correction for Pythia6 to match measured Ds production
  fpbrem = kFALSE;
  fpbremPDF = 0;
  fdy = kFALSE;
  fDPminM = 0.5;
  fInputFile = nullptr;
  fnRetries = 0;
  fnDPtot = 0;
  fShipEventNr = 0;
  fPythia = new Pythia8::Pythia();
  // fPythiaHadDecay =  new Pythia8::Pythia();
}

~DPPythia8Generator()

DPPythia8Generator::~DPPythia8Generator ( )

override

destructor

Definition at line 156 of file DPPythia8Generator.cxx.

{}

Member Function Documentation

GetDPId()

Int_t DPPythia8Generator::GetDPId ( )

inline

Definition at line 61 of file DPPythia8Generator.h.

{ return fDP; };

GetMom()

Double_t DPPythia8Generator::GetMom ( )

inline

Definition at line 58 of file DPPythia8Generator.h.

{ return fMom; };

getPythiaInstance()

Pythia8::Pythia * DPPythia8Generator::getPythiaInstance ( )

inline

Definition at line 88 of file DPPythia8Generator.h.

{ return fPythia; };

Init() [1/3]

Bool_t DPPythia8Generator::Init ( )

override

Definition at line 43 of file DPPythia8Generator.cxx.

                                {
  if (fUseRandom1) fRandomEngine = std::make_shared<PyTr1Rng>();
  if (fUseRandom3) fRandomEngine = std::make_shared<PyTr3Rng>();
  fPythia->setRndmEnginePtr(fRandomEngine);
  // fPythiaHadDecay->setRndmEnginePtr(fRandomEngine);
  fn = 0;
  if (fextFile) {
    /*if (0 == strncmp("/eos",fextFile,4) ) {
     if (0 == strncmp("/eos",fextFile,4) ) {
     TString tmp = gSystem->Getenv("EOSSHIP");
     tmp+=fextFile;
     fInputFile  = TFile::Open(tmp);
     fLogger->Info(MESSAGE_ORIGIN,""Open external file with charm or beauty
    hadrons on eos: %s",tmp->Data()); if (!fInputFile) {
      fLogger->Fatal(MESSAGE_ORIGIN, "Error opening input file. You may have
    forgotten to provide a krb5 token. Try kinit username@lxplus.cern.ch");
      return kFALSE; }
    }else{
      fLogger->Info(MESSAGE_ORIGIN,"Open external file with charm or beauty
    hadrons: %s",fextFile); fInputFile  = new TFile(fextFile->c_str()); if
    (!fInputFile) { fLogger->Fatal(MESSAGE_ORIGIN, "Error opening input file");
    return kFALSE;
    }
    }
    if (fInputFile->IsZombie()) {
     fLogger->Fatal(MESSAGE_ORIGIN, "File is corrupted");
     return kFALSE; }
     fTree = (TTree *)fInputFile->Get("pythia6");
     fNevents = fTree->GetEntries();
     fn = firstEvent;
     fTree->SetBranchAddress("id",&hid);                // particle id
     fTree->SetBranchAddress("px",&hpx);   // momentum
     fTree->SetBranchAddress("py",&hpy);
     fTree->SetBranchAddress("pz",&hpz);
     fTree->SetBranchAddress("E",&hE);
     fTree->SetBranchAddress("M",&hM);
     fTree->SetBranchAddress("mid",&mid);   // mother
     fTree->SetBranchAddress("mpx",&mpx);   // momentum
     fTree->SetBranchAddress("mpy",&mpy);
     fTree->SetBranchAddress("mpz",&mpz);
     fTree->SetBranchAddress("mE",&mE);
    */
  } else if (!fpbrem) {
    if (debug) {
      std::cout << "Beam Momentum " << fMom << std::endl;
    }
    fPythia->settings.mode("Beams:idA", fId);
    fPythia->settings.mode("Beams:idB", 2212);
    fPythia->settings.mode("Beams:frameType", 2);
    fPythia->settings.parm("Beams:eA", fMom);  // codespell:ignore parm
    fPythia->settings.parm("Beams:eB", 0.);    // codespell:ignore parm
 
    if (fdy)
      fPythia->settings.parm("PhaseSpace:mHatMin",  // codespell:ignore parm
                             fDPminM);
 
  } else {
    if (!fpbremPDF) {
      // std::cout << " Failed in retrieving dark photon PDF for production by
      // proton bremstrahlung! Exiting..." << std::endl;
      LOG(fatal) << "Failed in retrieving dark photon PDF for production by "
                    "proton bremstrahlung!";
      return kFALSE;
    }
  }
  /*if (fHadDecay) {
    std::cout << " ******************************** " << std::endl
              << " ** Initialise Pythia for e+e-->hadrons " << std::endl
              << " ******************************** " << std::endl
              << " Mass of the A: " << fPythia->particleData.m0(fDP) << " GeV"
    << std::endl; fPythiaHadDecay->settings.mode("Beams:idA",  11);
    fPythiaHadDecay->settings.mode("Beams:idB",  -11);
    fPythiaHadDecay->settings.mode("Beams:frameType",  1);
    fPythiaHadDecay->settings.parm("Beams:eCM",10);  // codespell:ignore parm
    fPythiaHadDecay->readString("WeakSingleBoson:ffbar2ffbar(s:gm) = on");
    //fPythiaHadDecay->readString("23:isResonance = true")
     //force to hadrons
    fPythiaHadDecay->readString("23:onMode = off");
    fPythiaHadDecay->readString("23:onIfAny = 1 2 3 4 5");
    }*/
  TDatabasePDG* pdgBase = TDatabasePDG::Instance();
  Double_t root_ctau = pdgBase->GetParticle(fDP)->Lifetime();
  // fPythia->particleData.readString("4900023:useBreitWigner = false");
  if (debug) {
    std::cout << "Final particle parameters for PDGID " << fDP << ":"
              << std::endl;
    List(fDP);
  }
  if (debug) {
    std::cout << "tau root PDG database " << root_ctau
              << "[s] ctau root = " << root_ctau * 3e10 << "[cm]" << std::endl;
  }
  fctau = fPythia->particleData.tau0(fDP);  //* 3.3333e-12
  if (debug) {
    std::cout << "ctau pythia " << fctau << "[mm]" << std::endl;
  }
  int initPass = fPythia->init();
  if (debug) {
    std::cout << "Pythia initialisation bool: " << initPass << std::endl;
  }
 
  if (!initPass) {
    LOG(fatal) << "Pythia initialisation failed";
    return kFALSE;
  }
 
  return kTRUE;
  // if (fHadDecay) fPythiaHadDecay->init();
  // return kTRUE;
}

Init() [2/3]

Bool_t DPPythia8Generator::Init ( const char *  inFile )

inlineoverridevirtual

Implements SHiP::Generator.

Definition at line 49 of file DPPythia8Generator.h.

{ return Init(inFile, 0); };

Init() [3/3]

Bool_t DPPythia8Generator::Init ( const char *  inFile, int  startEvent  )

inlineoverridevirtual

Implements SHiP::Generator.

Definition at line 51 of file DPPythia8Generator.h.

                                                           {
    LOG(warning) << "Init with files not implemented for DPPythia8Generator. "
                    "Using default Init() instead";
    return Init();
  };

IsPbrem()

Bool_t DPPythia8Generator::IsPbrem ( )

inline

Definition at line 79 of file DPPythia8Generator.h.

{ return fpbrem; };

List()

void DPPythia8Generator::List ( int  id )

inline

Definition at line 40 of file DPPythia8Generator.h.

{ fPythia->particleData.list(id); };

MinDPMass()

Double_t DPPythia8Generator::MinDPMass ( )

inline

Definition at line 82 of file DPPythia8Generator.h.

{ return fDPminM; };

nrOfDP()

Int_t DPPythia8Generator::nrOfDP ( )

inline

Definition at line 87 of file DPPythia8Generator.h.

{ return fnDPtot; };

nrOfRetries()

Int_t DPPythia8Generator::nrOfRetries ( )

inline

Definition at line 86 of file DPPythia8Generator.h.

{ return fnRetries; };

Print()

void DPPythia8Generator::Print ( )

inline

Definition at line 39 of file DPPythia8Generator.h.

{ fPythia->settings.listAll(); };

ReadEvent()

Bool_t DPPythia8Generator::ReadEvent ( FairPrimaryGenerator *  cpg )

override

public method ReadEvent

Definition at line 160 of file DPPythia8Generator.cxx.

                                                              {
  Double_t tp, tS, zp, xp, yp, zS, xS, yS, pz, px, py, e, w;
  Double_t tm, zm, xm, ym, pmz, pmx, pmy, em;
  // Double_t td,zd,xd,yd;
  Int_t im;
  // take DP decay of Pythia, move it to the SHiP decay region
  // recalculate decay time
  // weight event with exp(-t_ship/tau_DP) / exp(-t_pythia/tau_DP)
 
  int iDP =
      0;  // index of the chosen DP, also ensures that at least 1 DP is produced
  std::vector<int>
      dec_chain;  // pythia indices of the particles to be stored on the stack
  std::vector<int> dpvec;  // pythia indices of DP particles
  do {
    if (fextFile) {
      // take charm or beauty hadron from external file
      // correct for too much Ds produced by pythia6
      /*bool x = true;
        while(x){
        if (fn==fNevents) {fLogger->Warning(MESSAGE_ORIGIN, "End of input file.
        Rewind.");} fTree->GetEntry(fn%fNevents); fn++; if ( int(fabs(hid[0]) )
        != 431){ x = false; } else { Double_t rnr = gRandom->Uniform(0,1); if(
        rnr<fFDs ) { x = false; };
        //std::cout<<"what is x "<<x<<" id "<<int(fabs(hid[0]))<<" rnr " << rnr
        <<" "<< fFDs <<std::endl ;
        }
        }
        fPythia->event.reset();
        fPythia->event.append( (Int_t)hid[0], 1, 0, 0, hpx[0],  hpy[0],  hpz[0],
        hE[0],  hM[0], 0., 9. );
      */
    }
    // bit for proton brem
    if (fpbrem) {
      fPythia->event.reset();
      double dpmom = 0;
      double thetain = 0;
      fpbremPDF->GetRandom2(dpmom, thetain);
      double dpm = fPythia->particleData.m0(fDP);
      double dpe = sqrt(dpmom * dpmom + dpm * dpm);
      double phiin = 2. * M_PI * gRandom->Rndm();
 
      if (debug > 1) {
        std::cout << " Adding DP gun with p " << dpmom << " m " << dpm << " e "
                  << dpe << " theta,phi " << thetain << "," << phiin
                  << std::endl
                  << std::flush;
      }
      fPythia->event.append(fDP, 1, 0, 0, dpmom * sin(thetain) * cos(phiin),
                            dpmom * sin(thetain) * sin(phiin),
                            dpmom * cos(thetain), dpe, dpm);
    }
 
    if (!fPythia->next()) LOG(fatal) << "fPythia->next() failed";
 
    // fPythia->event.list();
    for (int i = 0; i < fPythia->event.size(); i++) {
      // find all DP
      if (abs(fPythia->event[i].id()) == fDP) {
        dpvec.push_back(i);
      }
    }
    iDP = dpvec.size();
    fnDPtot += iDP;
    if (iDP == 0) {
      // fLogger->Info(MESSAGE_ORIGIN,"Event without DP. Retry.");
      // fPythia->event.list();
      fnRetries +=
          1;  // can happen if phasespace does not allow meson to decay to DP
    } else {
      // for mesons, could have more than one ... but for DY prod, need to take
      // the last one... int r =  int( gRandom->Uniform(0,iDP) );
      int r = iDP - 1;
      // std::cout << " ----> debug 2 " << r  <<  std::endl;
      int i = dpvec[r];
      // production vertex
      zp = fPythia->event[i].zProd();
      xp = fPythia->event[i].xProd();
      yp = fPythia->event[i].yProd();
      tp = fPythia->event[i].tProd();
      // momentum
      pz = fPythia->event[i].pz();
      px = fPythia->event[i].px();
      py = fPythia->event[i].py();
      e = fPythia->event[i].e();
      // old decay vertex
      // Int_t ida =fPythia->event[i].daughter1();
      std::cout << " Debug: decay product of A: "
                << fPythia->event[fPythia->event[i].daughter1()].id() << " "
                << fPythia->event[fPythia->event[i].daughter2()].id()
                << std::endl;
      // hadDecay = abs(fPythia->event[ida].id())!=11 &&
      // abs(fPythia->event[ida].id())!=13 && abs(fPythia->event[ida].id())!=15;
 
      // zd =fPythia->event[ida].zProd();
      // xd =fPythia->event[ida].xProd();
      // yd =fPythia->event[ida].yProd();
      // td =fPythia->event[ida].tProd();
      //  new decay vertex
      Double_t LS = gRandom->Uniform(fLmin, fLmax);  // mm, G4 and Pythia8 units
      Double_t p = TMath::Sqrt(px * px + py * py + pz * pz);
      Double_t lam = LS / p;
      xS = xp + lam * px;
      yS = yp + lam * py;
      zS = zp + lam * pz;
      Double_t gam = e / TMath::Sqrt(e * e - p * p);
      Double_t beta = p / e;
      tS = tp + LS / beta;  // units ? [mm/c] + [mm/beta] (beta is dimensionless
                            // speed, and c=1 here)
      // if one would use [s], then tS = tp/(cm*c_light) +
      // (LS/cm)/(beta*c_light) = tS/(cm*c_light) i.e. units look consistent
      w = TMath::Exp(-LS / (beta * gam * fctau)) *
          ((fLmax - fLmin) / (beta * gam * fctau));
      im = (Int_t)fPythia->event[i].mother1();
      zm = fPythia->event[im].zProd();
      xm = fPythia->event[im].xProd();
      ym = fPythia->event[im].yProd();
      pmz = fPythia->event[im].pz();
      pmx = fPythia->event[im].px();
      pmy = fPythia->event[im].py();
      em = fPythia->event[im].e();
      tm = fPythia->event[im].tProd();
      // foresee finite beam size
      Double_t dx = 0;
      Double_t dy = 0;
      if (fsmearBeam > 0) {
        Double_t test = fsmearBeam * fsmearBeam;
        Double_t Rsq = test + 1.;
        while (Rsq > test) {
          dx = gRandom->Uniform(-1., 1.) * fsmearBeam;
          dy = gRandom->Uniform(-1., 1.) * fsmearBeam;
          Rsq = dx * dx + dy * dy;
        }
      }
      if (fextFile) {
        // take grand mother particle from input file, to know if primary or
        // secondary production
        // cpg->AddTrack((Int_t)mid[0],mpx[0],mpy[0],mpz[0],xm/cm+dx,ym/cm+dy,zm/cm,-1,false,mE[0],0.,1.);
        // cpg->AddTrack((Int_t)fPythia->event[im].id(),pmx,pmy,pmz,xm/cm+dx,ym/cm+dy,zm/cm,0,false,em,tm/cm/c_light,w);
        // // convert pythia's (x,y,z[mm], t[mm/c]) to ([cm], [s])
        // cpg->AddTrack(fDP, px, py, pz, xp/cm+dx,yp/cm+dy,zp/cm,
        // 1,false,e,tp/cm/c_light,w);
      } else {
        cpg->AddTrack(
            (Int_t)fPythia->event[im].id(), pmx, pmy, pmz, xm / cm + dx,
            ym / cm + dy, zm / cm, -1, false, em, tm / cm / c_light,
            w);  // convert pythia's (x,y,z[mm], t[mm/c]) to ([cm], [s])
        cpg->AddTrack(fDP, px, py, pz, xp / cm + dx, yp / cm + dy, zp / cm, 0,
                      false, e, tp / cm / c_light, w);
      }
      // bookkeep the indices of stored particles
      dec_chain.push_back(im);
      dec_chain.push_back(i);
      if (debug > 1)
        std::cout << std::endl
                  << " insert mother id " << im
                  << " pdg=" << fPythia->event[im].id() << " pmz = " << pmz
                  << " [GeV],  zm = " << zm << " [mm] tm = " << tm << " [mm/c]"
                  << std::endl;
      if (debug > 1)
        std::cout << " ----> insert DP id " << i << " pdg=" << fDP
                  << " pz = " << pz << " [GeV] zp = " << zp
                  << " [mm] tp = " << tp << " [mm/c]" << std::endl;
      iDP = i;
    }
  } while (iDP ==
           0);  // ----------- avoid rare empty events w/o any DP's produced
 
  if (fShipEventNr % 100 == 0) {
    LOGF(info, "ship event %i / pythia event-nr %i", fShipEventNr, fn);
  }
  fShipEventNr += 1;
  // fill a container with pythia indices of the DP decay chain
  if (debug > 1) std::cout << "Filling daughter particles" << std::endl;
  // if (!hadDecay){
  for (int k = 0; k < fPythia->event.size(); k++) {
    // if daughter of DP, copy
    if (debug > 1)
      std::cout << k << " pdg =" << fPythia->event[k].id() << " mum "
                << fPythia->event[k].mother1() << std::endl;
    im = fPythia->event[k].mother1();
    while (im > 0) {
      if (im == iDP) {
        break;
      }  // pick the decay products of only 1 chosen DP
      // if ( abs(fPythia->event[im].id())==fDP && im == iDP ){break;}
      else {
        im = fPythia->event[im].mother1();
      }
    }
    if (im < 1) {
      if (debug > 1) std::cout << "reject" << std::endl;
      continue;
    }
    if (debug > 1) std::cout << "accept" << std::endl;
    dec_chain.push_back(k);
  }
  //}
  /*else {
  //get decay from e+e- collision.....
  fPythiaHadDecay->settings.parm("Beams:eCM",20);  // codespell:ignore parm
  fPythiaHadDecay->next();
  for (int k=0; k<fPythiaHadDecay->event.size(); k++){
    fPythia->event.append(
  fPythiaHadDecay->event[k].id(),fPythiaHadDecay->event[k].status()
  ,fPythiaHadDecay->event[k].mother1() , fPythiaHadDecay->event[k].mother2(),
  fPythiaHadDecay->event[k].daughter1(), fPythiaHadDecay->event[k].daughter2(),
  fPythiaHadDecay->event[k].col(), fPythiaHadDecay->event[k].acol(),
  fPythiaHadDecay->event[k].px(),  fPythiaHadDecay->event[k].py(),
  fPythiaHadDecay->event[k].pz(), fPythiaHadDecay->event[k].e(),
  fPythiaHadDecay->event[k].m(), 0., 9. ); dec_chain.push_back(
  fPythia->event.size()-1 ); std::cout << " Adding decay product: " << k << " "
              << fPythiaHadDecay->event[k].id() << " "
              << fPythiaHadDecay->event[k].status() << " "
              << fPythiaHadDecay->event[k].mother1() << " "
              << fPythiaHadDecay->event[k].mother2() << " "
              << std::endl;
  }
  }*/
 
  // go over daughters and store them on the stack, starting from 2 to account
  // for DP and its mother
  for (std::vector<int>::iterator it = dec_chain.begin() + 2;
       it != dec_chain.end(); ++it) {
    // pythia index of the particle to store
    int k = *it;
    // find mother position on the output stack: impy -> im
    int impy = fPythia->event[k].mother1();
    std::vector<int>::iterator itm =
        std::find(dec_chain.begin(), dec_chain.end(), impy);
    im = -1;  // safety
    if (itm != dec_chain.end())
      im = itm - dec_chain.begin();  // convert iterator into sequence number
 
    Bool_t wanttracking = false;
    if (fPythia->event[k].isFinal()) {
      wanttracking = true;
    }
    pz = fPythia->event[k].pz();
    px = fPythia->event[k].px();
    py = fPythia->event[k].py();
    e = fPythia->event[k].e();
    if (fextFile) {
      im += 1;
    };
    cpg->AddTrack((Int_t)fPythia->event[k].id(), px, py, pz, xS / cm, yS / cm,
                  zS / cm, im, wanttracking, e, tS / cm / c_light, w);
    // std::cout <<k<< " insert pdg =" <<fPythia->event[k].id() << " pz = " <<
    // pz << " [GeV] zS = " << zS << " [mm] tS = " << tS << "[mm/c]" <<
    // std::endl;
  }
  return kTRUE;
}

SetDPId()

void DPPythia8Generator::SetDPId ( Int_t  id )

inline

Definition at line 60 of file DPPythia8Generator.h.

{ fDP = id; };

SetDY()

void DPPythia8Generator::SetDY ( )

inline

Definition at line 80 of file DPPythia8Generator.h.

{ fdy = kTRUE; };

SetfFDs()

void DPPythia8Generator::SetfFDs ( Double_t  z )

inline

Definition at line 65 of file DPPythia8Generator.h.

{ fFDs = z; };

SetId()

void DPPythia8Generator::SetId ( Double_t  id )

inline

Definition at line 59 of file DPPythia8Generator.h.

{ fId = id; };

SetLmax()

void DPPythia8Generator::SetLmax ( Double_t  z )

inline

Definition at line 63 of file DPPythia8Generator.h.

{ fLmax = z * 10; };

SetLmin()

void DPPythia8Generator::SetLmin ( Double_t  z )

inline

Definition at line 62 of file DPPythia8Generator.h.

{ fLmin = z * 10; };

SetMinDPMass()

void DPPythia8Generator::SetMinDPMass ( Double_t  m )

inline

Definition at line 83 of file DPPythia8Generator.h.

{ fDPminM = m; };

SetMom()

void DPPythia8Generator::SetMom ( Double_t  mom )

inline

Definition at line 57 of file DPPythia8Generator.h.

{ fMom = mom; };

SetParameters()

void DPPythia8Generator::SetParameters

(

char *

par

)

Definition at line 415 of file DPPythia8Generator.cxx.

                                                {
  // Set Parameters
  fPythia->readString(par);
  if (debug) {
    std::cout << "fPythia->readString(\"" << par << "\")" << std::endl;
  }
}

SetPbrem()

void DPPythia8Generator::SetPbrem ( TH2F *  pdf )

inline

Definition at line 75 of file DPPythia8Generator.h.

                           {
    fpbrem = kTRUE;
    fpbremPDF = pdf;
  };

SetSmearBeam()

void DPPythia8Generator::SetSmearBeam ( Double_t  sb )

inline

Definition at line 64 of file DPPythia8Generator.h.

{ fsmearBeam = sb; };

UseDeepCopy()

void DPPythia8Generator::UseDeepCopy ( )

inline

Definition at line 85 of file DPPythia8Generator.h.

{ fDeepCopy = kTRUE; };

UseRandom1()

void DPPythia8Generator::UseRandom1 ( )

inline

Definition at line 66 of file DPPythia8Generator.h.

                    {
    fUseRandom1 = kTRUE;
    fUseRandom3 = kFALSE;
  };

UseRandom3()

void DPPythia8Generator::UseRandom3 ( )

inline

Definition at line 70 of file DPPythia8Generator.h.

                    {
    fUseRandom1 = kFALSE;
    fUseRandom3 = kTRUE;
  };

Member Data Documentation

fctau

Double_t DPPythia8Generator::fctau

protected

Definition at line 113 of file DPPythia8Generator.h.

fDeepCopy

Bool_t DPPythia8Generator::fDeepCopy

protected

Definition at line 121 of file DPPythia8Generator.h.

fDP

Int_t DPPythia8Generator::fDP

protected

Definition at line 97 of file DPPythia8Generator.h.

fDPminM

Double_t DPPythia8Generator::fDPminM

protected

Definition at line 107 of file DPPythia8Generator.h.

fdy

Bool_t DPPythia8Generator::fdy

protected

Definition at line 106 of file DPPythia8Generator.h.

fFDs

Double_t DPPythia8Generator::fFDs

protected

Definition at line 114 of file DPPythia8Generator.h.

fId

Int_t DPPythia8Generator::fId

protected

Definition at line 98 of file DPPythia8Generator.h.

fInputFile

TFile* DPPythia8Generator::fInputFile

protected

Definition at line 116 of file DPPythia8Generator.h.

fLmax

Double_t DPPythia8Generator::fLmax

protected

Definition at line 110 of file DPPythia8Generator.h.

fLmin

Double_t DPPythia8Generator::fLmin

protected

Definition at line 109 of file DPPythia8Generator.h.

fLogger

FairLogger* DPPythia8Generator::fLogger

protected

Definition at line 122 of file DPPythia8Generator.h.

fMom

Double_t DPPythia8Generator::fMom

protected

Definition at line 96 of file DPPythia8Generator.h.

fn

Int_t DPPythia8Generator::fn

protected

Definition at line 118 of file DPPythia8Generator.h.

fnDPtot

Int_t DPPythia8Generator::fnDPtot

protected

Definition at line 112 of file DPPythia8Generator.h.

fNevents

Int_t DPPythia8Generator::fNevents

protected

Definition at line 118 of file DPPythia8Generator.h.

fnRetries

Int_t DPPythia8Generator::fnRetries

protected

Definition at line 111 of file DPPythia8Generator.h.

fpbrem

Bool_t DPPythia8Generator::fpbrem

protected

Definition at line 102 of file DPPythia8Generator.h.

fpbremPDF

TH2F* DPPythia8Generator::fpbremPDF

protected

Definition at line 103 of file DPPythia8Generator.h.

fPythia

Pythia8::Pythia* DPPythia8Generator::fPythia

Definition at line 89 of file DPPythia8Generator.h.

fRandomEngine

std::shared_ptr<Pythia8::RndmEngine> DPPythia8Generator::fRandomEngine

private

Definition at line 92 of file DPPythia8Generator.h.

fShipEventNr

Int_t DPPythia8Generator::fShipEventNr

protected

Definition at line 118 of file DPPythia8Generator.h.

fsmearBeam

Double_t DPPythia8Generator::fsmearBeam

protected

Definition at line 115 of file DPPythia8Generator.h.

fTree

TTree* DPPythia8Generator::fTree

protected

pointer to a file

Definition at line 117 of file DPPythia8Generator.h.

fUseRandom1

Bool_t DPPythia8Generator::fUseRandom1

protected

Definition at line 99 of file DPPythia8Generator.h.

fUseRandom3

Bool_t DPPythia8Generator::fUseRandom3

protected

Definition at line 100 of file DPPythia8Generator.h.

hE

Float_t DPPythia8Generator::hE[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

hid

Float_t DPPythia8Generator::hid[1]

protected

Definition at line 120 of file DPPythia8Generator.h.

hM

Float_t DPPythia8Generator::hM[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

hpx

Float_t DPPythia8Generator::hpx[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

hpy

Float_t DPPythia8Generator::hpy[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

hpz

Float_t DPPythia8Generator::hpz[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

mE

Float_t DPPythia8Generator::mE[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

mid

Float_t DPPythia8Generator::mid[1]

protected

Definition at line 120 of file DPPythia8Generator.h.

mpx

Float_t DPPythia8Generator::mpx[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

mpy

Float_t DPPythia8Generator::mpy[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

mpz

Float_t DPPythia8Generator::mpz[1]

protected

Definition at line 119 of file DPPythia8Generator.h.

---

The documentation for this class was generated from the following files:

• shipgen/DPPythia8Generator.h
• shipgen/DPPythia8Generator.cxx