#include <Py8HMC3InterfaceBase.h>

Inheritance diagram for gen::Py8HMC3InterfaceBase:

Public Member Functions
virtual const char *	classname () const =0

bool	decay ()

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

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

virtual void	finalizeEvent ()=0

virtual bool	generatePartonsAndHadronize ()=0

virtual bool	initializeForInternalPartons ()=0

void	makeTmpSLHA (const std::string &)

void	p8SetRandomEngine (CLHEP::HepRandomEngine *v)

	Py8HMC3InterfaceBase (edm::ParameterSet const &ps)

P8RndmEngine &	randomEngine ()

bool	readSettings (int)

virtual void	statistics ()

	~Py8HMC3InterfaceBase () override=default

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

HepMC3::Pythia8ToHepMC3	toHepMC

bool	useEvtGen

Protected Attributes inherited from gen::BaseHadronizer
unsigned int	ivhepmc = 2

std::string	lheFile_

int	randomIndex_

Private Attributes
std::shared_ptr< P8RndmEngine >	p8RndmEngine_

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 24 of file Py8HMC3InterfaceBase.h.

Constructor & Destructor Documentation

◆ Py8HMC3InterfaceBase()

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

Definition at line 15 of file Py8HMC3InterfaceBase.cc.

References web.browse_db::env, evtgenDecFile, evtgenPdlFile, evtgenUserFiles, Exception, edm::ParameterSet::exists(), ztee::fd, fParameters, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, maxEventsToPrint, p8RndmEngine_, pythiaHepMCVerbosity, pythiaHepMCVerbosityParticles, pythiaPylistVerbosity, AlCaHLTBitMon_QueryRunRegistry::string, useEvtGen, and writeEcalDQMStatus::write.

       : BaseHadronizer(ps), useEvtGen(false), evtgenDecays(nullptr) {
     fParameters = ps;
 
     pythiaPylistVerbosity = ps.getUntrackedParameter<int>("pythiaPylistVerbosity", 0);
     pythiaHepMCVerbosity = ps.getUntrackedParameter<bool>("pythiaHepMCVerbosity", false);
     pythiaHepMCVerbosityParticles = ps.getUntrackedParameter<bool>("pythiaHepMCVerbosityParticles", false);
     maxEventsToPrint = ps.getUntrackedParameter<int>("maxEventsToPrint", 0);
     p8RndmEngine_ = std::make_shared<P8RndmEngine>();
 
     //if (pythiaHepMCVerbosityParticles)
     //  ascii_io = new HepMC::IO_AsciiParticles("cout", std::ios::out);
 
     if (ps.exists("useEvtGenPlugin")) {
       useEvtGen = true;
       auto env = std::getenv("EVTGENDATA");
       if (not env) {
         throw cms::Exception("EvtGenMissingEnv") << "The environment variable EVTGENDATA must be defined";
       }
       string evtgenpath(env);
       evtgenDecFile = evtgenpath + string("/DECAY_2010.DEC");
       evtgenPdlFile = evtgenpath + string("/evt.pdl");
 
       if (ps.exists("evtgenDecFile")) {
         edm::FileInPath decay_table(ps.getParameter<std::string>("evtgenDecFile"));
         evtgenDecFile = decay_table.fullPath();
       }
 
       if (ps.exists("evtgenPdlFile")) {
         edm::FileInPath pdt(ps.getParameter<std::string>("evtgenPdlFile"));
         evtgenPdlFile = pdt.fullPath();
       }
 
       if (ps.exists("evtgenUserFile")) {
         std::vector<std::string> user_decays = ps.getParameter<std::vector<std::string> >("evtgenUserFile");
         for (unsigned int i = 0; i < user_decays.size(); i++) {
           edm::FileInPath user_decay(user_decays.at(i));
           evtgenUserFiles.push_back(user_decay.fullPath());
         }
       }
 
       if (ps.exists("evtgenUserFileEmbedded")) {
         std::vector<std::string> user_decay_lines =
             ps.getParameter<std::vector<std::string> >("evtgenUserFileEmbedded");
         char tempslhaname[] = "pythia8evtgenXXXXXX";
         int fd = mkstemp(tempslhaname);
 
         for (unsigned int i = 0; i < user_decay_lines.size(); i++) {
           user_decay_lines.at(i) += "\n";
           write(fd, user_decay_lines.at(i).c_str(), user_decay_lines.at(i).size());
         }
         close(fd);
         evtgenUserFiles.push_back(std::string(tempslhaname));
       }
     }
   }

