Inheritance diagram for Pythia8Hadronizer:

Public Member Functions
const char *	classname () const override

void	finalizeEvent () override

bool	generatePartonsAndHadronize () override

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

bool	hadronize ()

bool	initializeForExternalPartons ()

bool	initializeForInternalPartons () override

	Pythia8Hadronizer (const edm::ParameterSet &params)

virtual bool	residualDecay ()

void	statistics () override

	~Pythia8Hadronizer () override

Public Member Functions inherited from gen::Py8InterfaceBase
bool	decay ()

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

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

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

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)

Private Types
enum	{ PP, PPbar, ElectronPositron }

Private Member Functions
void	doSetRandomEngine (CLHEP::HepRandomEngine *v) override

std::vector< std::string > const &	doSharedResources () const override

Private Attributes
double	comEnergy
	Center-of-Mass energy. More...

vector< float >	DJR

int	EV1_emittedMode

int	EV1_maxVetoCount

bool	EV1_MPIvetoOn

int	EV1_nFinal

int	EV1_nFinalMode

int	EV1_pTdefMode

int	EV1_pTempMode

int	EV1_pThardMode

int	EV1_QEDvetoMode

bool	EV1_vetoOn

double	fBeam1PZ

double	fBeam2PZ

std::shared_ptr< BiasedTauDecayer >	fBiasedTauDecayer

std::shared_ptr< UserHooksVector >	fCustomHooksVector

std::shared_ptr< PowhegHooks >	fEmissionVetoHook

std::shared_ptr< EmissionVetoHook1 >	fEmissionVetoHook1

int	fInitialState

std::shared_ptr< JetMatchingHook >	fJetMatchingHook

std::shared_ptr< Pythia8::JetMatchingMadgraph >	fJetMatchingPy8InternalHook

std::shared_ptr< Pythia8::amcnlo_unitarised_interface >	fMergingHook

std::shared_ptr< PowhegHooksBB4L >	fPowhegHooksBB4L

std::shared_ptr< PowhegResHook >	fPowhegResHook

std::shared_ptr< PTFilterHook >	fPTFilterHook

std::shared_ptr< ResonanceDecayFilterHook >	fResonanceDecayFilterHook

std::shared_ptr< UserHooks >	fReweightEmpUserHook

std::shared_ptr< UserHooks >	fReweightPtHatRapUserHook

std::shared_ptr< UserHooks >	fReweightRapUserHook

std::shared_ptr< UserHooks >	fReweightUserHook

std::shared_ptr< TopRecoilHook >	fTopRecoilHook

std::shared_ptr< UserHooksVector >	fUserHooksVector

std::shared_ptr< LHAupLesHouches >	lhaUP

std::string	LHEInputFileName

int	nFSRveto

int	nISRveto

int	nME

int	nMEFiltered

bool	UserHooksSet

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

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_

Detailed Description

Definition at line 79 of file Pythia8Hadronizer.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
PP
PPbar
ElectronPositron

Definition at line 110 of file Pythia8Hadronizer.cc.

110 { PP, PPbar, ElectronPositron };

Pythia8Hadronizer::PPbar

Definition: Pythia8Hadronizer.cc:110

Pythia8Hadronizer::ElectronPositron

Definition: Pythia8Hadronizer.cc:110

Pythia8Hadronizer::PP

Definition: Pythia8Hadronizer.cc:110

Constructor & Destructor Documentation

◆ Pythia8Hadronizer()

Pythia8Hadronizer::Pythia8Hadronizer ( const edm::ParameterSet & params )

Definition at line 180 of file Pythia8Hadronizer.cc.

