gen::Py8InterfaceBase Class Reference

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

Py8InterfaceBase()

gen::Py8InterfaceBase::Py8InterfaceBase

(

edm::ParameterSet const &

ps

)

Definition at line 17 of file Py8InterfaceBase.cc.

      : 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(std::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);
      }
    }
  }

References ascii_io, evtgenDecFile, evtgenPdlFile, evtgenUserFiles, edm::ParameterSet::exists(), beamvalidation::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.

~Py8InterfaceBase()

gen::Py8InterfaceBase::~Py8InterfaceBase ( )

inlineoverride

Definition at line 28 of file Py8InterfaceBase.h.

{}

Member Function Documentation

classname()

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

pure virtual

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

decay()

bool gen::Py8InterfaceBase::decay ( )

inline

Definition at line 31 of file Py8InterfaceBase.h.

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

declareSpecialSettings()

bool gen::Py8InterfaceBase::declareSpecialSettings

(

const std::vector< std::string > &

settings

)

Definition at line 207 of file Py8InterfaceBase.cc.

                                                                                    {
    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;
  }

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

declareStableParticles()

bool gen::Py8InterfaceBase::declareStableParticles

(

const std::vector< int > &

pdgIds

)

Definition at line 180 of file Py8InterfaceBase.cc.

                                                                            {
    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;
  }

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

finalizeEvent()

virtual void gen::Py8InterfaceBase::finalizeEvent ( )

pure virtual

Implemented in Pythia8Hadronizer, and gen::Py8GunBase.

generatePartonsAndHadronize()

virtual bool gen::Py8InterfaceBase::generatePartonsAndHadronize ( )

pure virtual

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

initializeForInternalPartons()

virtual bool gen::Py8InterfaceBase::initializeForInternalPartons ( )

pure virtual

Implemented in Pythia8Hadronizer, and gen::Py8GunBase.

p8SetRandomEngine()

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

inline

Definition at line 40 of file Py8InterfaceBase.h.

{ p8RndmEngine_.setRandomEngine(v); }

References p8RndmEngine_, gen::P8RndmEngine::setRandomEngine(), and gen::v.

Referenced by gen::Py8GunBase::setRandomEngine().

randomEngine()

P8RndmEngine& gen::Py8InterfaceBase::randomEngine ( )

inline

Definition at line 41 of file Py8InterfaceBase.h.

{ return p8RndmEngine_; }

References p8RndmEngine_.

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

readSettings()

bool gen::Py8InterfaceBase::readSettings

(

int

)

Definition at line 78 of file Py8InterfaceBase.cc.

                                         {
    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:eMuDecays", 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;
  }

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

statistics()

void gen::Py8InterfaceBase::statistics ( )

virtual

Reimplemented in Pythia8Hadronizer, and gen::Py8GunBase.

Definition at line 222 of file Py8InterfaceBase.cc.

                                    {
    fMasterGen->stat();
    return;
  }

References fMasterGen.

Member Data Documentation

ascii_io

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

protected

Definition at line 54 of file Py8InterfaceBase.h.

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

evtgenDecays

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

protected

Definition at line 59 of file Py8InterfaceBase.h.

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

evtgenDecFile

std::string gen::Py8InterfaceBase::evtgenDecFile

protected

Definition at line 60 of file Py8InterfaceBase.h.

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

evtgenPdlFile

std::string gen::Py8InterfaceBase::evtgenPdlFile

protected

Definition at line 61 of file Py8InterfaceBase.h.

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

evtgenUserFiles

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

protected

Definition at line 62 of file Py8InterfaceBase.h.

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

fDecayer

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

protected

Definition at line 45 of file Py8InterfaceBase.h.

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

fMasterGen

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

protected

Definition at line 44 of file Py8InterfaceBase.h.

Referenced by declareSpecialSettings(), declareStableParticles(), gen::Py8GunBase::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), gen::Py8PtotGun::generatePartonsAndHadronize(), gen::Py8PtGun::generatePartonsAndHadronize(), gen::Py8JetGun::generatePartonsAndHadronize(), gen::Py8EGun::generatePartonsAndHadronize(), Pythia8Hadronizer::generatePartonsAndHadronize(), Pythia8Hadronizer::getGenLumiInfoHeader(), Pythia8Hadronizer::hadronize(), Pythia8Hadronizer::initializeForExternalPartons(), gen::Py8GunBase::initializeForInternalPartons(), Pythia8Hadronizer::initializeForInternalPartons(), Pythia8Hadronizer::Pythia8Hadronizer(), readSettings(), gen::Py8GunBase::residualDecay(), Pythia8Hadronizer::residualDecay(), statistics(), gen::Py8GunBase::statistics(), and Pythia8Hadronizer::statistics().

fParameters

edm::ParameterSet gen::Py8InterfaceBase::fParameters

protected

Definition at line 48 of file Py8InterfaceBase.h.

Referenced by Py8InterfaceBase(), and readSettings().

maxEventsToPrint

unsigned int gen::Py8InterfaceBase::maxEventsToPrint

protected

Definition at line 53 of file Py8InterfaceBase.h.

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

p8RndmEngine_

P8RndmEngine gen::Py8InterfaceBase::p8RndmEngine_

private

Definition at line 67 of file Py8InterfaceBase.h.

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

pythiaHepMCVerbosity

bool gen::Py8InterfaceBase::pythiaHepMCVerbosity

protected

Definition at line 51 of file Py8InterfaceBase.h.

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

pythiaHepMCVerbosityParticles

bool gen::Py8InterfaceBase::pythiaHepMCVerbosityParticles

protected

Definition at line 52 of file Py8InterfaceBase.h.

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

pythiaPylistVerbosity

unsigned int gen::Py8InterfaceBase::pythiaPylistVerbosity

protected

Definition at line 50 of file Py8InterfaceBase.h.

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

slhafile_

std::string gen::Py8InterfaceBase::slhafile_

protected

Definition at line 64 of file Py8InterfaceBase.h.

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

toHepMC

HepMC::Pythia8ToHepMC gen::Py8InterfaceBase::toHepMC

protected

Definition at line 46 of file Py8InterfaceBase.h.

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

useEvtGen

bool gen::Py8InterfaceBase::useEvtGen

protected

Definition at line 58 of file Py8InterfaceBase.h.

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