◆ ~Py8HMC3InterfaceBase()

gen::Py8HMC3InterfaceBase::~Py8HMC3InterfaceBase ( )

overridedefault

Member Function Documentation

◆ classname()

virtual const char* gen::Py8HMC3InterfaceBase::classname ( ) const

pure virtual

Implemented in Pythia8HepMC3Hadronizer.

◆ decay()

bool gen::Py8HMC3InterfaceBase::decay ( )

inline

Definition at line 30 of file Py8HMC3InterfaceBase.h.

30 { return true; } // NOT used - let's call it "design imperfection"

◆ declareSpecialSettings()

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

Definition at line 206 of file Py8HMC3InterfaceBase.cc.

References fDecayer, spr::find(), fMasterGen, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         {
     for (unsigned int iss = 0; iss < settings.size(); iss++) {
       if (settings[iss].find("QED-brem-off") != std::string::npos) {
         fMasterGen->readString("TimeShower:QEDshowerByL=off");
       } else {
         size_t fnd1 = settings[iss].find("Pythia8:");
         if (fnd1 != std::string::npos) {
           std::string value = settings[iss].substr(fnd1 + 8);
           fDecayer->readString(value);
         }
       }
     }
     return true;
   }

◆ declareStableParticles()

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

Definition at line 185 of file Py8HMC3InterfaceBase.cc.

References fMasterGen, mps_fire::i, and CosmicGenFilterHelix_cfi::pdgIds.

                                                                                 {
     for (size_t i = 0; i < pdgIds.size(); i++) {
       int PyID = pdgIds[i];
       std::ostringstream pyCard;
       pyCard << PyID << ":mayDecay=false";
 
       if (fMasterGen->particleData.isParticle(PyID)) {
         fMasterGen->readString(pyCard.str());
       } else {
         edm::LogWarning("DataNotUnderstood") << "Pythia8 does not "
                                              << "recognize particle id = " << PyID << std::endl;
       }
       // alternative:
       // set the 2nd input argument warn=false
       // - this way Py8 will NOT print warnings about unknown particle code(s)
       // fMasterPtr->readString( pyCard.str(), false )
     }
 
     return true;
   }

◆ finalizeEvent()

virtual void gen::Py8HMC3InterfaceBase::finalizeEvent ( )

pure virtual

Implemented in Pythia8HepMC3Hadronizer.

◆ generatePartonsAndHadronize()

virtual bool gen::Py8HMC3InterfaceBase::generatePartonsAndHadronize ( )

pure virtual

Implemented in Pythia8HepMC3Hadronizer.

◆ initializeForInternalPartons()

virtual bool gen::Py8HMC3InterfaceBase::initializeForInternalPartons ( )

pure virtual

Implemented in Pythia8HepMC3Hadronizer.

◆ makeTmpSLHA()

void gen::Py8HMC3InterfaceBase::makeTmpSLHA ( const std::string & slhatable )

Definition at line 173 of file Py8HMC3InterfaceBase.cc.

References ztee::fd, fMasterGen, slhafile_, and writeEcalDQMStatus::write.

Referenced by readSettings().

                                                                    {
     char tempslhaname[] = "pythia8SLHAtableXXXXXX";
     int fd = mkstemp(tempslhaname);
     write(fd, slhatable.c_str(), slhatable.size());
     close(fd);
 
     slhafile_ = tempslhaname;
 
     fMasterGen->settings.mode("SLHA:readFrom", 2);
     fMasterGen->settings.word("SLHA:file", slhafile_);
   }