References edm::errors::Configuration, ElectronPositron, EV1_emittedMode, EV1_maxVetoCount, EV1_MPIvetoOn, EV1_nFinal, EV1_nFinalMode, EV1_pTdefMode, EV1_pTempMode, EV1_pThardMode, EV1_QEDvetoMode, EV1_vetoOn, Exception, edm::ParameterSet::exists(), fCustomHooksVector, fEmissionVetoHook1, fInitialState, fJetMatchingHook, gen::Py8InterfaceBase::fMasterGen, fReweightEmpUserHook, fReweightPtHatRapUserHook, fReweightRapUserHook, fReweightUserHook, get, edm::ParameterSet::getParameter(), gen::BaseHadronizer::ivhepmc, submitPVValidationJobs::params, PP, PPbar, push_back(), generator_cfi::scheme, AlCaHLTBitMon_QueryRunRegistry::string, and gen::Py8InterfaceBase::toHepMC.

     : Py8InterfaceBase(params),
       comEnergy(params.getParameter<double>("comEnergy")),
       LHEInputFileName(params.getUntrackedParameter<std::string>("LHEInputFileName", "")),
       fInitialState(PP),
       UserHooksSet(false),
       nME(-1),
       nMEFiltered(-1),
       nISRveto(0),
       nFSRveto(0) {
   ivhepmc = 2;
   // J.Y.: the following 3 parameters are hacked "for a reason"
   //
   if (params.exists("PPbarInitialState")) {
     if (fInitialState == PP) {
       fInitialState = PPbar;
       edm::LogImportant("GeneratorInterface|Pythia8Interface")
           << "Pythia8 will be initialized for PROTON-ANTIPROTON INITIAL STATE. "
           << "This is a user-request change from the DEFAULT PROTON-PROTON initial state.";
     } else {
       // probably need to throw on attempt to override ?
     }
   } else if (params.exists("ElectronPositronInitialState")) {
     if (fInitialState == PP) {
       fInitialState = ElectronPositron;
       edm::LogInfo("GeneratorInterface|Pythia8Interface")
           << "Pythia8 will be initialized for ELECTRON-POSITRON INITIAL STATE. "
           << "This is a user-request change from the DEFAULT PROTON-PROTON initial state.";
     } else {
       // probably need to throw on attempt to override ?
     }
   } else if (params.exists("ElectronProtonInitialState") || params.exists("PositronProtonInitialState")) {
     // throw on unknown initial state !
     throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
         << " UNKNOWN INITIAL STATE. \n The allowed initial states are: PP, PPbar, ElectronPositron \n";
   }
 
   // avoid filling weights twice (from v8.30x)
   toHepMC.set_store_weights(false);
 
   // Reweight user hook
   //
   if (params.exists("reweightGen")) {
     edm::LogInfo("Pythia8Interface") << "Start setup for reweightGen";
     edm::ParameterSet rgParams = params.getParameter<edm::ParameterSet>("reweightGen");
     fReweightUserHook.reset(
         new PtHatReweightUserHook(rgParams.getParameter<double>("pTRef"), rgParams.getParameter<double>("power")));
     edm::LogInfo("Pythia8Interface") << "End setup for reweightGen";
   }
   if (params.exists("reweightGenEmp")) {
     edm::LogInfo("Pythia8Interface") << "Start setup for reweightGenEmp";
     edm::ParameterSet rgeParams = params.getParameter<edm::ParameterSet>("reweightGenEmp");
 
     std::string tuneName = "";
     if (rgeParams.exists("tune"))
       tuneName = rgeParams.getParameter<std::string>("tune");
     fReweightEmpUserHook.reset(new PtHatEmpReweightUserHook(tuneName));
     edm::LogInfo("Pythia8Interface") << "End setup for reweightGenEmp";
   }
   if (params.exists("reweightGenRap")) {
     edm::LogInfo("Pythia8Interface") << "Start setup for reweightGenRap";
     edm::ParameterSet rgrParams = params.getParameter<edm::ParameterSet>("reweightGenRap");
     fReweightRapUserHook.reset(new RapReweightUserHook(rgrParams.getParameter<std::string>("yLabSigmaFunc"),
                                                        rgrParams.getParameter<double>("yLabPower"),
                                                        rgrParams.getParameter<std::string>("yCMSigmaFunc"),
                                                        rgrParams.getParameter<double>("yCMPower"),
                                                        rgrParams.getParameter<double>("pTHatMin"),
                                                        rgrParams.getParameter<double>("pTHatMax")));
     edm::LogInfo("Pythia8Interface") << "End setup for reweightGenRap";
   }
   if (params.exists("reweightGenPtHatRap")) {
     edm::LogInfo("Pythia8Interface") << "Start setup for reweightGenPtHatRap";
     edm::ParameterSet rgrParams = params.getParameter<edm::ParameterSet>("reweightGenPtHatRap");
     fReweightPtHatRapUserHook.reset(new PtHatRapReweightUserHook(rgrParams.getParameter<std::string>("yLabSigmaFunc"),
                                                                  rgrParams.getParameter<double>("yLabPower"),
                                                                  rgrParams.getParameter<std::string>("yCMSigmaFunc"),
                                                                  rgrParams.getParameter<double>("yCMPower"),
                                                                  rgrParams.getParameter<double>("pTHatMin"),
                                                                  rgrParams.getParameter<double>("pTHatMax")));
     edm::LogInfo("Pythia8Interface") << "End setup for reweightGenPtHatRap";
   }
 
   if (params.exists("useUserHook"))
     throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
         << " Obsolete parameter: useUserHook \n Please use the actual one instead \n";
 
   // PS matching prototype
   //
   if (params.exists("jetMatching")) {
     edm::ParameterSet jmParams = params.getUntrackedParameter<edm::ParameterSet>("jetMatching");
     std::string scheme = jmParams.getParameter<std::string>("scheme");
     if (scheme == "Madgraph" || scheme == "MadgraphFastJet") {
       fJetMatchingHook.reset(new JetMatchingHook(jmParams, &fMasterGen->info));
     }
   }
 
   // Pythia8Interface emission veto
   //
   if (params.exists("emissionVeto1")) {
     EV1_nFinal = -1;
     if (params.exists("EV1_nFinal"))
       EV1_nFinal = params.getParameter<int>("EV1_nFinal");
     EV1_vetoOn = true;
     if (params.exists("EV1_vetoOn"))
       EV1_vetoOn = params.getParameter<bool>("EV1_vetoOn");
     EV1_maxVetoCount = 10;
     if (params.exists("EV1_maxVetoCount"))
       EV1_maxVetoCount = params.getParameter<int>("EV1_maxVetoCount");
     EV1_pThardMode = 1;
     if (params.exists("EV1_pThardMode"))
       EV1_pThardMode = params.getParameter<int>("EV1_pThardMode");
     EV1_pTempMode = 0;
     if (params.exists("EV1_pTempMode"))
       EV1_pTempMode = params.getParameter<int>("EV1_pTempMode");
     if (EV1_pTempMode > 2 || EV1_pTempMode < 0)
       throw edm::Exception(edm::errors::Configuration, "Pythia8Interface") << " Wrong value for EV1_pTempMode code\n";
     EV1_emittedMode = 0;
     if (params.exists("EV1_emittedMode"))
       EV1_emittedMode = params.getParameter<int>("EV1_emittedMode");
     EV1_pTdefMode = 1;
     if (params.exists("EV1_pTdefMode"))
       EV1_pTdefMode = params.getParameter<int>("EV1_pTdefMode");
     EV1_MPIvetoOn = false;
     if (params.exists("EV1_MPIvetoOn"))
       EV1_MPIvetoOn = params.getParameter<bool>("EV1_MPIvetoOn");
     EV1_QEDvetoMode = 0;
     if (params.exists("EV1_QEDvetoMode"))
       EV1_QEDvetoMode = params.getParameter<int>("EV1_QEDvetoMode");
     EV1_nFinalMode = 0;
     if (params.exists("EV1_nFinalMode"))
       EV1_nFinalMode = params.getParameter<int>("EV1_nFinalMode");
     fEmissionVetoHook1.reset(new EmissionVetoHook1(EV1_nFinal,
                                                    EV1_vetoOn,
                                                    EV1_maxVetoCount,
                                                    EV1_pThardMode,
                                                    EV1_pTempMode,
                                                    EV1_emittedMode,
                                                    EV1_pTdefMode,
                                                    EV1_MPIvetoOn,
                                                    EV1_QEDvetoMode,
                                                    EV1_nFinalMode,
                                                    0));
   }
 
   if (params.exists("UserCustomization")) {
     fCustomHooksVector = std::make_shared<UserHooksVector>();
     const std::vector<edm::ParameterSet> userParams =
         params.getParameter<std::vector<edm::ParameterSet>>("UserCustomization");
     for (const auto &pluginParams : userParams) {
       (fCustomHooksVector->hooks)
           .push_back(
               CustomHookFactory::get()->create(pluginParams.getParameter<std::string>("pluginName"), pluginParams));
     }
   }
 
   if (params.exists("VinciaPlugin")) {
     throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
         << " Obsolete parameter: VinciaPlugin \n Please use the parameter PartonShowers:model instead \n";
   }
   if (params.exists("DirePlugin")) {
     throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
         << " Obsolete parameter: DirePlugin \n Please use the parameter PartonShowers:model instead \n";
   }
 }

◆ ~Pythia8Hadronizer()

Pythia8Hadronizer::~Pythia8Hadronizer ( )

override

Definition at line 345 of file Pythia8Hadronizer.cc.

345 {}

Member Function Documentation

◆ classname()

const char* Pythia8Hadronizer::classname ( ) const

inlineoverridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 96 of file Pythia8Hadronizer.cc.

96 { return "Pythia8Hadronizer"; }

◆ doSetRandomEngine()

void Pythia8Hadronizer::doSetRandomEngine ( CLHEP::HepRandomEngine * v )

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 101 of file Pythia8Hadronizer.cc.

References findQualityFiles::v.

101 { p8SetRandomEngine(v); }

