Pythia8HepMC3Hadronizer Class Reference

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.

{ PP, PPbar, ElectronPositron };

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.

{ 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.

{ p8SetRandomEngine(v); }

doSharedResources()

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

inlineoverrideprivatevirtual

Reimplemented from gen::BaseHadronizer.

Definition at line 101 of file Pythia8HepMC3Hadronizer.cc.

{ return p8SharedResources; }

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, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, submitPVResolutionJobs::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, 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 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.

References l1ct::clear(), edm::errors::Configuration, gen::Py8HMC3InterfaceBase::evtgenDecays, gen::Py8HMC3InterfaceBase::evtgenDecFile, gen::Py8HMC3InterfaceBase::evtgenPdlFile, gen::Py8HMC3InterfaceBase::evtgenUserFiles, Exception, fBiasedTauDecayer, fCustomHooksVector, gen::Py8HMC3InterfaceBase::fDecayer, fEmissionVetoHook, fEmissionVetoHook1, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8HMC3InterfaceBase::fMasterGen, fMergingHook, fPowhegHooksBB4L, fPowhegResHook, fPTFilterHook, fResonanceDecayFilterHook, fReweightEmpUserHook, fReweightPtHatRapUserHook, fReweightRapUserHook, fReweightUserHook, fUserHooksVector, mps_fire::i, lhaUP, LHEInputFileName, gen::BaseHadronizer::lheRunInfo(), push_back(), gen::Py8HMC3InterfaceBase::pythiaPylistVerbosity, MatrixUtil::remove(), generator_cfi::scheme, gen::Py8HMC3InterfaceBase::slhafile_, mps_update::status, gen::Py8HMC3InterfaceBase::useEvtGen, and UserHooksSet.

                                                           {
  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.

References l1ct::clear(), comEnergy, edm::errors::Configuration, ElectronPositron, gen::Py8HMC3InterfaceBase::evtgenDecays, gen::Py8HMC3InterfaceBase::evtgenDecFile, gen::Py8HMC3InterfaceBase::evtgenPdlFile, gen::Py8HMC3InterfaceBase::evtgenUserFiles, Exception, fBiasedTauDecayer, fCustomHooksVector, gen::Py8HMC3InterfaceBase::fDecayer, fEmissionVetoHook, fEmissionVetoHook1, fInitialState, fJetMatchingHook, fJetMatchingPy8InternalHook, gen::Py8HMC3InterfaceBase::fMasterGen, fMergingHook, fPowhegHooksBB4L, fPowhegResHook, fPTFilterHook, fResonanceDecayFilterHook, fReweightEmpUserHook, fReweightPtHatRapUserHook, fReweightRapUserHook, fReweightUserHook, fUserHooksVector, mps_fire::i, gen::BaseHadronizer::lheFile_, PP, PPbar, push_back(), gen::Py8HMC3InterfaceBase::pythiaPylistVerbosity, MatrixUtil::remove(), generator_cfi::scheme, gen::Py8HMC3InterfaceBase::slhafile_, mps_update::status, gen::Py8HMC3InterfaceBase::useEvtGen, and UserHooksSet.

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

Member Data Documentation

comEnergy

double Pythia8HepMC3Hadronizer::comEnergy

private

Center-of-Mass energy.

Definition at line 104 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForInternalPartons().

DJR

vector<float> Pythia8HepMC3Hadronizer::DJR

private

Definition at line 166 of file Pythia8HepMC3Hadronizer.cc.

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

EV1_emittedMode

int Pythia8HepMC3Hadronizer::EV1_emittedMode

private

Definition at line 158 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_maxVetoCount

int Pythia8HepMC3Hadronizer::EV1_maxVetoCount

private

Definition at line 155 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_MPIvetoOn

bool Pythia8HepMC3Hadronizer::EV1_MPIvetoOn

private

Definition at line 160 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_nFinal

int Pythia8HepMC3Hadronizer::EV1_nFinal

private

Definition at line 153 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_nFinalMode

int Pythia8HepMC3Hadronizer::EV1_nFinalMode

private

Definition at line 162 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_pTdefMode

int Pythia8HepMC3Hadronizer::EV1_pTdefMode

private

Definition at line 159 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_pTempMode

int Pythia8HepMC3Hadronizer::EV1_pTempMode

private

Definition at line 157 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_pThardMode

int Pythia8HepMC3Hadronizer::EV1_pThardMode

private

Definition at line 156 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_QEDvetoMode

int Pythia8HepMC3Hadronizer::EV1_QEDvetoMode

private

Definition at line 161 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

EV1_vetoOn

bool Pythia8HepMC3Hadronizer::EV1_vetoOn

private

Definition at line 154 of file Pythia8HepMC3Hadronizer.cc.

Referenced by Pythia8HepMC3Hadronizer().

fBeam1PZ

double Pythia8HepMC3Hadronizer::fBeam1PZ

private

Definition at line 112 of file Pythia8HepMC3Hadronizer.cc.

fBeam2PZ

double Pythia8HepMC3Hadronizer::fBeam2PZ

private

Definition at line 113 of file Pythia8HepMC3Hadronizer.cc.

fBiasedTauDecayer

std::shared_ptr<BiasedTauDecayer> Pythia8HepMC3Hadronizer::fBiasedTauDecayer

private

Definition at line 142 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

fCustomHooksVector

std::shared_ptr<UserHooksVector> Pythia8HepMC3Hadronizer::fCustomHooksVector

private

Definition at line 151 of file Pythia8HepMC3Hadronizer.cc.

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

fEmissionVetoHook

std::shared_ptr<PowhegHooks> Pythia8HepMC3Hadronizer::fEmissionVetoHook

private

Definition at line 134 of file Pythia8HepMC3Hadronizer.cc.

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

fEmissionVetoHook1

std::shared_ptr<EmissionVetoHook1> Pythia8HepMC3Hadronizer::fEmissionVetoHook1

private

Definition at line 135 of file Pythia8HepMC3Hadronizer.cc.

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

fInitialState

int Pythia8HepMC3Hadronizer::fInitialState

private

Definition at line 110 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForInternalPartons(), and Pythia8HepMC3Hadronizer().

fJetMatchingHook

std::shared_ptr<JetMatchingHook> Pythia8HepMC3Hadronizer::fJetMatchingHook

private

Definition at line 128 of file Pythia8HepMC3Hadronizer.cc.

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

fJetMatchingPy8InternalHook

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

private

Definition at line 129 of file Pythia8HepMC3Hadronizer.cc.

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

fMergingHook

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

private

Definition at line 130 of file Pythia8HepMC3Hadronizer.cc.

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

fPowhegHooksBB4L

std::shared_ptr<PowhegHooksBB4L> Pythia8HepMC3Hadronizer::fPowhegHooksBB4L

private

Definition at line 139 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

fPowhegResHook

std::shared_ptr<PowhegResHook> Pythia8HepMC3Hadronizer::fPowhegResHook

private

Definition at line 138 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

fPTFilterHook

std::shared_ptr<PTFilterHook> Pythia8HepMC3Hadronizer::fPTFilterHook

private

Definition at line 148 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

fResonanceDecayFilterHook

std::shared_ptr<ResonanceDecayFilterHook> Pythia8HepMC3Hadronizer::fResonanceDecayFilterHook

private

Definition at line 145 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

fReweightEmpUserHook

std::shared_ptr<UserHooks> Pythia8HepMC3Hadronizer::fReweightEmpUserHook

private

Definition at line 122 of file Pythia8HepMC3Hadronizer.cc.

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

fReweightPtHatRapUserHook

std::shared_ptr<UserHooks> Pythia8HepMC3Hadronizer::fReweightPtHatRapUserHook

private

Definition at line 124 of file Pythia8HepMC3Hadronizer.cc.

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

fReweightRapUserHook

std::shared_ptr<UserHooks> Pythia8HepMC3Hadronizer::fReweightRapUserHook

private

Definition at line 123 of file Pythia8HepMC3Hadronizer.cc.

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

fReweightUserHook

std::shared_ptr<UserHooks> Pythia8HepMC3Hadronizer::fReweightUserHook

private

Definition at line 121 of file Pythia8HepMC3Hadronizer.cc.

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

fUserHooksVector

std::shared_ptr<UserHooksVector> Pythia8HepMC3Hadronizer::fUserHooksVector

private

Definition at line 116 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().

lhaUP

std::shared_ptr<LHAupLesHouches> Pythia8HepMC3Hadronizer::lhaUP

private

Definition at line 107 of file Pythia8HepMC3Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

LHEInputFileName

std::string Pythia8HepMC3Hadronizer::LHEInputFileName

private

Definition at line 106 of file Pythia8HepMC3Hadronizer.cc.

Referenced by hadronize(), and initializeForExternalPartons().

nFSRveto

int Pythia8HepMC3Hadronizer::nFSRveto

private

Definition at line 171 of file Pythia8HepMC3Hadronizer.cc.

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

nISRveto

int Pythia8HepMC3Hadronizer::nISRveto

private

Definition at line 170 of file Pythia8HepMC3Hadronizer.cc.

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

nME

int Pythia8HepMC3Hadronizer::nME

private

Definition at line 167 of file Pythia8HepMC3Hadronizer.cc.

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

nMEFiltered

int Pythia8HepMC3Hadronizer::nMEFiltered

private

Definition at line 168 of file Pythia8HepMC3Hadronizer.cc.

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

p8SharedResources

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

staticprivate

Definition at line 164 of file Pythia8HepMC3Hadronizer.cc.

UserHooksSet

bool Pythia8HepMC3Hadronizer::UserHooksSet

private

Definition at line 117 of file Pythia8HepMC3Hadronizer.cc.

Referenced by initializeForExternalPartons(), and initializeForInternalPartons().