Inheritance diagram for gen::Py8PtAndDxyGun:

Public Member Functions
const char *	classname () const override

bool	generatePartonsAndHadronize () override

	Py8PtAndDxyGun (edm::ParameterSet const &)

	~Py8PtAndDxyGun () override

Public Member Functions inherited from gen::Py8GunBase
void	evtGenDecay ()

void	finalizeEvent () override

bool	initializeForInternalPartons () override

	Py8GunBase (edm::ParameterSet const &ps)

virtual bool	residualDecay ()

void	setRandomEngine (CLHEP::HepRandomEngine *v)

std::vector< std::string > const &	sharedResources () const

void	statistics () override

	~Py8GunBase () override

Public Member Functions inherited from gen::Py8InterfaceBase
bool	decay ()

bool	declareSpecialSettings (const std::vector< std::string > &)

bool	declareStableParticles (const std::vector< int > &)

void	makeTmpSLHA (const std::string &)

void	p8SetRandomEngine (CLHEP::HepRandomEngine *v)

	Py8InterfaceBase (edm::ParameterSet const &ps)

P8RndmEngine &	randomEngine ()

bool	readSettings (int)

	~Py8InterfaceBase () override

Public Member Functions inherited from gen::BaseHadronizer
	BaseHadronizer (edm::ParameterSet const &ps)

void	cleanLHE ()

void	generateLHE (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine, unsigned int ncpu)

edm::Event &	getEDMEvent () const

std::unique_ptr< HepMC::GenEvent >	getGenEvent ()

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

virtual std::unique_ptr< GenLumiInfoHeader >	getGenLumiInfoHeader () const

GenRunInfoProduct &	getGenRunInfo ()

std::unique_ptr< lhef::LHEEvent >	getLHEEvent ()

const std::shared_ptr< lhef::LHERunInfo > &	getLHERunInfo () const

const std::string &	gridpackPath () const

int	randomIndex () const

const std::string &	randomInitConfigDescription () const

void	randomizeIndex (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine)

void	resetEvent (std::unique_ptr< HepMC::GenEvent > event)

void	resetEventInfo (std::unique_ptr< GenEventInfoProduct > eventInfo)

virtual bool	select (HepMC::GenEvent *) const

void	setEDMEvent (edm::Event &event)

void	setLHEEvent (std::unique_ptr< lhef::LHEEvent > event)

void	setLHERunInfo (std::unique_ptr< lhef::LHERunInfo > runInfo)

void	setRandomEngine (CLHEP::HepRandomEngine *v)

std::vector< std::string > const &	sharedResources () const

virtual	~BaseHadronizer () noexcept(false)

Private Attributes
bool	fAddAntiParticle

double	fConeH

double	fConeRadius

double	fDistanceToAPEX

double	fDxyMax

double	fDxyMin

double	fLxyMax

double	fLzMax

double	fMaxEta

double	fMaxPt

double	fMinEta

double	fMinPt

Additional Inherited Members
Protected Member Functions inherited from gen::BaseHadronizer
std::unique_ptr< HepMC::GenEvent > &	event ()

std::unique_ptr< GenEventInfoProduct > &	eventInfo ()

lhef::LHEEvent *	lheEvent ()

lhef::LHERunInfo *	lheRunInfo ()

GenRunInfoProduct &	runInfo ()

Protected Attributes inherited from gen::Py8GunBase
double	fMaxPhi

double	fMinPhi

std::vector< int >	fPartIDs

Protected Attributes inherited from gen::Py8InterfaceBase
HepMC::IO_AsciiParticles *	ascii_io

std::shared_ptr< Pythia8::EvtGenDecays >	evtgenDecays

std::string	evtgenDecFile

std::string	evtgenPdlFile

std::vector< std::string >	evtgenUserFiles

std::unique_ptr< Pythia8::Pythia >	fDecayer

std::unique_ptr< Pythia8::Pythia >	fMasterGen