gen::Py8InterfaceBase::p8SetRandomEngine

void p8SetRandomEngine(CLHEP::HepRandomEngine *v)

Definition: Py8InterfaceBase.h:43

findQualityFiles.v

v

Definition: findQualityFiles.py:179

◆ doSharedResources()

std::vector<std::string> const& Pythia8Hadronizer::doSharedResources ( ) const

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 102 of file Pythia8Hadronizer.cc.

102 { return p8SharedResources; }

Pythia8Hadronizer::p8SharedResources

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

Definition: Pythia8Hadronizer.cc:168

◆ finalizeEvent()

void Pythia8Hadronizer::finalizeEvent ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 962 of file Pythia8Hadronizer.cc.

References gen::Py8InterfaceBase::ascii_io, gather_cfg::cout, DJR, relativeConstraints::empty, gen::BaseHadronizer::event(), gen::BaseHadronizer::eventInfo(), gen::Py8InterfaceBase::fMasterGen, gen::BaseHadronizer::lheEvent(), gen::Py8InterfaceBase::maxEventsToPrint, nME, nMEFiltered, push_back(), gen::Py8InterfaceBase::pythiaHepMCVerbosity, gen::Py8InterfaceBase::pythiaHepMCVerbosityParticles, gen::Py8InterfaceBase::pythiaPylistVerbosity, and hltDeepSecondaryVertexTagInfosPFPuppi_cfi::weights.

                                       {
   bool lhe = lheEvent() != nullptr;
 
   // protection against empty weight container
   if ((event()->weights()).empty())
     (event()->weights()).push_back(1.);
 
   // now create the GenEventInfo product from the GenEvent and fill
   // the missing pieces
   eventInfo() = std::make_unique<GenEventInfoProduct>(event().get());
 
   // in pythia pthat is used to subdivide samples into different bins
   // in LHE mode the binning is done by the external ME generator
   // which is likely not pthat, so only filling it for Py6 internal mode
   if (!lhe) {
     eventInfo()->setBinningValues(std::vector<double>(1, fMasterGen->info.pTHat()));
   }
 
   eventInfo()->setDJR(DJR);
   eventInfo()->setNMEPartons(nME);
   eventInfo()->setNMEPartonsFiltered(nMEFiltered);
 
   //******** 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());
     }
   }
 }

◆ generatePartonsAndHadronize()

bool Pythia8Hadronizer::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 722 of file Pythia8Hadronizer.cc.

References funct::abs(), DJR, gen::BaseHadronizer::event(), gen::Py8InterfaceBase::evtgenDecays, fEmissionVetoHook, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8InterfaceBase::fMasterGen, fMergingHook, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, submitPVResolutionJobs::key, gen::BaseHadronizer::lheEvent(), SiStripPI::min, nFSRveto, nISRveto, nME, nMEFiltered, and gen::Py8InterfaceBase::toHepMC.

                                                     {
   DJR.resize(0);
   nME = -1;
   nMEFiltered = -1;
 
   if (fJetMatchingHook.get()) {
     fJetMatchingHook->resetMatchingStatus();
     fJetMatchingHook->beforeHadronization(lheEvent());
   }
 
   if (!fMasterGen->next())
     return false;
 
   double mergeweight = fMasterGen.get()->info.mergingWeightNLO();
   if (fMergingHook.get()) {
     mergeweight *= fMergingHook->getNormFactor();
   }
 
   //protect against 0-weight from ckkw or similar
   if (std::abs(mergeweight) == 0.) {
     event().reset();
     return false;
   }
 
   if (fJetMatchingPy8InternalHook.get()) {
     const std::vector<double> djrmatch = fJetMatchingPy8InternalHook->getDJR();
     //cap size of djr vector to save storage space (keep only up to first 6 elements)
     unsigned int ndjr = std::min(djrmatch.size(), std::vector<double>::size_type(6));
     for (unsigned int idjr = 0; idjr < ndjr; ++idjr) {
       DJR.push_back(djrmatch[idjr]);
     }
 
     nME = fJetMatchingPy8InternalHook->nMEpartons().first;
     nMEFiltered = fJetMatchingPy8InternalHook->nMEpartons().second;
   }
 
   if (evtgenDecays.get())
     evtgenDecays->decay();
 
   event() = std::make_unique<HepMC::GenEvent>();
   bool py8hepmc = toHepMC.fill_next_event(*(fMasterGen.get()), event().get());
 
   if (!py8hepmc) {
     return false;
   }
 
   // 0th weight is not filled anymore since v8.30x, pushback manually
   event()->weights().push_back(fMasterGen->info.weight());
 
   //add ckkw/umeps/unlops merging weight
   if (mergeweight != 1.) {
     event()->weights()[0] *= mergeweight;
   }
 
   if (fEmissionVetoHook.get()) {
     nISRveto += fEmissionVetoHook->getNISRveto();
     nFSRveto += fEmissionVetoHook->getNFSRveto();
   }
 
   //fill additional weights for systematic uncertainties
   if (fMasterGen->info.getWeightsDetailedSize() > 0) {
     for (const string &key : fMasterGen->info.initrwgt->weightsKeys) {
       double wgt = (*fMasterGen->info.weights_detailed)[key];
       event()->weights().push_back(wgt);
     }
   } else if (fMasterGen->info.getWeightsCompressedSize() > 0) {
     for (unsigned int i = 0; i < fMasterGen->info.getWeightsCompressedSize(); i++) {
       double wgt = fMasterGen->info.getWeightsCompressedValue(i);
       event()->weights().push_back(wgt);
     }
   }
 
   // fill shower weights
   // http://home.thep.lu.se/~torbjorn/pythia82html/Variations.html
   if (fMasterGen->info.nWeights() > 1) {
     for (int i = 0; i < fMasterGen->info.nWeights(); ++i) {
       double wgt = fMasterGen->info.weight(i);
       event()->weights().push_back(wgt);
     }
   }
 
 #if 0
   // VINCIA shower weights
   // http://vincia.hepforge.org/current/share/Vincia/htmldoc/VinciaUncertainties.html
   if (fvincia.get()) {
     event()->weights()[0] *= fvincia->weight(0);
     for (int iVar = 1; iVar < fvincia->nWeights(); iVar++) {
       event()->weights().push_back(fvincia->weight(iVar));
     }
   }
 
   // Retrieve Dire shower weights
   if (fDire.get()) {
     fDire->weightsPtr->calcWeight(0.);
     fDire->weightsPtr->reset();
 
     //Make sure the base weight comes first
     event()->weights()[0] *= fDire->weightsPtr->getShowerWeight("base");
 
     unordered_map<string, double>::iterator it;
     for (it = fDire->weightsPtr->getShowerWeights()->begin(); it != fDire->weightsPtr->getShowerWeights()->end();
          it++) {
       if (it->first == "base")
         continue;
       event()->weights().push_back(it->second);
     }
   }
 #endif
 
   return true;
 }

