#include <Py8InterfaceBase.h>

Inheritance diagram for gen::Py8InterfaceBase:

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	p8SetRandomEngine (CLHEP::HepRandomEngine *v)

	Py8InterfaceBase (edm::ParameterSet const &ps)

P8RndmEngine &	randomEngine ()

bool	readSettings (int)

virtual void	statistics ()

	~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 ()(false)

Protected Attributes
HepMC::IO_AsciiParticles *	ascii_io

std::shared_ptr< 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_

Private Attributes
P8RndmEngine	p8RndmEngine_

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 ()

Detailed Description

Definition at line 25 of file Py8InterfaceBase.h.

Constructor & Destructor Documentation

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

Definition at line 17 of file Py8InterfaceBase.cc.

References ascii_io, evtgenDecFile, evtgenPdlFile, evtgenUserFiles, edm::ParameterSet::exists(), cmsRelvalreport::exit, fParameters, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, maxEventsToPrint, MillePedeFileConverter_cfg::out, pythiaHepMCVerbosity, pythiaHepMCVerbosityParticles, pythiaPylistVerbosity, AlCaHLTBitMon_QueryRunRegistry::string, and useEvtGen.

       : 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);
 
     if (pythiaHepMCVerbosityParticles)
       ascii_io = new HepMC::IO_AsciiParticles("cout", std::ios::out);
 
     if (ps.exists("useEvtGenPlugin")) {
       useEvtGen = true;
       string evtgenpath(getenv("EVTGENDATA"));
       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());
         }
         //evtgenUserFiles = ps.getParameter< std::vector<std::string> >("evtgenUserFile");
       }
 
       if (ps.exists("evtgenUserFileEmbedded")) {
         std::vector<std::string> user_decay_lines =
             ps.getParameter<std::vector<std::string> >("evtgenUserFileEmbedded");
         auto tmp_dir = boost::filesystem::temp_directory_path();
         tmp_dir += "/%%%%-%%%%-%%%%-%%%%";
         auto tmp_path = boost::filesystem::unique_path(tmp_dir);
         std::string user_decay_tmp = std::string(tmp_path.c_str());
         FILE* tmpf = std::fopen(user_decay_tmp.c_str(), "w");
         if (!tmpf) {
           edm::LogError("Py8InterfaceBase::~Py8InterfaceBase")
               << "Py8InterfaceBase::Py8InterfaceBase fails when trying to open a temporary file for embedded user.dec "
                  "for EvtGenPlugin. Terminating program ";
           exit(0);
         }
         for (unsigned int i = 0; i < user_decay_lines.size(); i++) {
           user_decay_lines.at(i) += "\n";
           std::fputs(user_decay_lines.at(i).c_str(), tmpf);
         }
         std::fclose(tmpf);
         evtgenUserFiles.push_back(user_decay_tmp);
       }
     }
   }

gen::Py8InterfaceBase::~Py8InterfaceBase ( )

inlineoverride

Definition at line 30 of file Py8InterfaceBase.h.

30 {}

Member Function Documentation

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

pure virtual

Implemented in Pythia8Hadronizer, gen::Py8EGun, gen::Py8JetGun, and gen::Py8PtGun.

bool gen::Py8InterfaceBase::decay ( )

inline

Definition at line 33 of file Py8InterfaceBase.h.

References data-class-funcs::classname, and myMessageLogger_cff::statistics.

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

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

Definition at line 208 of file Py8InterfaceBase.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;
   }

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

Definition at line 181 of file Py8InterfaceBase.cc.

References fMasterGen, and mps_fire::i.

                                                                             {
     for (size_t i = 0; i < pdgIds.size(); i++) {
       // FIXME: need to double check if PID's are the same in Py6 & Py8,
       //        because the HepPDT translation tool is actually for **Py6**
       //
       // well, actually it looks like Py8 operates in PDT id's rather than Py6's
       //
       //    int PyID = HepPID::translatePDTtoPythia( pdgIds[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;
   }

virtual void gen::Py8InterfaceBase::finalizeEvent ( )

pure virtual

Implemented in Pythia8Hadronizer, and gen::Py8GunBase.

virtual bool gen::Py8InterfaceBase::generatePartonsAndHadronize ( )

pure virtual

Implemented in Pythia8Hadronizer, gen::Py8EGun, gen::Py8JetGun, and gen::Py8PtGun.

virtual bool gen::Py8InterfaceBase::initializeForInternalPartons ( )

pure virtual

Implemented in Pythia8Hadronizer, and gen::Py8GunBase.

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

inline

Definition at line 42 of file Py8InterfaceBase.h.

42 { p8RndmEngine_.setRandomEngine(v); }

gen::v

double v[5][pyjets_maxn]

Definition: Cascade2Hadronizer.cc:80

gen::P8RndmEngine::setRandomEngine

void setRandomEngine(CLHEP::HepRandomEngine *v)

Definition: P8RndmEngine.h:35

gen::Py8InterfaceBase::p8RndmEngine_

P8RndmEngine p8RndmEngine_

Definition: Py8InterfaceBase.h:71

P8RndmEngine& gen::Py8InterfaceBase::randomEngine ( )

inline

Definition at line 43 of file Py8InterfaceBase.h.

Referenced by gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), and gen::Py8JetGun::generatePartonsAndHadronize().