◆ p8SetRandomEngine()

void gen::Py8HMC3InterfaceBase::p8SetRandomEngine ( CLHEP::HepRandomEngine * v )

inline

Definition at line 40 of file Py8HMC3InterfaceBase.h.

References p8RndmEngine_, and gen::v.

40 { p8RndmEngine_->setRandomEngine(v); }

gen::v

double v[5][pyjets_maxn]

Definition: Pythia6Hadronizer.cc:89

gen::Py8HMC3InterfaceBase::p8RndmEngine_

std::shared_ptr< P8RndmEngine > p8RndmEngine_

Definition: Py8HMC3InterfaceBase.h:65

◆ randomEngine()

P8RndmEngine& gen::Py8HMC3InterfaceBase::randomEngine ( )

inline

Definition at line 41 of file Py8HMC3InterfaceBase.h.

References p8RndmEngine_.

41 { return *p8RndmEngine_; }

gen::Py8HMC3InterfaceBase::p8RndmEngine_

std::shared_ptr< P8RndmEngine > p8RndmEngine_

Definition: Py8HMC3InterfaceBase.h:65

◆ readSettings()

bool gen::Py8HMC3InterfaceBase::readSettings ( int )

Definition at line 72 of file Py8HMC3InterfaceBase.cc.

References gen::ParameterCollector::begin(), gen::ParameterCollector::end(), edm::ParameterSet::exists(), validate-o2o-wbm::f1, fDecayer, fMasterGen, fParameters, get, edm::ParameterSet::getParameter(), mps_splice::line, makeTmpSLHA(), p8RndmEngine_, gen::BaseHadronizer::randomIndex(), SQLiteCheck_cfg::reader, slhafile_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                              {
     if (!fMasterGen.get())
       fMasterGen = std::make_unique<Pythia>();
     fDecayer = std::make_unique<Pythia>();
 
     //add settings for resonance decay filter
     fMasterGen->settings.addFlag("BiasedTauDecayer:filter", false);
     fMasterGen->settings.addFlag("BiasedTauDecayer:eDecays", true);
     fMasterGen->settings.addFlag("BiasedTauDecayer:muDecays", true);
 
     //add settings for resonance decay filter
     fMasterGen->settings.addFlag("ResonanceDecayFilter:filter", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:exclusive", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:eMuAsEquivalent", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:eMuTauAsEquivalent", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:allNuAsEquivalent", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:udscAsEquivalent", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:udscbAsEquivalent", false);
     fMasterGen->settings.addFlag("ResonanceDecayFilter:wzAsEquivalent", false);
     fMasterGen->settings.addMVec("ResonanceDecayFilter:mothers", std::vector<int>(), false, false, 0, 0);
     fMasterGen->settings.addMVec("ResonanceDecayFilter:daughters", std::vector<int>(), false, false, 0, 0);
 
     //add settings for PT filter
     fMasterGen->settings.addFlag("PTFilter:filter", false);
     fMasterGen->settings.addMode("PTFilter:quarkToFilter", 5, true, true, 3, 6);
     fMasterGen->settings.addParm("PTFilter:scaleToFilter", 0.4, true, true, 0.0, 10.);
     fMasterGen->settings.addParm("PTFilter:quarkRapidity", 10.0, true, true, 0.0, 10.);
     fMasterGen->settings.addParm("PTFilter:quarkPt", -.1, true, true, -.1, 100.);
 
     //add settings for powheg resonance scale calculation
     fMasterGen->settings.addFlag("POWHEGres:calcScales", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:onlyDistance1", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:veto", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:dryRun", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:vetoAtPL", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:vetoQED", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:PartonLevel:veto", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:PartonLevel:excludeFSRConflicting", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:DEBUG", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:ScaleResonance:veto", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:vetoDipoleFrame", false);
     fMasterGen->settings.addFlag("POWHEG:bb4l:FSREmission:pTpythiaVeto", false);
     fMasterGen->settings.addParm("POWHEG:bb4l:pTminVeto", 10.0, true, true, 0.0, 10.);
 
     fMasterGen->setRndmEnginePtr(p8RndmEngine_);
     fDecayer->setRndmEnginePtr(p8RndmEngine_);
 
     fMasterGen->readString("Next:numberShowEvent = 0");
     fDecayer->readString("Next:numberShowEvent = 0");
 
     edm::ParameterSet currentParameters;
     if (randomIndex() >= 0) {
       std::vector<edm::ParameterSet> randomizedParameters =
           fParameters.getParameter<std::vector<edm::ParameterSet> >("RandomizedParameters");
       currentParameters = randomizedParameters[randomIndex()];
     } else {
       currentParameters = fParameters;
     }
 
     ParameterCollector pCollector = currentParameters.getParameter<edm::ParameterSet>("PythiaParameters");
 
     for (ParameterCollector::const_iterator line = pCollector.begin(); line != pCollector.end(); ++line) {
       if (line->find("Random:") != std::string::npos)
         throw cms::Exception("PythiaError") << "Attempted to set random number "
                                                "using Pythia commands. Please use "
                                                "the RandomNumberGeneratorService."
                                             << std::endl;
 
       if (!fMasterGen->readString(*line))
         throw cms::Exception("PythiaError") << "Pythia 8 did not accept \"" << *line << "\"." << std::endl;
 
       if (line->find("ParticleDecays:") != std::string::npos) {
         if (!fDecayer->readString(*line))
           throw cms::Exception("PythiaError") << "Pythia 8 Decayer did not accept \"" << *line << "\"." << std::endl;
       }
     }
 
     slhafile_.clear();
 
     if (currentParameters.exists("SLHAFileForPythia8")) {
       std::string slhafilenameshort = currentParameters.getParameter<std::string>("SLHAFileForPythia8");
       edm::FileInPath f1(slhafilenameshort);
 
       fMasterGen->settings.mode("SLHA:readFrom", 2);
       fMasterGen->settings.word("SLHA:file", f1.fullPath());
     } else if (currentParameters.exists("SLHATableForPythia8")) {
       std::string slhatable = currentParameters.getParameter<std::string>("SLHATableForPythia8");
 
       makeTmpSLHA(slhatable);
     } else if (currentParameters.exists("SLHATreeForPythia8")) {
       auto slhaReaderParams = currentParameters.getParameter<edm::ParameterSet>("SLHATreeForPythia8");
       std::unique_ptr<SLHAReaderBase> reader =
           SLHAReaderFactory::get()->create(slhaReaderParams.getParameter<std::string>("name"), slhaReaderParams);
 
       makeTmpSLHA(reader->getSLHA(currentParameters.getParameter<std::string>("ConfigDescription")));
     }
 
     return true;
   }