◆ getGenLumiInfoHeader()

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

overridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 1006 of file Pythia8Hadronizer.cc.

References gen::Py8InterfaceBase::fMasterGen, genWeightsTable_cfi::genLumiInfoHeader, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, submitPVResolutionJobs::key, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
   auto genLumiInfoHeader = BaseHadronizer::getGenLumiInfoHeader();
 
   //fill lhe headers
   //*FIXME* initrwgt header is corrupt due to pythia bug
   for (const std::string &key : fMasterGen->info.headerKeys()) {
     genLumiInfoHeader->lheHeaders().emplace_back(key, fMasterGen->info.header(key));
   }
 
   //check, if it is not only nominal weight
   int weights_number = fMasterGen->info.nWeights();
   if (fMasterGen->info.initrwgt)
     weights_number += fMasterGen->info.initrwgt->weightsKeys.size();
   if (weights_number > 1) {
     genLumiInfoHeader->weightNames().reserve(weights_number + 1);
     genLumiInfoHeader->weightNames().push_back("nominal");
   }
 
   //fill weight names
   if (fMasterGen->info.initrwgt) {
     for (const std::string &key : fMasterGen->info.initrwgt->weightsKeys) {
       std::string weightgroupname;
       for (const auto &wgtgrp : fMasterGen->info.initrwgt->weightgroups) {
         const auto &wgtgrpwgt = wgtgrp.second.weights.find(key);
         if (wgtgrpwgt != wgtgrp.second.weights.end()) {
           weightgroupname = wgtgrp.first;
         }
       }
 
       std::ostringstream weightname;
       weightname << "LHE, id = " << key << ", ";
       if (!weightgroupname.empty()) {
         weightname << "group = " << weightgroupname << ", ";
       }
       weightname << fMasterGen->info.initrwgt->weights[key].contents;
       genLumiInfoHeader->weightNames().push_back(weightname.str());
     }
   }
 
   //fill shower labels
   // http://home.thep.lu.se/~torbjorn/pythia82html/Variations.html
   // http://home.thep.lu.se/~torbjorn/doxygen/classPythia8_1_1Info.html
   if (fMasterGen->info.nWeights() > 1) {
     for (int i = 0; i < fMasterGen->info.nWeights(); ++i) {
       genLumiInfoHeader->weightNames().push_back(fMasterGen->info.weightLabel(i));
     }
   }
 
 #if 0
   // VINCIA shower weights
   // http://vincia.hepforge.org/current/share/Vincia/htmldoc/VinciaUncertainties.html
   if (fvincia.get()) {
     for (int iVar = 0; iVar < fvincia->nWeights(); iVar++) {
       genLumiInfoHeader->weightNames().push_back(fvincia->weightLabel(iVar));
     }
   }
 
   if (fDire.get()) {
     //Make sure the base weight comes first
     genLumiInfoHeader->weightNames().push_back("base");
 
     unordered_map<string, double>::iterator it;
     for (it = fDire->weightsPtr->getShowerWeights()->begin(); it != fDire->weightsPtr->getShowerWeights()->end();
          it++) {
       if (it->first == "base")
         continue;
       genLumiInfoHeader->weightNames().push_back(it->first);
     }
   }
 #endif
 
   return genLumiInfoHeader;
 }

◆ hadronize()

bool Pythia8Hadronizer::hadronize ( )

Definition at line 834 of file Pythia8Hadronizer.cc.

References funct::abs(), lhef::LHEEvent::count(), DJR, gen::BaseHadronizer::event(), gen::Py8InterfaceBase::evtgenDecays, fEmissionVetoHook, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8InterfaceBase::fMasterGen, fMergingHook, mps_fire::i, lhef::LHERunInfo::kAccepted, lhef::LHERunInfo::kSelected, lhaUP, gen::BaseHadronizer::lheEvent(), LHEInputFileName, SiStripPI::min, nFSRveto, nISRveto, nME, nMEFiltered, and gen::Py8InterfaceBase::toHepMC.

                                   {
   DJR.resize(0);
   nME = -1;
   nMEFiltered = -1;
   if (LHEInputFileName.empty())
     lhaUP->loadEvent(lheEvent());
 
   if (fJetMatchingHook.get()) {
     fJetMatchingHook->resetMatchingStatus();
     fJetMatchingHook->beforeHadronization(lheEvent());
   }
 
   bool py8next = fMasterGen->next();
 
   double mergeweight = fMasterGen.get()->info.mergingWeightNLO();
   if (fMergingHook.get()) {
     mergeweight *= fMergingHook->getNormFactor();
   }
 
   //protect against 0-weight from ckkw or similar
   if (!py8next || std::abs(mergeweight) == 0.) {
     lheEvent()->count(lhef::LHERunInfo::kSelected, 1.0, mergeweight);
     event().reset();
     return false;
   }
 
   if (fJetMatchingPy8InternalHook.get()) {
     const std::vector<double> djrmatch = fJetMatchingPy8InternalHook->getDJR();
     //cap size of djr vector to save storage space (keep only up to first 6 elements)
     unsigned int ndjr = std::min(djrmatch.size(), std::vector<double>::size_type(6));
     for (unsigned int idjr = 0; idjr < ndjr; ++idjr) {
       DJR.push_back(djrmatch[idjr]);
     }
 
     nME = fJetMatchingPy8InternalHook->nMEpartons().first;
     nMEFiltered = fJetMatchingPy8InternalHook->nMEpartons().second;
   }
 
   // update LHE matching statistics
   //
   lheEvent()->count(lhef::LHERunInfo::kAccepted, 1.0, mergeweight);
 
   if (evtgenDecays.get())
     evtgenDecays->decay();
 
   event() = std::make_unique<HepMC::GenEvent>();
 
   bool py8hepmc = toHepMC.fill_next_event(*(fMasterGen.get()), event().get());
 
   if (!py8hepmc) {
     return false;
   }
 
   // 0th weight is not filled anymore since v8.30x, pushback manually
   event()->weights().push_back(fMasterGen->info.weight());
 
   //add ckkw/umeps/unlops merging weight
   if (mergeweight != 1.) {
     event()->weights()[0] *= mergeweight;
   }
 
   if (fEmissionVetoHook.get()) {
     nISRveto += fEmissionVetoHook->getNISRveto();
     nFSRveto += fEmissionVetoHook->getNFSRveto();
   }
 
   // fill shower weights
   // http://home.thep.lu.se/~torbjorn/pythia82html/Variations.html
   if (fMasterGen->info.nWeights() > 1) {
     for (int i = 0; i < fMasterGen->info.nWeights(); ++i) {
       double wgt = fMasterGen->info.weight(i);
       event()->weights().push_back(wgt);
     }
   }
 
   return true;
 }

