Inheritance diagram for gen::Py8MassGun:

Public Member Functions
const char *	classname () const override

bool	generatePartonsAndHadronize () override

	Py8MassGun (edm::ParameterSet const &)

	~Py8MassGun () 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
double	fMaxEta

double	fMaxM

double	fMaxP

double	fMaxPt

double	fMinEta

double	fMinM

double	fMinP

double	fMinPt

int	fMomMode

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 9 of file Py8MassGun.cc.

Constructor & Destructor Documentation

◆ Py8MassGun()

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

Definition at line 32 of file Py8MassGun.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);
     fMinP = pgun_params.getParameter<double>("MinP");                                      // ,  0.);
     fMaxP = pgun_params.getParameter<double>("MaxP");                                      // ,  0.);
     fMinPt = pgun_params.getParameter<double>("MinPt");                                    // ,  0.);
     fMaxPt = pgun_params.getParameter<double>("MaxPt");                                    // ,  0.);
     fMinM = pgun_params.getParameter<double>("MinM");                                      // ,  0.);
     fMaxM = pgun_params.getParameter<double>("MaxM");                                      // ,  0.);
     fMomMode = pgun_params.getParameter<int>("MomMode");                                   // ,  1);
   }

References fMaxEta, fMaxM, fMaxP, fMaxPt, fMinEta, fMinM, fMinP, fMinPt, fMomMode, and edm::ParameterSet::getParameter().

◆ ~Py8MassGun()

gen::Py8MassGun::~Py8MassGun ( )

inlineoverride

Definition at line 12 of file Py8MassGun.cc.

12 {}

Member Function Documentation

◆ classname()

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

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 113 of file Py8MassGun.cc.

113 { return "Py8MassGun"; }

◆ generatePartonsAndHadronize()

bool gen::Py8MassGun::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 46 of file Py8MassGun.cc.

                                                {
     fMasterGen->event.reset();
     size_t pSize = fPartIDs.size();
     if (pSize > 2)
       return false;
  
     // Pick a flat mass range
     double phi, eta, the, ee, pp;
     double m0 = (fMaxM - fMinM) * randomEngine().flat() + fMinM;
     // Global eta
     eta = (fMaxEta - fMinEta) * randomEngine().flat() + fMinEta;
  
     if (pSize == 2) {
       // Masses.
       double m1 = fMasterGen->particleData.m0(fPartIDs[0]);
       double m2 = fMasterGen->particleData.m0(fPartIDs[1]);
  
       // Energies and absolute momentum in the rest frame.
       if (m1 + m2 > m0)
         return false;
       double e1 = 0.5 * (m0 * m0 + m1 * m1 - m2 * m2) / m0;
       double e2 = 0.5 * (m0 * m0 + m2 * m2 - m1 * m1) / m0;
       double pAbs = 0.5 * sqrt((m0 - m1 - m2) * (m0 + m1 + m2) * (m0 + m1 - m2) * (m0 - m1 + m2)) / m0;
       // Isotropic angles in rest frame give three-momentum.
       double cosTheta = 2. * randomEngine().flat() - 1.;
       double sinTheta = sqrt(1. - cosTheta * cosTheta);
       phi = 2. * M_PI * randomEngine().flat();
  
       double pX = pAbs * sinTheta * cos(phi);
       double pY = pAbs * sinTheta * sin(phi);
       double pZ = pAbs * cosTheta;
  
       (fMasterGen->event).append(fPartIDs[0], 1, 0, 0, pX, pY, pZ, e1, m1);
       (fMasterGen->event).append(fPartIDs[1], 1, 0, 0, -pX, -pY, -pZ, e2, m2);
     } else {
       (fMasterGen->event).append(fPartIDs[0], 1, 0, 0, 0.0, 0.0, 0.0, m0, m0);
     }
  
     //now the boost (from input params)
     if (fMomMode == 0) {
       pp = (fMaxP - fMinP) * randomEngine().flat() + fMinP;
     } else {
       double pT = (fMaxPt - fMinPt) * randomEngine().flat() + fMinPt;
       pp = pT * cosh(eta);
     }
     ee = sqrt(m0 * m0 + pp * pp);
  
     //the boost direction (from input params)
     //
     phi = (fMaxPhi - fMinPhi) * randomEngine().flat() + fMinPhi;
     the = 2. * atan(exp(-eta));
  
     double betaX = pp / ee * std::sin(the) * std::cos(phi);
     double betaY = pp / ee * std::sin(the) * std::sin(phi);
     double betaZ = pp / ee * std::cos(the);
  
     // boost all particles
     //
     (fMasterGen->event).bst(betaX, betaY, betaZ);
  
     if (!fMasterGen->next())
       return false;
  
     event().reset(new HepMC::GenEvent);
     return toHepMC.fill_next_event(fMasterGen->event, event().get());
   }