#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 219 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 186 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 80 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("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 236 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