◆ initializeForExternalPartons()

bool Pythia8Hadronizer::initializeForExternalPartons ( )

Definition at line 527 of file Pythia8Hadronizer.cc.

                                                      {
   edm::LogInfo("Pythia8Interface") << "Initializing for external partons";
 
   bool status = false, status1 = false;
 
   if (!fUserHooksVector.get())
     fUserHooksVector.reset(new UserHooksVector);
   (fUserHooksVector->hooks).clear();
 
   if (fReweightUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightUserHook);
   if (fReweightEmpUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightEmpUserHook);
   if (fReweightRapUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightRapUserHook);
   if (fReweightPtHatRapUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightPtHatRapUserHook);
   if (fJetMatchingHook.get())
     (fUserHooksVector->hooks).push_back(fJetMatchingHook);
   if (fEmissionVetoHook1.get()) {
     edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook 1 from CMSSW Pythia8Interface";
     (fUserHooksVector->hooks).push_back(fEmissionVetoHook1);
   }
 
   if (fCustomHooksVector.get()) {
     edm::LogInfo("Pythia8Interface") << "Adding customized user hook";
     for (const auto &fUserHook : fCustomHooksVector->hooks) {
       (fUserHooksVector->hooks).push_back(fUserHook);
     }
   }
 
   if (fMasterGen->settings.mode("POWHEG:veto") > 0 || fMasterGen->settings.mode("POWHEG:MPIveto") > 0) {
     if (fJetMatchingHook.get() || fEmissionVetoHook1.get())
       throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
           << " Attempt to turn on PowhegHooks by pythia8 settings but there are incompatible hooks on \n Incompatible "
              "are : jetMatching, emissionVeto1 \n";
 
     if (!fEmissionVetoHook.get())
       fEmissionVetoHook.reset(new PowhegHooks());
 
     edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook from pythia8 code";
     (fUserHooksVector->hooks).push_back(fEmissionVetoHook);
   }
 
   bool PowhegRes = fMasterGen->settings.flag("POWHEGres:calcScales");
   if (PowhegRes) {
     edm::LogInfo("Pythia8Interface") << "Turning on resonance scale setting from CMSSW Pythia8Interface";
     if (!fPowhegResHook.get())
       fPowhegResHook.reset(new PowhegResHook());
     (fUserHooksVector->hooks).push_back(fPowhegResHook);
   }
 
   bool PowhegBB4L = fMasterGen->settings.flag("POWHEG:bb4l");
   if (PowhegBB4L) {
     edm::LogInfo("Pythia8Interface") << "Turning on BB4l hook from CMSSW Pythia8Interface";
     if (!fPowhegHooksBB4L.get())
       fPowhegHooksBB4L.reset(new PowhegHooksBB4L());
     (fUserHooksVector->hooks).push_back(fPowhegHooksBB4L);
   }
 
   bool TopRecoilHook1 = fMasterGen->settings.flag("TopRecoilHook:doTopRecoilIn");
   if (TopRecoilHook1) {
     edm::LogInfo("Pythia8Interface") << "Turning on RecoilToTop hook from Pythia8Interface";
     if (!fTopRecoilHook.get())
       fTopRecoilHook.reset(new TopRecoilHook());
     (fUserHooksVector->hooks).push_back(fTopRecoilHook);
   }
 
   //adapted from main89.cc in pythia8 examples
   bool internalMatching = fMasterGen->settings.flag("JetMatching:merge");
   bool internalMerging = !(fMasterGen->settings.word("Merging:Process") == "void");
 
   if (internalMatching && internalMerging) {
     throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
         << " Only one jet matching/merging scheme can be used at a time. \n";
   }
 
   if (internalMatching) {
     if (!fJetMatchingPy8InternalHook.get())
       fJetMatchingPy8InternalHook.reset(new Pythia8::JetMatchingMadgraph);
     (fUserHooksVector->hooks).push_back(fJetMatchingPy8InternalHook);
   }
 
   if (internalMerging) {
     int scheme = (fMasterGen->settings.flag("Merging:doUMEPSTree") || fMasterGen->settings.flag("Merging:doUMEPSSubt"))
                      ? 1
                      : ((fMasterGen->settings.flag("Merging:doUNLOPSTree") ||
                          fMasterGen->settings.flag("Merging:doUNLOPSSubt") ||
                          fMasterGen->settings.flag("Merging:doUNLOPSLoop") ||
                          fMasterGen->settings.flag("Merging:doUNLOPSSubtNLO"))
                             ? 2
                             : 0);
     if (!fMergingHook.get())
       fMergingHook.reset(new Pythia8::amcnlo_unitarised_interface(scheme));
     (fUserHooksVector->hooks).push_back(fMergingHook);
   }
 
   bool biasedTauDecayer = fMasterGen->settings.flag("BiasedTauDecayer:filter");
   if (biasedTauDecayer) {
     if (!fBiasedTauDecayer.get()) {
       Pythia8::Info localInfo = fMasterGen->info;
       fBiasedTauDecayer.reset(new BiasedTauDecayer(&localInfo, &(fMasterGen->settings)));
     }
     std::vector<int> handledParticles;
     handledParticles.push_back(15);
     fMasterGen->setDecayPtr(fBiasedTauDecayer, handledParticles);
   }
 
   bool resonanceDecayFilter = fMasterGen->settings.flag("ResonanceDecayFilter:filter");
   if (resonanceDecayFilter) {
     fResonanceDecayFilterHook.reset(new ResonanceDecayFilterHook);
     (fUserHooksVector->hooks).push_back(fResonanceDecayFilterHook);
   }
 
   bool PTFilter = fMasterGen->settings.flag("PTFilter:filter");
   if (PTFilter) {
     fPTFilterHook.reset(new PTFilterHook);
     (fUserHooksVector->hooks).push_back(fPTFilterHook);
   }
 
   if (!(fUserHooksVector->hooks).empty() && !UserHooksSet) {
     for (auto &fUserHook : fUserHooksVector->hooks) {
       fMasterGen->addUserHooksPtr(fUserHook);
     }
     UserHooksSet = true;
   }
 
   if (!LHEInputFileName.empty()) {
     edm::LogInfo("Pythia8Interface") << "Initialize direct pythia8 reading from LHE file " << LHEInputFileName;
     edm::LogInfo("Pythia8Interface") << "Some LHE information can be not stored";
     fMasterGen->settings.mode("Beams:frameType", 4);
     fMasterGen->settings.word("Beams:LHEF", LHEInputFileName);
     status = fMasterGen->init();
 
   } else {
     lhaUP.reset(new LHAupLesHouches());
     lhaUP->setScalesFromLHEF(fMasterGen->settings.flag("Beams:setProductionScalesFromLHEF"));
     lhaUP->loadRunInfo(lheRunInfo());
 
     if (fJetMatchingHook.get()) {
       fJetMatchingHook->init(lheRunInfo());
     }
 
     fMasterGen->settings.mode("Beams:frameType", 5);
     fMasterGen->setLHAupPtr(lhaUP);
     edm::LogInfo("Pythia8Interface") << "Initializing MasterGen";
     status = fMasterGen->init();
   }
 
   //clean up temp file
   if (!slhafile_.empty()) {
     std::remove(slhafile_.c_str());
   }
 
   if (pythiaPylistVerbosity > 10) {
     if (pythiaPylistVerbosity == 11 || pythiaPylistVerbosity == 13)
       fMasterGen->settings.listAll();
     if (pythiaPylistVerbosity == 12 || pythiaPylistVerbosity == 13)
       fMasterGen->particleData.listAll();
   }
 
   // init decayer
   fDecayer->settings.flag("ProcessLevel:all", false);  // trick
   fDecayer->settings.flag("ProcessLevel:resonanceDecays", true);
   edm::LogInfo("Pythia8Interface") << "Initializing Decayer";
   status1 = fDecayer->init();
 
   if (useEvtGen) {
     edm::LogInfo("Pythia8Hadronizer") << "Creating and initializing pythia8 EvtGen plugin";
     if (!evtgenDecays.get()) {
       evtgenDecays.reset(new EvtGenDecays(fMasterGen.get(), evtgenDecFile, evtgenPdlFile));
       for (unsigned int i = 0; i < evtgenUserFiles.size(); i++)
         evtgenDecays->readDecayFile(evtgenUserFiles.at(i));
     }
   }
 
   return (status && status1);
 }

◆ initializeForInternalPartons()

bool Pythia8Hadronizer::initializeForInternalPartons ( )

overridevirtual

Implements gen::Py8InterfaceBase.

Definition at line 347 of file Pythia8Hadronizer.cc.

                                                      {
   bool status = false, status1 = false;
 
   if (lheFile_.empty()) {
     if (fInitialState == PP)  // default
     {
       fMasterGen->settings.mode("Beams:idA", 2212);
       fMasterGen->settings.mode("Beams:idB", 2212);
     } else if (fInitialState == PPbar) {
       fMasterGen->settings.mode("Beams:idA", 2212);
       fMasterGen->settings.mode("Beams:idB", -2212);
     } else if (fInitialState == ElectronPositron) {
       fMasterGen->settings.mode("Beams:idA", 11);
       fMasterGen->settings.mode("Beams:idB", -11);
     } else {
       // throw on unknown initial state !
       throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
           << " UNKNOWN INITIAL STATE. \n The allowed initial states are: PP, PPbar, ElectronPositron \n";
     }
     fMasterGen->settings.parm("Beams:eCM", comEnergy);
   } else {
     fMasterGen->settings.mode("Beams:frameType", 4);
     fMasterGen->settings.word("Beams:LHEF", lheFile_);
   }
 
   if (!fUserHooksVector.get())
     fUserHooksVector.reset(new UserHooksVector);
   (fUserHooksVector->hooks).clear();
 
   if (fReweightUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightUserHook);
   if (fReweightEmpUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightEmpUserHook);
   if (fReweightRapUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightRapUserHook);
   if (fReweightPtHatRapUserHook.get())
     (fUserHooksVector->hooks).push_back(fReweightPtHatRapUserHook);
   if (fJetMatchingHook.get())
     (fUserHooksVector->hooks).push_back(fJetMatchingHook);
   if (fEmissionVetoHook1.get()) {
     edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook 1 from CMSSW Pythia8Interface";
     (fUserHooksVector->hooks).push_back(fEmissionVetoHook1);
   }
 
   if (fMasterGen->settings.mode("POWHEG:veto") > 0 || fMasterGen->settings.mode("POWHEG:MPIveto") > 0) {
     if (fJetMatchingHook.get() || fEmissionVetoHook1.get())
       throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
           << " Attempt to turn on PowhegHooks by pythia8 settings but there are incompatible hooks on \n Incompatible "
              "are : jetMatching, emissionVeto1 \n";
 
     if (!fEmissionVetoHook.get())
       fEmissionVetoHook.reset(new PowhegHooks());
 
     edm::LogInfo("Pythia8Interface") << "Turning on Emission Veto Hook from pythia8 code";
     (fUserHooksVector->hooks).push_back(fEmissionVetoHook);
   }
 
   bool PowhegRes = fMasterGen->settings.flag("POWHEGres:calcScales");
   if (PowhegRes) {
     edm::LogInfo("Pythia8Interface") << "Turning on resonance scale setting from CMSSW Pythia8Interface";
     if (!fPowhegResHook.get())
       fPowhegResHook.reset(new PowhegResHook());
     (fUserHooksVector->hooks).push_back(fPowhegResHook);
   }
 
   bool PowhegBB4L = fMasterGen->settings.flag("POWHEG:bb4l");
   if (PowhegBB4L) {
     edm::LogInfo("Pythia8Interface") << "Turning on BB4l hook from CMSSW Pythia8Interface";
     if (!fPowhegHooksBB4L.get())
       fPowhegHooksBB4L.reset(new PowhegHooksBB4L());
     (fUserHooksVector->hooks).push_back(fPowhegHooksBB4L);
   }
 
   bool TopRecoilHook1 = fMasterGen->settings.flag("TopRecoilHook:doTopRecoilIn");
   if (TopRecoilHook1) {
     edm::LogInfo("Pythia8Interface") << "Turning on RecoilToTop hook from Pythia8Interface";
     if (!fTopRecoilHook.get())
       fTopRecoilHook.reset(new TopRecoilHook());
     (fUserHooksVector->hooks).push_back(fTopRecoilHook);
   }
 
   //adapted from main89.cc in pythia8 examples
   bool internalMatching = fMasterGen->settings.flag("JetMatching:merge");
   bool internalMerging = !(fMasterGen->settings.word("Merging:Process") == "void");
 
   if (internalMatching && internalMerging) {
     throw edm::Exception(edm::errors::Configuration, "Pythia8Interface")
         << " Only one jet matching/merging scheme can be used at a time. \n";
   }
 
   if (internalMatching) {
     if (!fJetMatchingPy8InternalHook.get())
       fJetMatchingPy8InternalHook.reset(new Pythia8::JetMatchingMadgraph);
     (fUserHooksVector->hooks).push_back(fJetMatchingPy8InternalHook);
   }
 
   if (internalMerging) {
     int scheme = (fMasterGen->settings.flag("Merging:doUMEPSTree") || fMasterGen->settings.flag("Merging:doUMEPSSubt"))
                      ? 1
                      : ((fMasterGen->settings.flag("Merging:doUNLOPSTree") ||
                          fMasterGen->settings.flag("Merging:doUNLOPSSubt") ||
                          fMasterGen->settings.flag("Merging:doUNLOPSLoop") ||
                          fMasterGen->settings.flag("Merging:doUNLOPSSubtNLO"))
                             ? 2
                             : 0);
     if (!fMergingHook.get())
       fMergingHook.reset(new Pythia8::amcnlo_unitarised_interface(scheme));
     (fUserHooksVector->hooks).push_back(fMergingHook);
   }
 
   bool biasedTauDecayer = fMasterGen->settings.flag("BiasedTauDecayer:filter");
   if (biasedTauDecayer) {
     if (!fBiasedTauDecayer.get()) {
       Pythia8::Info localInfo = fMasterGen->info;
       fBiasedTauDecayer.reset(new BiasedTauDecayer(&localInfo, &(fMasterGen->settings)));
     }
     std::vector<int> handledParticles;
     handledParticles.push_back(15);
     fMasterGen->setDecayPtr(fBiasedTauDecayer, handledParticles);
   }
 
   bool resonanceDecayFilter = fMasterGen->settings.flag("ResonanceDecayFilter:filter");
   if (resonanceDecayFilter) {
     fResonanceDecayFilterHook.reset(new ResonanceDecayFilterHook);
     (fUserHooksVector->hooks).push_back(fResonanceDecayFilterHook);
   }
 
   bool PTFilter = fMasterGen->settings.flag("PTFilter:filter");
   if (PTFilter) {
     fPTFilterHook.reset(new PTFilterHook);
     (fUserHooksVector->hooks).push_back(fPTFilterHook);
   }
 
   if (!(fUserHooksVector->hooks).empty() && !UserHooksSet) {
     for (auto &fUserHook : fUserHooksVector->hooks) {
       fMasterGen->addUserHooksPtr(fUserHook);
     }
     UserHooksSet = true;
   }
 
   if (fCustomHooksVector.get()) {
     edm::LogInfo("Pythia8Interface") << "Adding customized user hooks";
     for (const auto &fUserHook : fCustomHooksVector->hooks) {
       fMasterGen->addUserHooksPtr(fUserHook);
     }
   }
 
   edm::LogInfo("Pythia8Interface") << "Initializing MasterGen";
   status = fMasterGen->init();
 
   //clean up temp file
   if (!slhafile_.empty()) {
     std::remove(slhafile_.c_str());
   }
 
   if (pythiaPylistVerbosity > 10) {
     if (pythiaPylistVerbosity == 11 || pythiaPylistVerbosity == 13)
       fMasterGen->settings.listAll();
     if (pythiaPylistVerbosity == 12 || pythiaPylistVerbosity == 13)
       fMasterGen->particleData.listAll();
   }
 
   // init decayer
   fDecayer->settings.flag("ProcessLevel:all", false);  // trick
   fDecayer->settings.flag("ProcessLevel:resonanceDecays", true);
   edm::LogInfo("Pythia8Interface") << "Initializing Decayer";
   status1 = fDecayer->init();
 
   if (useEvtGen) {
     edm::LogInfo("Pythia8Hadronizer") << "Creating and initializing pythia8 EvtGen plugin";
     if (!evtgenDecays.get()) {
       evtgenDecays.reset(new EvtGenDecays(fMasterGen.get(), evtgenDecFile, evtgenPdlFile));
       for (unsigned int i = 0; i < evtgenUserFiles.size(); i++)
         evtgenDecays->readDecayFile(evtgenUserFiles.at(i));
     }
   }
 
   return (status && status1);
 }