edm::ParameterSet	fParameters

unsigned int	maxEventsToPrint

bool	pythiaHepMCVerbosity

bool	pythiaHepMCVerbosityParticles

unsigned int	pythiaPylistVerbosity

std::string	slhafile_

HepMC::Pythia8ToHepMC	toHepMC

bool	useEvtGen

Protected Attributes inherited from gen::BaseHadronizer
std::string	lheFile_

int	randomIndex_

Detailed Description

Definition at line 10 of file Py8PtAndDxyGun.cc.

Constructor & Destructor Documentation

◆ Py8PtAndDxyGun()

gen::Py8PtAndDxyGun::Py8PtAndDxyGun ( edm::ParameterSet const & ps )

Definition at line 36 of file Py8PtAndDxyGun.cc.

                                                           : Py8GunBase(ps) {
     // ParameterSet defpset ;
     edm::ParameterSet pgun_params = ps.getParameter<edm::ParameterSet>("PGunParameters");  // , defpset ) ;
     fMinEta = pgun_params.getParameter<double>("MinEta");                                  // ,-2.2);
     fMaxEta = pgun_params.getParameter<double>("MaxEta");                                  // , 2.2);
     fMinPt = pgun_params.getParameter<double>("MinPt");                                    // ,  0.);
     fMaxPt = pgun_params.getParameter<double>("MaxPt");                                    // ,  0.);
     fAddAntiParticle = pgun_params.getParameter<bool>("AddAntiParticle");                  //, false) ;
     fDxyMin = pgun_params.getParameter<double>("dxyMin");
     fDxyMax = pgun_params.getParameter<double>("dxyMax");
     fLxyMax = pgun_params.getParameter<double>("LxyMax");
     fLzMax = pgun_params.getParameter<double>("LzMax");
     fConeRadius = pgun_params.getParameter<double>("ConeRadius");
     fConeH = pgun_params.getParameter<double>("ConeH");
     fDistanceToAPEX = pgun_params.getParameter<double>("DistanceToAPEX");
   }

References fAddAntiParticle, fConeH, fConeRadius, fDistanceToAPEX, fDxyMax, fDxyMin, fLxyMax, fLzMax, fMaxEta, fMaxPt, fMinEta, fMinPt, and edm::ParameterSet::getParameter().

◆ ~Py8PtAndDxyGun()

gen::Py8PtAndDxyGun::~Py8PtAndDxyGun ( )

inlineoverride

Definition at line 13 of file Py8PtAndDxyGun.cc.

13 {}

Member Function Documentation

◆ classname()

const char * gen::Py8PtAndDxyGun::classname ( ) const

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 176 of file Py8PtAndDxyGun.cc.

176 { return "Py8PtAndDxyGun"; }

◆ generatePartonsAndHadronize()

