#include <Py8GunBase.h>

Inheritance diagram for gen::Py8GunBase:

Public Member Functions
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
virtual const char *	classname () const =0

bool	decay ()

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

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

virtual bool	generatePartonsAndHadronize ()=0

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< HepMC3::GenEvent >	getGenEvent3 ()

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

std::unique_ptr< GenEventInfoProduct3 >	getGenEventInfo3 ()

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

GenRunInfoProduct &	getGenRunInfo ()

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

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

unsigned int	getVHepMC ()

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	resetEvent3 (std::unique_ptr< HepMC3::GenEvent > event3)

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

void	resetEventInfo3 (std::unique_ptr< GenEventInfoProduct3 > 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)

Protected Attributes
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
unsigned int	ivhepmc = 2

std::string	lheFile_

int	randomIndex_

Static Private Attributes
static const std::vector< std::string >	p8SharedResources = {edm::SharedResourceNames::kPythia8}

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

std::unique_ptr< HepMC3::GenEvent > &	event3 ()

std::unique_ptr< GenEventInfoProduct > &	eventInfo ()

std::unique_ptr< GenEventInfoProduct3 > &	eventInfo3 ()

lhef::LHEEvent *	lheEvent ()

lhef::LHERunInfo *	lheRunInfo ()

GenRunInfoProduct &	runInfo ()

Detailed Description

Definition at line 40 of file Py8GunBase.h.

Constructor & Destructor Documentation

◆ Py8GunBase()

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

Definition at line 15 of file Py8GunBase.cc.

References fMaxPhi, fMinPhi, fPartIDs, and edm::ParameterSet::getParameter().

                                                   : Py8InterfaceBase(ps) {
     // PGun specs
     //
     edm::ParameterSet pgun_params = ps.getParameter<edm::ParameterSet>("PGunParameters");
 
     // although there's the method ParameterSet::empty(),
     // it looks like it's NOT even necessary to check if it is,
     // before trying to extract parameters - if it is empty,
     // the default values seem to be taken
     //
     fPartIDs = pgun_params.getParameter<std::vector<int> >("ParticleID");
     fMinPhi = pgun_params.getParameter<double>("MinPhi");  // ,-3.14159265358979323846);
     fMaxPhi = pgun_params.getParameter<double>("MaxPhi");  // , 3.14159265358979323846);
   }

◆ ~Py8GunBase()

gen::Py8GunBase::~Py8GunBase ( )

inlineoverride

Definition at line 43 of file Py8GunBase.h.

43 {}

Member Function Documentation

◆ evtGenDecay()

void gen::Py8GunBase::evtGenDecay ( )

Definition at line 144 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::evtgenDecays.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtAndLxyGun::generatePartonsAndHadronize(), and gen::Py8EGun::generatePartonsAndHadronize().

                                {
     if (evtgenDecays.get())
       evtgenDecays->decay();
   }

◆ finalizeEvent()

void gen::Py8GunBase::finalizeEvent ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 110 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::ascii_io, gather_cfg::cout, gen::BaseHadronizer::event(), gen::Py8InterfaceBase::fMasterGen, gen::Py8InterfaceBase::maxEventsToPrint, gen::Py8InterfaceBase::pythiaHepMCVerbosity, gen::Py8InterfaceBase::pythiaHepMCVerbosityParticles, and gen::Py8InterfaceBase::pythiaPylistVerbosity.

                                  {
     //******** Verbosity ********
 
     if (maxEventsToPrint > 0 && (pythiaPylistVerbosity || pythiaHepMCVerbosity || pythiaHepMCVerbosityParticles)) {
       maxEventsToPrint--;
       if (pythiaPylistVerbosity) {
         fMasterGen->info.list();
         fMasterGen->event.list();
       }
 
       if (pythiaHepMCVerbosity) {
         std::cout << "Event process = " << fMasterGen->info.code() << "\n"
                   << "----------------------" << std::endl;
         event()->print();
       }
       if (pythiaHepMCVerbosityParticles) {
         std::cout << "Event process = " << fMasterGen->info.code() << "\n"
                   << "----------------------" << std::endl;
         ascii_io->write_event(event().get());
       }
     }
 
     return;
   }

◆ initializeForInternalPartons()

bool gen::Py8GunBase::initializeForInternalPartons ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 32 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::evtgenDecays, gen::Py8InterfaceBase::evtgenDecFile, gen::Py8InterfaceBase::evtgenPdlFile, gen::Py8InterfaceBase::evtgenUserFiles, gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, mps_fire::i, and gen::Py8InterfaceBase::useEvtGen.

                                                 {
     // NO MATTER what was this setting below, override it before init
     // - this is essencial for the PGun mode
 
     // Key requirement: switch off ProcessLevel, and thereby also PartonLevel.
     fMasterGen->readString("ProcessLevel:all = off");
     fMasterGen->readString("ProcessLevel::resonanceDecays=on");
     fMasterGen->init();
 
     // init decayer
     fDecayer->readString("ProcessLevel:all = off");  // Same trick!
     fDecayer->readString("ProcessLevel::resonanceDecays=on");
     fDecayer->init();
 
     if (useEvtGen) {
       edm::LogInfo("Pythia8Interface") << "Creating and initializing pythia8 EvtGen plugin";
       evtgenDecays.reset(new EvtGenDecays(fMasterGen.get(), evtgenDecFile, evtgenPdlFile));
       for (unsigned int i = 0; i < evtgenUserFiles.size(); i++)
         evtgenDecays->readDecayFile(evtgenUserFiles.at(i));
     }
 
     return true;
   }