◆ residualDecay()

bool Pythia8Hadronizer::residualDecay ( )

virtual

Definition at line 912 of file Pythia8Hadronizer.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();
   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;
 }

◆ statistics()

void Pythia8Hadronizer::statistics ( )

overridevirtual

Reimplemented from gen::Py8InterfaceBase.

Definition at line 706 of file Pythia8Hadronizer.cc.

References submitPVResolutionJobs::err, fEmissionVetoHook, gen::Py8InterfaceBase::fMasterGen, nFSRveto, nISRveto, gen::BaseHadronizer::runInfo(), and GenRunInfoProduct::setInternalXSec().

                                    {
   fMasterGen->stat();
 
   if (fEmissionVetoHook.get()) {
     edm::LogPrint("Pythia8Interface") << "\n"
                                       << "Number of ISR vetoed = " << nISRveto;
     edm::LogPrint("Pythia8Interface") << "Number of FSR vetoed = " << nFSRveto;
   }
 
   double xsec = fMasterGen->info.sigmaGen();  // cross section in mb
   xsec *= 1.0e9;                              // translate to pb (CMS/Gen "convention" as of May 2009)
   double err = fMasterGen->info.sigmaErr();   // cross section err in mb
   err *= 1.0e9;                               // translate to pb (CMS/Gen "convention" as of May 2009)
   runInfo().setInternalXSec(GenRunInfoProduct::XSec(xsec, err));
 }

Member Data Documentation

◆ comEnergy

double Pythia8Hadronizer::comEnergy

private

Center-of-Mass energy.

Definition at line 105 of file Pythia8Hadronizer.cc.

Referenced by initializeForInternalPartons().

◆ DJR

vector<float> Pythia8Hadronizer::DJR

private

Definition at line 170 of file Pythia8Hadronizer.cc.

Referenced by finalizeEvent(), generatePartonsAndHadronize(), and hadronize().

◆ EV1_emittedMode

int Pythia8Hadronizer::EV1_emittedMode

private

Definition at line 162 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_maxVetoCount

int Pythia8Hadronizer::EV1_maxVetoCount

private

Definition at line 159 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_MPIvetoOn

bool Pythia8Hadronizer::EV1_MPIvetoOn

private

Definition at line 164 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_nFinal

int Pythia8Hadronizer::EV1_nFinal

private

Definition at line 157 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_nFinalMode

int Pythia8Hadronizer::EV1_nFinalMode

private

Definition at line 166 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_pTdefMode

int Pythia8Hadronizer::EV1_pTdefMode

private

Definition at line 163 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_pTempMode

int Pythia8Hadronizer::EV1_pTempMode

private

Definition at line 161 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_pThardMode

int Pythia8Hadronizer::EV1_pThardMode

private

Definition at line 160 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_QEDvetoMode

int Pythia8Hadronizer::EV1_QEDvetoMode

private

Definition at line 165 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ EV1_vetoOn

bool Pythia8Hadronizer::EV1_vetoOn

private

Definition at line 158 of file Pythia8Hadronizer.cc.

Referenced by Pythia8Hadronizer().

◆ fBeam1PZ

double Pythia8Hadronizer::fBeam1PZ

private

Definition at line 113 of file Pythia8Hadronizer.cc.

◆ fBeam2PZ

double Pythia8Hadronizer::fBeam2PZ

private

Definition at line 114 of file Pythia8Hadronizer.cc.

◆ fBiasedTauDecayer

std::shared_ptr<BiasedTauDecayer> Pythia8Hadronizer::fBiasedTauDecayer

private

Definition at line 143 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ fCustomHooksVector

std::shared_ptr<UserHooksVector> Pythia8Hadronizer::fCustomHooksVector

private

Definition at line 152 of file Pythia8Hadronizer.cc.

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

◆ fEmissionVetoHook

std::shared_ptr<PowhegHooks> Pythia8Hadronizer::fEmissionVetoHook

private

Definition at line 135 of file Pythia8Hadronizer.cc.

Referenced by generatePartonsAndHadronize(), hadronize(), initializeForExternalPartons(), initializeForInternalPartons(), and statistics().

◆ fEmissionVetoHook1

std::shared_ptr<EmissionVetoHook1> Pythia8Hadronizer::fEmissionVetoHook1

private

Definition at line 136 of file Pythia8Hadronizer.cc.

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

◆ fInitialState

int Pythia8Hadronizer::fInitialState

private

Definition at line 111 of file Pythia8Hadronizer.cc.

Referenced by initializeForInternalPartons(), and Pythia8Hadronizer().

◆ fJetMatchingHook

std::shared_ptr<JetMatchingHook> Pythia8Hadronizer::fJetMatchingHook

private

Definition at line 129 of file Pythia8Hadronizer.cc.

Referenced by generatePartonsAndHadronize(), hadronize(), initializeForExternalPartons(), initializeForInternalPartons(), and Pythia8Hadronizer().

◆ fJetMatchingPy8InternalHook

std::shared_ptr<Pythia8::JetMatchingMadgraph> Pythia8Hadronizer::fJetMatchingPy8InternalHook

private

Definition at line 130 of file Pythia8Hadronizer.cc.

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

◆ fMergingHook

std::shared_ptr<Pythia8::amcnlo_unitarised_interface> Pythia8Hadronizer::fMergingHook

private

Definition at line 131 of file Pythia8Hadronizer.cc.

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

◆ fPowhegHooksBB4L

std::shared_ptr<PowhegHooksBB4L> Pythia8Hadronizer::fPowhegHooksBB4L

private

Definition at line 140 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ fPowhegResHook

std::shared_ptr<PowhegResHook> Pythia8Hadronizer::fPowhegResHook

private

Definition at line 139 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ fPTFilterHook

std::shared_ptr<PTFilterHook> Pythia8Hadronizer::fPTFilterHook

private

Definition at line 149 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ fResonanceDecayFilterHook

std::shared_ptr<ResonanceDecayFilterHook> Pythia8Hadronizer::fResonanceDecayFilterHook

private

Definition at line 146 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ fReweightEmpUserHook

std::shared_ptr<UserHooks> Pythia8Hadronizer::fReweightEmpUserHook

private

Definition at line 123 of file Pythia8Hadronizer.cc.

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

◆ fReweightPtHatRapUserHook

std::shared_ptr<UserHooks> Pythia8Hadronizer::fReweightPtHatRapUserHook

private

Definition at line 125 of file Pythia8Hadronizer.cc.

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

◆ fReweightRapUserHook

std::shared_ptr<UserHooks> Pythia8Hadronizer::fReweightRapUserHook

private

Definition at line 124 of file Pythia8Hadronizer.cc.

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

◆ fReweightUserHook

std::shared_ptr<UserHooks> Pythia8Hadronizer::fReweightUserHook

private

Definition at line 122 of file Pythia8Hadronizer.cc.

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

◆ fTopRecoilHook

std::shared_ptr<TopRecoilHook> Pythia8Hadronizer::fTopRecoilHook

private

Definition at line 155 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ fUserHooksVector

std::shared_ptr<UserHooksVector> Pythia8Hadronizer::fUserHooksVector

private

Definition at line 117 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

◆ lhaUP

std::shared_ptr<LHAupLesHouches> Pythia8Hadronizer::lhaUP

private

Definition at line 108 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

◆ LHEInputFileName

std::string Pythia8Hadronizer::LHEInputFileName

private

Definition at line 107 of file Pythia8Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

◆ nFSRveto

int Pythia8Hadronizer::nFSRveto

private

Definition at line 175 of file Pythia8Hadronizer.cc.

Referenced by generatePartonsAndHadronize(), hadronize(), and statistics().

◆ nISRveto

int Pythia8Hadronizer::nISRveto

private

Definition at line 174 of file Pythia8Hadronizer.cc.

Referenced by generatePartonsAndHadronize(), hadronize(), and statistics().

◆ nME

int Pythia8Hadronizer::nME

private

Definition at line 171 of file Pythia8Hadronizer.cc.

Referenced by finalizeEvent(), generatePartonsAndHadronize(), and hadronize().

◆ nMEFiltered

int Pythia8Hadronizer::nMEFiltered

private

Definition at line 172 of file Pythia8Hadronizer.cc.

Referenced by finalizeEvent(), generatePartonsAndHadronize(), and hadronize().

◆ p8SharedResources

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

staticprivate

Definition at line 168 of file Pythia8Hadronizer.cc.

◆ UserHooksSet

bool Pythia8Hadronizer::UserHooksSet

private

Definition at line 118 of file Pythia8Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ Pythia8Hadronizer()

◆ ~Pythia8Hadronizer()

Member Function Documentation

◆ classname()

◆ doSetRandomEngine()

◆ doSharedResources()

◆ finalizeEvent()

◆ generatePartonsAndHadronize()

◆ getGenLumiInfoHeader()

◆ hadronize()

◆ initializeForExternalPartons()

◆ initializeForInternalPartons()

◆ residualDecay()

◆ statistics()

Member Data Documentation

◆ comEnergy

◆ DJR

◆ EV1_emittedMode

◆ EV1_maxVetoCount

◆ EV1_MPIvetoOn

◆ EV1_nFinal

◆ EV1_nFinalMode

◆ EV1_pTdefMode

◆ EV1_pTempMode

◆ EV1_pThardMode

◆ EV1_QEDvetoMode

◆ EV1_vetoOn

◆ fBeam1PZ

◆ fBeam2PZ

◆ fBiasedTauDecayer

◆ fCustomHooksVector

◆ fEmissionVetoHook

◆ fEmissionVetoHook1

◆ fInitialState

◆ fJetMatchingHook

◆ fJetMatchingPy8InternalHook

◆ fMergingHook

◆ fPowhegHooksBB4L

◆ fPowhegResHook

◆ fPTFilterHook

◆ fResonanceDecayFilterHook

◆ fReweightEmpUserHook

◆ fReweightPtHatRapUserHook

◆ fReweightRapUserHook

◆ fReweightUserHook

◆ fTopRecoilHook

◆ fUserHooksVector

◆ lhaUP

◆ LHEInputFileName

◆ nFSRveto

◆ nISRveto

◆ nME

◆ nMEFiltered

◆ p8SharedResources

◆ UserHooksSet