bool gen::Py8PtAndDxyGun::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 53 of file Py8PtAndDxyGun.cc.

                                                    {
     fMasterGen->event.reset();
  
     for (size_t i = 0; i < fPartIDs.size(); i++) {
       int particleID = fPartIDs[i];  // this is PDG - need to convert to Py8 ???
  
       double phi = 0;
       double dxy = 0;
       double pt = 0;
       double eta = 0;
       double px = 0;
       double py = 0;
       double pz = 0;
       double mass = 0;
       double ee = 0;
       double vx = 0;
       double vy = 0;
       double vz = 0;
       double lxy = 0;
  
       bool passLoop = false;
       while (!passLoop) {
         bool passLxy = false;
         bool passLz = false;
  
         phi = (fMaxPhi - fMinPhi) * randomEngine().flat() + fMinPhi;
         dxy = (fDxyMax - fDxyMin) * randomEngine().flat() + fDxyMin;
         float dxysign = randomEngine().flat() - 0.5;
         if (dxysign < 0)
           dxy = -dxy;
  
         pt = (fMaxPt - fMinPt) * randomEngine().flat() + fMinPt;
         px = pt * cos(phi);
         py = pt * sin(phi);
  
         for (int i = 0; i < 10000; i++) {
           vx = 2 * fLxyMax * randomEngine().flat() - fLxyMax;
           vy = (pt * dxy + vx * py) / px;
           lxy = sqrt(vx * vx + vy * vy);
           if (lxy < std::abs(fLxyMax) && (vx * px + vy * py) > 0) {
             passLxy = true;
             break;
           }
         }
  
         eta = (fMaxEta - fMinEta) * randomEngine().flat() + fMinEta;
         double theta = 2. * atan(exp(-eta));
  
         mass = (fMasterGen->particleData).m0(particleID);
  
         double pp = pt / sin(theta);  // sqrt( ee*ee - mass*mass );
         ee = sqrt(pp * pp + mass * mass);
  
         pz = pp * cos(theta);
  
         float coneTheta = fConeRadius / fConeH;
         for (int j = 0; j < 100; j++) {
           vz = fLzMax * randomEngine().flat();  // this is abs(vz)
           float v0 = vz - fDistanceToAPEX;
           if (v0 <= 0 || lxy * lxy / (coneTheta * coneTheta) > v0 * v0) {
             passLz = true;
             break;
           }
         }
         if (pz < 0)
           vz = -vz;
         passLoop = (passLxy && passLz);
  
         if (passLoop)
           break;
       }
  
       float time = sqrt(vx * vx + vy * vy + vz * vz);
  
       if (!((fMasterGen->particleData).isParticle(particleID))) {
         particleID = std::abs(particleID);
       }
       if (1 <= std::abs(particleID) && std::abs(particleID) <= 6)  // quarks
         (fMasterGen->event).append(particleID, 23, 101, 0, px, py, pz, ee, mass);
       else if (std::abs(particleID) == 21)  // gluons
         (fMasterGen->event).append(21, 23, 101, 102, px, py, pz, ee, mass);
       // other
       else {
         (fMasterGen->event).append(particleID, 1, 0, 0, px, py, pz, ee, mass);
         int eventSize = (fMasterGen->event).size() - 1;
         // -log(flat) = exponential distribution
         double tauTmp = -(fMasterGen->event)[eventSize].tau0() * log(randomEngine().flat());
         (fMasterGen->event)[eventSize].tau(tauTmp);
       }
       (fMasterGen->event).back().vProd(vx, vy, vz, time);
  
       // Here also need to add anti-particle (if any)
       // otherwise just add a 2nd particle of the same type
       // (for example, gamma)
       //
       if (fAddAntiParticle) {
         if (1 <= std::abs(particleID) && std::abs(particleID) <= 6) {  // quarks
           (fMasterGen->event).append(-particleID, 23, 0, 101, -px, -py, -pz, ee, mass);
         } else if (std::abs(particleID) == 21) {  // gluons
           (fMasterGen->event).append(21, 23, 102, 101, -px, -py, -pz, ee, mass);
         } else {
           if ((fMasterGen->particleData).isParticle(-particleID)) {
             (fMasterGen->event).append(-particleID, 1, 0, 0, -px, -py, -pz, ee, mass);
           } else {
             (fMasterGen->event).append(particleID, 1, 0, 0, -px, -py, -pz, ee, mass);
           }
           int eventSize = (fMasterGen->event).size() - 1;
           // -log(flat) = exponential distribution
           double tauTmp = -(fMasterGen->event)[eventSize].tau0() * log(randomEngine().flat());
           (fMasterGen->event)[eventSize].tau(tauTmp);
         }
         (fMasterGen->event).back().vProd(-vx, -vy, -vz, time);
       }
     }
  
     if (!fMasterGen->next())
       return false;
     evtGenDecay();
  
     event() = std::make_unique<HepMC::GenEvent>();
     return toHepMC.fill_next_event(fMasterGen->event, event().get());
   }