43 { return p8RndmEngine_; }

gen::Py8InterfaceBase::p8RndmEngine_

P8RndmEngine p8RndmEngine_

Definition: Py8InterfaceBase.h:71

bool gen::Py8InterfaceBase::readSettings ( int )

Definition at line 78 of file Py8InterfaceBase.cc.

References gen::ParameterCollector::begin(), gen::ParameterCollector::end(), edm::ParameterSet::exists(), connectstrParser::f1, fDecayer, fMasterGen, fParameters, edm::ParameterSet::getParameter(), mps_splice::line, p8RndmEngine_, gen::BaseHadronizer::randomIndex(), slhafile_, AlCaHLTBitMon_QueryRunRegistry::string, and TriggerAnalyzer::write().

                                          {
     if (!fMasterGen.get())
       fMasterGen.reset(new Pythia);
     fDecayer.reset(new 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");
 
       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_);
     }
 
     return true;
   }

void gen::Py8InterfaceBase::statistics ( )

virtual

Reimplemented in Pythia8Hadronizer, and gen::Py8GunBase.

Definition at line 223 of file Py8InterfaceBase.cc.

References fMasterGen.

                                     {
     fMasterGen->stat();
     return;
   }

Member Data Documentation

HepMC::IO_AsciiParticles* gen::Py8InterfaceBase::ascii_io

protected

Definition at line 57 of file Py8InterfaceBase.h.

Referenced by gen::Py8GunBase::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), and Py8InterfaceBase().

std::shared_ptr<EvtGenDecays> gen::Py8InterfaceBase::evtgenDecays

protected

Definition at line 62 of file Py8InterfaceBase.h.

Referenced by gen::Py8GunBase::evtGenDecay(), Pythia8Hadronizer::generatePartonsAndHadronize(), Pythia8Hadronizer::hadronize(), Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), and Pythia8Hadronizer::initializeForInternalPartons().

std::string gen::Py8InterfaceBase::evtgenDecFile

protected

Definition at line 63 of file Py8InterfaceBase.h.

Referenced by Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), and Py8InterfaceBase().

std::string gen::Py8InterfaceBase::evtgenPdlFile

protected

Definition at line 64 of file Py8InterfaceBase.h.

Referenced by Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), and Py8InterfaceBase().

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

protected

Definition at line 65 of file Py8InterfaceBase.h.

Referenced by Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), and Py8InterfaceBase().

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

protected

Definition at line 48 of file Py8InterfaceBase.h.

Referenced by declareSpecialSettings(), Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), readSettings(), gen::Py8GunBase::residualDecay(), and Pythia8Hadronizer::residualDecay().

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

protected

edm::ParameterSet gen::Py8InterfaceBase::fParameters

protected

Definition at line 51 of file Py8InterfaceBase.h.

Referenced by Py8InterfaceBase(), and readSettings().

unsigned int gen::Py8InterfaceBase::maxEventsToPrint

protected

Definition at line 56 of file Py8InterfaceBase.h.

Referenced by gen::Py8GunBase::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), and Py8InterfaceBase().

P8RndmEngine gen::Py8InterfaceBase::p8RndmEngine_

private

Definition at line 71 of file Py8InterfaceBase.h.

Referenced by readSettings().

bool gen::Py8InterfaceBase::pythiaHepMCVerbosity

protected

Definition at line 54 of file Py8InterfaceBase.h.

Referenced by gen::Py8GunBase::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), and Py8InterfaceBase().

bool gen::Py8InterfaceBase::pythiaHepMCVerbosityParticles

protected

Definition at line 55 of file Py8InterfaceBase.h.

Referenced by gen::Py8GunBase::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), and Py8InterfaceBase().

unsigned int gen::Py8InterfaceBase::pythiaPylistVerbosity

protected

Definition at line 53 of file Py8InterfaceBase.h.

Referenced by gen::Py8GunBase::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), Pythia8Hadronizer::initializeForExternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), and Py8InterfaceBase().

std::string gen::Py8InterfaceBase::slhafile_

protected

Definition at line 67 of file Py8InterfaceBase.h.

Referenced by Pythia8Hadronizer::initializeForExternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), and readSettings().

HepMC::Pythia8ToHepMC gen::Py8InterfaceBase::toHepMC

protected

Definition at line 49 of file Py8InterfaceBase.h.

Referenced by gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), Pythia8Hadronizer::generatePartonsAndHadronize(), Pythia8Hadronizer::hadronize(), gen::Py8GunBase::residualDecay(), and Pythia8Hadronizer::residualDecay().

bool gen::Py8InterfaceBase::useEvtGen

protected

Definition at line 61 of file Py8InterfaceBase.h.

Referenced by Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), and Py8InterfaceBase().

Public Member Functions

Protected Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation