Inheritance diagram for Pythia8HepMC3Hadronizer:

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

	Pythia8HepMC3Hadronizer (const edm::ParameterSet &params)

virtual bool	residualDecay ()

void	statistics () override

	~Pythia8HepMC3Hadronizer () override=default

Public Member Functions inherited from gen::Py8HMC3InterfaceBase
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)

	Py8HMC3InterfaceBase (edm::ParameterSet const &ps)

P8RndmEngine &	randomEngine ()

bool	readSettings (int)

	~Py8HMC3InterfaceBase () override=default

Public Member Functions inherited from gen::BaseHadronizer
	BaseHadronizer (edm::ParameterSet const &ps)

void	cleanLHE ()

void	generateLHE (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine, unsigned int ncpu)

edm::Event &	getEDMEvent () const

std::unique_ptr< HepMC::GenEvent >	getGenEvent ()

std::unique_ptr< HepMC3::GenEvent >	getGenEvent3 ()

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

std::unique_ptr< GenEventInfoProduct3 >	getGenEventInfo3 ()

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< 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::Py8HMC3InterfaceBase
std::shared_ptr< Pythia8::EvtGenDecays >	evtgenDecays

std::string	evtgenDecFile

std::string	evtgenPdlFile

std::vector< std::string >	evtgenUserFiles

std::unique_ptr< Pythia8::Pythia >	fDecayer

std::unique_ptr< Pythia8::Pythia >	fMasterGen

edm::ParameterSet	fParameters

unsigned int	maxEventsToPrint

bool	pythiaHepMCVerbosity

bool	pythiaHepMCVerbosityParticles

unsigned int	pythiaPylistVerbosity

std::string	slhafile_

HepMC3::Pythia8ToHepMC3	toHepMC

bool	useEvtGen

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

std::string	lheFile_

int	randomIndex_

Detailed Description

Definition at line 78 of file Pythia8HepMC3Hadronizer.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
PP
PPbar
ElectronPositron

Definition at line 109 of file Pythia8HepMC3Hadronizer.cc.

109 { PP, PPbar, ElectronPositron };

Pythia8HepMC3Hadronizer::ElectronPositron

Definition: Pythia8HepMC3Hadronizer.cc:109

Pythia8HepMC3Hadronizer::PP

Definition: Pythia8HepMC3Hadronizer.cc:109

Pythia8HepMC3Hadronizer::PPbar

Definition: Pythia8HepMC3Hadronizer.cc:109

Constructor & Destructor Documentation

◆ Pythia8HepMC3Hadronizer()

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

Definition at line 176 of file Pythia8HepMC3Hadronizer.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::Py8HMC3InterfaceBase::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::Py8HMC3InterfaceBase::toHepMC.

     : Py8HMC3InterfaceBase(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 = 3;
   // 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";
   }
 }

◆ ~Pythia8HepMC3Hadronizer()

Pythia8HepMC3Hadronizer::~Pythia8HepMC3Hadronizer ( )

overridedefault

Member Function Documentation

◆ classname()

const char* Pythia8HepMC3Hadronizer::classname ( ) const

inlineoverridevirtual

Implements gen::Py8HMC3InterfaceBase.

Definition at line 95 of file Pythia8HepMC3Hadronizer.cc.

95 { return "Pythia8HepMC3Hadronizer"; }

◆ doSetRandomEngine()

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

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 100 of file Pythia8HepMC3Hadronizer.cc.

References findQualityFiles::v.

100 { p8SetRandomEngine(v); }

findQualityFiles.v

v

Definition: findQualityFiles.py:179

gen::Py8HMC3InterfaceBase::p8SetRandomEngine

void p8SetRandomEngine(CLHEP::HepRandomEngine *v)

Definition: Py8HMC3InterfaceBase.h:40

◆ doSharedResources()

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

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 101 of file Pythia8HepMC3Hadronizer.cc.

101 { return p8SharedResources; }

Pythia8HepMC3Hadronizer::p8SharedResources

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

Definition: Pythia8HepMC3Hadronizer.cc:164

◆ finalizeEvent()

void Pythia8HepMC3Hadronizer::finalizeEvent ( )

overridevirtual

Implements gen::Py8HMC3InterfaceBase.

Definition at line 951 of file Pythia8HepMC3Hadronizer.cc.

References gather_cfg::cout, DJR, relativeConstraints::empty, gen::BaseHadronizer::event3(), gen::BaseHadronizer::eventInfo3(), gen::Py8HMC3InterfaceBase::fMasterGen, gen::BaseHadronizer::lheEvent(), mps_splice::line, gen::Py8HMC3InterfaceBase::maxEventsToPrint, nME, nMEFiltered, AlCaHLTBitMon_ParallelJobs::p, ecalTrigSettings_cff::particles, push_back(), gen::Py8HMC3InterfaceBase::pythiaHepMCVerbosity, gen::Py8HMC3InterfaceBase::pythiaHepMCVerbosityParticles, gen::Py8HMC3InterfaceBase::pythiaPylistVerbosity, and hltDeepSecondaryVertexTagInfosPFPuppi_cfi::weights.

                                             {
   bool lhe = lheEvent() != nullptr;
 
   // protection against empty weight container
   if ((event3()->weights()).empty())
     (event3()->weights()).push_back(1.);
 
   // now create the GenEventInfo product from the GenEvent and fill
   // the missing pieces
   eventInfo3() = std::make_unique<GenEventInfoProduct3>(event3().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) {
     eventInfo3()->setBinningValues(std::vector<double>(1, fMasterGen->info.pTHat()));
   }
 
   eventInfo3()->setDJR(DJR);
   eventInfo3()->setNMEPartons(nME);
   eventInfo3()->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;
       //event3()->print();
       HepMC3::Print::listing(*(event3().get()));
     }
     if (pythiaHepMCVerbosityParticles) {
       std::cout << "Event process = " << fMasterGen->info.code() << "\n"
                 << "----------------------" << std::endl;
       //ascii_io->write_event(event().get());
       for (const auto &p : (event3().get())->particles()) {
         HepMC3::Print::line(p, true);
       }
     }
   }
 }

◆ generatePartonsAndHadronize()

bool Pythia8HepMC3Hadronizer::generatePartonsAndHadronize ( )

overridevirtual

Implements gen::Py8HMC3InterfaceBase.

Definition at line 700 of file Pythia8HepMC3Hadronizer.cc.

References funct::abs(), DJR, gen::BaseHadronizer::event(), gen::BaseHadronizer::event3(), gen::Py8HMC3InterfaceBase::evtgenDecays, fEmissionVetoHook, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8HMC3InterfaceBase::fMasterGen, fMergingHook, mps_fire::i, crabWrapper::key, gen::BaseHadronizer::lheEvent(), SiStripPI::min, nFSRveto, nISRveto, nME, nMEFiltered, and gen::Py8HMC3InterfaceBase::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>();
   event3() = std::make_unique<HepMC3::GenEvent>();
   bool py8hepmc = toHepMC.fill_next_event(*(fMasterGen.get()), event3().get());
 
   if (!py8hepmc) {
     return false;
   }
 
   // 0th weight is not filled anymore since v8.30x, pushback manually
   event3()->weights().push_back(fMasterGen->info.weight());
 
   //add ckkw/umeps/unlops merging weight
   if (mergeweight != 1.) {
     event3()->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];
       event3()->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);
       event3()->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);
       event3()->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 > Pythia8HepMC3Hadronizer::getGenLumiInfoHeader ( ) const

overridevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 999 of file Pythia8HepMC3Hadronizer.cc.

References gen::Py8HMC3InterfaceBase::fMasterGen, genWeightsTable_cfi::genLumiInfoHeader, mps_fire::i, crabWrapper::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 Pythia8HepMC3Hadronizer::hadronize ( )

Definition at line 813 of file Pythia8HepMC3Hadronizer.cc.

References funct::abs(), lhef::LHEEvent::count(), DJR, gen::BaseHadronizer::event(), gen::BaseHadronizer::event3(), gen::Py8HMC3InterfaceBase::evtgenDecays, fEmissionVetoHook, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8HMC3InterfaceBase::fMasterGen, fMergingHook, mps_fire::i, lhef::LHERunInfo::kAccepted, lhef::LHERunInfo::kSelected, lhaUP, gen::BaseHadronizer::lheEvent(), LHEInputFileName, SiStripPI::min, nFSRveto, nISRveto, nME, nMEFiltered, and gen::Py8HMC3InterfaceBase::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);
     event3().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>();
   event3() = std::make_unique<HepMC3::GenEvent>();
   bool py8hepmc = toHepMC.fill_next_event(*(fMasterGen.get()), event3().get());
 
   if (!py8hepmc) {
     return false;
   }
 
   // 0th weight is not filled anymore since v8.30x, pushback manually
   event3()->weights().push_back(fMasterGen->info.weight());
 
   //add ckkw/umeps/unlops merging weight
   if (mergeweight != 1.) {
     event3()->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);
       event3()->weights().push_back(wgt);
     }
   }
 
   return true;
 }

◆ initializeForExternalPartons()

bool Pythia8HepMC3Hadronizer::initializeForExternalPartons ( )

Definition at line 513 of file Pythia8HepMC3Hadronizer.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);
   }
 
   //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 Pythia8HepMC3Hadronizer::initializeForInternalPartons ( )

overridevirtual

Implements gen::Py8HMC3InterfaceBase.

Definition at line 341 of file Pythia8HepMC3Hadronizer.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);
   }
 
   //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 Pythia8HepMC3Hadronizer::residualDecay ( )

virtual

Definition at line 891 of file Pythia8HepMC3Hadronizer.cc.

References gen::BaseHadronizer::event(), gen::BaseHadronizer::event3(), gen::Py8HMC3InterfaceBase::fDecayer, gen::Py8HMC3InterfaceBase::fMasterGen, GenParticle::GenParticle, AlCaHLTBitMon_ParallelJobs::p, ecalTrigSettings_cff::particles, mps_fire::result, and gen::Py8HMC3InterfaceBase::toHepMC.

                                             {
   Event *pythiaEvent = &(fMasterGen->event);
 
   int NPartsBeforeDecays = pythiaEvent->size() - 1;  // do NOT count the very 1st "system" particle
                                                      // in Pythia8::Event record; it does NOT even
                                                      // get translated by the HepMCInterface to the
                                                      // HepMC::GenEvent record !!!
   //int NPartsAfterDecays = event().get()->particles_size();
   int NPartsAfterDecays = 0;
   for (auto p : (event3().get())->particles()) {
     NPartsAfterDecays++;
   }
 
   if (NPartsAfterDecays == NPartsBeforeDecays)
     return true;
 
   bool result = true;
 
 // this below is to be rewritten in future development, then it will be uncommented
 #if 0
   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);
     }
   }
 #endif
 
   return result;
 }

◆ statistics()

void Pythia8HepMC3Hadronizer::statistics ( )

overridevirtual

Reimplemented from gen::Py8HMC3InterfaceBase.

Definition at line 684 of file Pythia8HepMC3Hadronizer.cc.

References submitPVResolutionJobs::err, fEmissionVetoHook, gen::Py8HMC3InterfaceBase::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));
 }