◆ statistics()

void gen::Py8HMC3InterfaceBase::statistics ( )

virtual

Reimplemented in Pythia8HepMC3Hadronizer.

Definition at line 221 of file Py8HMC3InterfaceBase.cc.

References fMasterGen.

                                         {
     fMasterGen->stat();
     return;
   }

Member Data Documentation

◆ evtgenDecays

std::shared_ptr<Pythia8::EvtGenDecays> gen::Py8HMC3InterfaceBase::evtgenDecays

protected

Definition at line 57 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::generatePartonsAndHadronize(), Pythia8HepMC3Hadronizer::hadronize(), Pythia8HepMC3Hadronizer::initializeForExternalPartons(), and Pythia8HepMC3Hadronizer::initializeForInternalPartons().

◆ evtgenDecFile

std::string gen::Py8HMC3InterfaceBase::evtgenDecFile

protected

Definition at line 58 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), and Py8HMC3InterfaceBase().

◆ evtgenPdlFile

std::string gen::Py8HMC3InterfaceBase::evtgenPdlFile

protected

Definition at line 59 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), and Py8HMC3InterfaceBase().

◆ evtgenUserFiles

std::vector<std::string> gen::Py8HMC3InterfaceBase::evtgenUserFiles

protected

Definition at line 60 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), and Py8HMC3InterfaceBase().