◆ residualDecay()

bool gen::Py8GunBase::residualDecay ( )

virtual

Definition at line 56 of file Py8GunBase.cc.

References gen::BaseHadronizer::event(), gen::Py8InterfaceBase::fDecayer, gen::Py8InterfaceBase::fMasterGen, GenParticle::GenParticle, mps_fire::result, and gen::Py8InterfaceBase::toHepMC.

                                  {
     Event* pythiaEvent = &(fMasterGen->event);
 
     int NPartsBeforeDecays = pythiaEvent->size() - 1;  // do NOT count the very 1st "system" particle
                                                        // in Pythia8::Event record; it does NOT even
                                                        // get translated by the HepMCInterface to the
                                                        // HepMC::GenEvent record !!!
     int NPartsAfterDecays = event().get()->particles_size();
 
     if (NPartsAfterDecays == NPartsBeforeDecays)
       return true;
 
     bool result = true;
 
     for (int ipart = NPartsAfterDecays; ipart > NPartsBeforeDecays; ipart--) {
       HepMC::GenParticle* part = event().get()->barcode_to_particle(ipart);
 
       if (part->status() == 1 && (fDecayer->particleData).canDecay(part->pdg_id())) {
         fDecayer->event.reset();
         Particle py8part(part->pdg_id(),
                          93,
                          0,
                          0,
                          0,
                          0,
                          0,
                          0,
                          part->momentum().x(),
                          part->momentum().y(),
                          part->momentum().z(),
                          part->momentum().t(),
                          part->generated_mass());
         HepMC::GenVertex* ProdVtx = part->production_vertex();
         py8part.vProd(
             ProdVtx->position().x(), ProdVtx->position().y(), ProdVtx->position().z(), ProdVtx->position().t());
         py8part.tau((fDecayer->particleData).tau0(part->pdg_id()));
         fDecayer->event.append(py8part);
         int nentries = fDecayer->event.size();
         if (!fDecayer->event[nentries - 1].mayDecay())
           continue;
         fDecayer->next();
         int nentries1 = fDecayer->event.size();
         if (nentries1 <= nentries)
           continue;  //same number of particles, no decays...
 
         part->set_status(2);
 
         result = toHepMC.fill_next_event(*(fDecayer.get()), event().get(), -1, true, part);
       }
     }
 
     return result;
   }

◆ setRandomEngine()

void gen::Py8GunBase::setRandomEngine ( CLHEP::HepRandomEngine * v )

inline

Definition at line 50 of file Py8GunBase.h.

References gen::Py8InterfaceBase::p8SetRandomEngine(), and gen::v.

50 { p8SetRandomEngine(v); }

gen::Py8InterfaceBase::p8SetRandomEngine

void p8SetRandomEngine(CLHEP::HepRandomEngine *v)

Definition: Py8InterfaceBase.h:43

gen::v

double v[5][pyjets_maxn]

Definition: Pythia6Hadronizer.cc:89

◆ sharedResources()

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

inline

Definition at line 51 of file Py8GunBase.h.

References p8SharedResources.

51 { return p8SharedResources; }

gen::Py8GunBase::p8SharedResources

static const std::vector< std::string > p8SharedResources

Definition: Py8GunBase.h:62

◆ statistics()

void gen::Py8GunBase::statistics ( )

overridevirtual

Reimplemented from gen::Py8InterfaceBase.

Definition at line 135 of file Py8GunBase.cc.

References gen::Py8InterfaceBase::fMasterGen, gen::BaseHadronizer::runInfo(), and GenRunInfoProduct::setInternalXSec().

                               {
     fMasterGen->stat();
 
     double xsec = fMasterGen->info.sigmaGen();  // cross section in mb
     xsec *= 1.0e9;                              // translate to pb (CMS/Gen "convention" as of May 2009)
     runInfo().setInternalXSec(xsec);
     return;
   }

Member Data Documentation

◆ fMaxPhi

double gen::Py8GunBase::fMaxPhi

protected

Definition at line 59 of file Py8GunBase.h.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), gen::Py8PtAndLxyGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8MassGun::generatePartonsAndHadronize(), and Py8GunBase().

◆ fMinPhi

double gen::Py8GunBase::fMinPhi

protected

Definition at line 58 of file Py8GunBase.h.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), gen::Py8PtAndLxyGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8MassGun::generatePartonsAndHadronize(), and Py8GunBase().

◆ fPartIDs

std::vector<int> gen::Py8GunBase::fPartIDs

protected

Definition at line 57 of file Py8GunBase.h.

Referenced by gen::Py8PtAndDxyGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), gen::Py8PtAndLxyGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8MassGun::generatePartonsAndHadronize(), and Py8GunBase().

◆ p8SharedResources

const std::vector< std::string > gen::Py8GunBase::p8SharedResources = {edm::SharedResourceNames::kPythia8}

staticprivate

Definition at line 62 of file Py8GunBase.h.

Referenced by sharedResources().

Public Member Functions

Protected Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Py8GunBase()

◆ ~Py8GunBase()

Member Function Documentation

◆ evtGenDecay()

◆ finalizeEvent()

◆ initializeForInternalPartons()

◆ residualDecay()

◆ setRandomEngine()

◆ sharedResources()

◆ statistics()

Member Data Documentation

◆ fMaxPhi

◆ fMinPhi

◆ fPartIDs

◆ p8SharedResources