◆ fDecayer

std::unique_ptr<Pythia8::Pythia> gen::Py8HMC3InterfaceBase::fDecayer

protected

Definition at line 45 of file Py8HMC3InterfaceBase.h.

Referenced by declareSpecialSettings(), Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), readSettings(), and Pythia8HepMC3Hadronizer::residualDecay().

◆ fMasterGen

std::unique_ptr<Pythia8::Pythia> gen::Py8HMC3InterfaceBase::fMasterGen

protected

Definition at line 44 of file Py8HMC3InterfaceBase.h.

◆ fParameters

edm::ParameterSet gen::Py8HMC3InterfaceBase::fParameters

protected

Definition at line 47 of file Py8HMC3InterfaceBase.h.

Referenced by Py8HMC3InterfaceBase(), and readSettings().

◆ maxEventsToPrint

unsigned int gen::Py8HMC3InterfaceBase::maxEventsToPrint

protected

Definition at line 52 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::finalizeEvent(), and Py8HMC3InterfaceBase().

◆ p8RndmEngine_

std::shared_ptr<P8RndmEngine> gen::Py8HMC3InterfaceBase::p8RndmEngine_

private

Definition at line 65 of file Py8HMC3InterfaceBase.h.

Referenced by p8SetRandomEngine(), Py8HMC3InterfaceBase(), randomEngine(), and readSettings().

◆ pythiaHepMCVerbosity

bool gen::Py8HMC3InterfaceBase::pythiaHepMCVerbosity

protected

Definition at line 50 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::finalizeEvent(), and Py8HMC3InterfaceBase().

◆ pythiaHepMCVerbosityParticles

bool gen::Py8HMC3InterfaceBase::pythiaHepMCVerbosityParticles

protected

Definition at line 51 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::finalizeEvent(), and Py8HMC3InterfaceBase().

◆ pythiaPylistVerbosity

unsigned int gen::Py8HMC3InterfaceBase::pythiaPylistVerbosity

protected

Definition at line 49 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::finalizeEvent(), Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), and Py8HMC3InterfaceBase().

◆ slhafile_

std::string gen::Py8HMC3InterfaceBase::slhafile_

protected

Definition at line 62 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), makeTmpSLHA(), and readSettings().

◆ toHepMC

HepMC3::Pythia8ToHepMC3 gen::Py8HMC3InterfaceBase::toHepMC

protected

Definition at line 46 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::generatePartonsAndHadronize(), Pythia8HepMC3Hadronizer::hadronize(), Pythia8HepMC3Hadronizer::Pythia8HepMC3Hadronizer(), and Pythia8HepMC3Hadronizer::residualDecay().

◆ useEvtGen

bool gen::Py8HMC3InterfaceBase::useEvtGen

protected

Definition at line 56 of file Py8HMC3InterfaceBase.h.

Referenced by Pythia8HepMC3Hadronizer::initializeForExternalPartons(), Pythia8HepMC3Hadronizer::initializeForInternalPartons(), and Py8HMC3InterfaceBase().

Public Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Py8HMC3InterfaceBase()

◆ ~Py8HMC3InterfaceBase()

Member Function Documentation

◆ classname()

◆ decay()

◆ declareSpecialSettings()

◆ declareStableParticles()

◆ finalizeEvent()

◆ generatePartonsAndHadronize()

◆ initializeForInternalPartons()

◆ makeTmpSLHA()

◆ p8SetRandomEngine()

◆ randomEngine()

◆ readSettings()

◆ statistics()

Member Data Documentation

◆ evtgenDecays

◆ evtgenDecFile

◆ evtgenPdlFile

◆ evtgenUserFiles

◆ fDecayer

◆ fMasterGen

◆ fParameters

◆ maxEventsToPrint

◆ p8RndmEngine_

◆ pythiaHepMCVerbosity

◆ pythiaHepMCVerbosityParticles

◆ pythiaPylistVerbosity

◆ slhafile_

◆ toHepMC

◆ useEvtGen