#include <BaseHadronizer.h>

Inheritance diagram for gen::BaseHadronizer:

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

void	cleanLHE ()

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

edm::Event &	getEDMEvent () const

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

std::unique_ptr< GenEventInfoProduct >	getGenEventInfo ()

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

GenRunInfoProduct &	getGenRunInfo ()

std::unique_ptr< lhef::LHEEvent >	getLHEEvent ()

const std::shared_ptr< lhef::LHERunInfo > &	getLHERunInfo () const

const std::string &	gridpackPath () const

int	randomIndex () const

const std::string &	randomInitConfigDescription () const

void	randomizeIndex (edm::LuminosityBlock const &lumi, CLHEP::HepRandomEngine *rengine)

void	resetEvent (std::unique_ptr< HepMC::GenEvent > event)

void	resetEventInfo (std::unique_ptr< GenEventInfoProduct > eventInfo)

virtual bool	select (HepMC::GenEvent *) const

void	setEDMEvent (edm::Event &event)

void	setLHEEvent (std::unique_ptr< lhef::LHEEvent > event)

void	setLHERunInfo (std::unique_ptr< lhef::LHERunInfo > runInfo)

void	setRandomEngine (CLHEP::HepRandomEngine *v)

std::vector< std::string > const &	sharedResources () const

virtual	~BaseHadronizer () noexcept(false)

Protected Member Functions
std::unique_ptr< HepMC::GenEvent > &	event ()

std::unique_ptr< GenEventInfoProduct > &	eventInfo ()

lhef::LHEEvent *	lheEvent ()

lhef::LHERunInfo *	lheRunInfo ()

GenRunInfoProduct &	runInfo ()

Protected Attributes
std::string	lheFile_

int	randomIndex_

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

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

Private Attributes
edm::Event *	edmEvent_

std::unique_ptr< HepMC::GenEvent >	genEvent_

std::unique_ptr< GenEventInfoProduct >	genEventInfo_

GenRunInfoProduct	genRunInfo_

std::vector< std::string >	gridpackPaths_

std::unique_ptr< lhef::LHEEvent >	lheEvent_

std::shared_ptr< lhef::LHERunInfo >	lheRunInfo_

std::vector< std::string >	randomInitConfigDescriptions_

std::vector< double >	randomInitWeights_

Static Private Attributes
static const std::vector< std::string >	theSharedResources

Detailed Description

Definition at line 46 of file BaseHadronizer.h.

Constructor & Destructor Documentation

◆ BaseHadronizer()

gen::BaseHadronizer::BaseHadronizer ( edm::ParameterSet const & ps )

Definition at line 12 of file BaseHadronizer.cc.

                                                           : randomIndex_(-1), gridpackPaths_(1) {
     if (ps.exists("RandomizedParameters")) {
       std::vector<edm::ParameterSet> randomizedParameters =
           ps.getParameter<std::vector<edm::ParameterSet> >("RandomizedParameters");
       randomInitWeights_.resize(randomizedParameters.size());
       randomInitConfigDescriptions_.resize(randomizedParameters.size());
       gridpackPaths_.resize(randomizedParameters.size());
       for (unsigned int irand = 0; irand < randomizedParameters.size(); ++irand) {
         randomInitWeights_[irand] = randomizedParameters[irand].getParameter<double>("ConfigWeight");
         if (randomizedParameters[irand].exists("ConfigDescription")) {
           randomInitConfigDescriptions_[irand] =
               randomizedParameters[irand].getParameter<std::string>("ConfigDescription");
         }
         if (randomizedParameters[irand].exists("GridpackPath")) {
           gridpackPaths_[irand] = randomizedParameters[irand].getParameter<std::string>("GridpackPath");
         }
       }
     } else {
       if (ps.exists("GridpackPath")) {
         gridpackPaths_[0] = ps.getParameter<std::string>("GridpackPath");
       }
     }
  
     runInfo().setFilterEfficiency(ps.getUntrackedParameter<double>("filterEfficiency", -1.));
     runInfo().setExternalXSecLO(GenRunInfoProduct::XSec(ps.getUntrackedParameter<double>("crossSection", -1.)));
     runInfo().setExternalXSecNLO(GenRunInfoProduct::XSec(ps.getUntrackedParameter<double>("crossSectionNLO", -1.)));
   }

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), gridpackPaths_, randomInitConfigDescriptions_, randomInitWeights_, runInfo(), GenRunInfoProduct::setExternalXSecLO(), GenRunInfoProduct::setExternalXSecNLO(), GenRunInfoProduct::setFilterEfficiency(), and AlCaHLTBitMon_QueryRunRegistry::string.

◆ ~BaseHadronizer()

virtual gen::BaseHadronizer::~BaseHadronizer ( )

inlinevirtualnoexcept

Definition at line 49 of file BaseHadronizer.h.

49 {}

Member Function Documentation

◆ cleanLHE()

void gen::BaseHadronizer::cleanLHE ( )

Definition at line 137 of file BaseHadronizer.cc.

                                 {
     if (lheFile_.empty()) {
       return;
     }
  
     std::remove(lheFile_.c_str());
   }

References lheFile_, and MatrixUtil::remove().

◆ doSetRandomEngine()

virtual void gen::BaseHadronizer::doSetRandomEngine ( CLHEP::HepRandomEngine * v )

inlineprivatevirtual

Reimplemented in gen::ReggeGribovPartonMCHadronizer, Herwig6Hadronizer, gen::Hydjet2Hadronizer, Pythia8Hadronizer, gen::Pythia6Hadronizer, Herwig7Hadronizer, gen::HydjetHadronizer, gen::ExhumeHadronizer, SherpaHadronizer, gen::PyquenHadronizer, gen::AMPTHadronizer, gen::Cascade2Hadronizer, gen::HijingHadronizer, and gen::PomwigHadronizer.

Definition at line 95 of file BaseHadronizer.h.

95 {}

Referenced by setRandomEngine().

◆ doSharedResources()

virtual std::vector<std::string> const& gen::BaseHadronizer::doSharedResources ( ) const

inlineprivatevirtual

Reimplemented in Herwig6Hadronizer, gen::Hydjet2Hadronizer, Pythia8Hadronizer, gen::Pythia6Hadronizer, gen::HydjetHadronizer, gen::ExhumeHadronizer, gen::PyquenHadronizer, gen::Cascade2Hadronizer, gen::HijingHadronizer, and gen::PomwigHadronizer.

Definition at line 97 of file BaseHadronizer.h.

97 { return theSharedResources; }

References theSharedResources.

Referenced by sharedResources().

◆ event()

std::unique_ptr<HepMC::GenEvent>& gen::BaseHadronizer::event ( )

inlineprotected

Definition at line 86 of file BaseHadronizer.h.

86 { return genEvent_; }

References genEvent_.

◆ eventInfo()

std::unique_ptr<GenEventInfoProduct>& gen::BaseHadronizer::eventInfo ( )

inlineprotected

Definition at line 87 of file BaseHadronizer.h.

87 { return genEventInfo_; }

References genEventInfo_.

Referenced by gen::Cascade2Hadronizer::finalizeEvent(), Herwig7Hadronizer::finalizeEvent(), gen::Pythia6Hadronizer::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), Herwig6Hadronizer::finalizeEvent(), and resetEventInfo().

◆ generateLHE()

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

Definition at line 69 of file BaseHadronizer.cc.

                                                       {
     if (gridpackPath().empty()) {
       return;
     }
  
     //get random seed from HepRandomEngine state plus run and lumi section numbers
     //(random engine state will be the same for every lumi section in a job)
     std::vector<long unsigned int> seeds = rengine->put();
     seeds.push_back(lumi.id().run());
     seeds.push_back(lumi.id().luminosityBlock());
     std::seed_seq seedseq(seeds.begin(), seeds.end());
     std::array<unsigned int, 1> lheseed;
     seedseq.generate(lheseed.begin(), lheseed.end());
  
     constexpr unsigned int maxseed = 30081 * 30081;  //madgraph cannot handle seeds larger than this
     unsigned int seedval = lheseed[0] % (maxseed + 1);
  
     unsigned int nevents = edm::pset::Registry::instance()
                                ->getMapped(lumi.processHistory().rbegin()->parameterSetID())
                                ->getParameter<edm::ParameterSet>("@main_input")
                                .getUntrackedParameter<unsigned int>("numberEventsInLuminosityBlock");
  
     std::ostringstream nevStream;
     nevStream << nevents;
  
     std::ostringstream randomStream;
     randomStream << seedval;
  
     edm::FileInPath script("GeneratorInterface/LHEInterface/data/run_generic_tarball_cvmfs.sh");
     const char* outfilename = "cmsgrid_final.lhe";
  
     std::array<std::string, 5> argStrs;
     argStrs[0] = script.fullPath();
     argStrs[1] = gridpackPath();
     argStrs[2] = nevStream.str();
     argStrs[3] = randomStream.str();
     argStrs[4] = std::to_string(ncpu);
     std::array<char*, 6> args{
         {&argStrs[0][0], &argStrs[1][0], &argStrs[2][0], &argStrs[3][0], &argStrs[4][0], nullptr}};
  
     pid_t pid = fork();
  
     if (pid == -1) {
       // error, failed to fork()
       throw cms::Exception("BaseHadronizer::generateLHE") << "Unable to fork a child";
     } else if (pid == 0) {
       //child
       execvp(args[0], std::begin(args));
       _exit(1);  // exec never returns
     } else {
       //parent
       int status;
       waitpid(pid, &status, 0);
       if (status) {
         throw cms::Exception("BaseHadronizer::generateLHE") << "Failed to execute script";
       }
     }
     FILE* lhef = std::fopen(outfilename, "r");
     if (!lhef) {
       throw cms::Exception("BaseHadronizer::generateLHE") << "Output file " << outfilename << " not found.";
     }
     std::fclose(lhef);
  
     lheFile_ = outfilename;
   }

References writedatasetfile::args, relativeConstraints::empty, Exception, edm::pset::Registry::getMapped(), gridpackPath(), edm::pset::Registry::instance(), lheFile_, cmsHarvester::nevents, SiStripCommissioningSource_FromRAW_cfg::outfilename, submitPVResolutionJobs::script, InitialStep_cff::seeds, and mps_update::status.

◆ getEDMEvent()

edm::Event& gen::BaseHadronizer::getEDMEvent ( ) const

inline

Definition at line 69 of file BaseHadronizer.h.

69 { return *edmEvent_; }

References edmEvent_.

Referenced by gen::PyquenHadronizer::generatePartonsAndHadronize(), gen::HydjetHadronizer::generatePartonsAndHadronize(), and gen::Hydjet2Hadronizer::generatePartonsAndHadronize().

◆ getGenEvent()

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

inline

Definition at line 53 of file BaseHadronizer.h.

53 { return std::move(genEvent_); }

References genEvent_, and eostools::move().

◆ getGenEventInfo()

std::unique_ptr<GenEventInfoProduct> gen::BaseHadronizer::getGenEventInfo ( )

inline

Definition at line 54 of file BaseHadronizer.h.

54 { return std::move(genEventInfo_); }

References genEventInfo_, and eostools::move().

◆ getGenLumiInfoHeader()

std::unique_ptr< GenLumiInfoHeader > gen::BaseHadronizer::getGenLumiInfoHeader ( ) const

virtual

Reimplemented in Pythia8Hadronizer, Herwig7Hadronizer, and SherpaHadronizer.

Definition at line 40 of file BaseHadronizer.cc.

                                                                               {
     auto genLumiInfoHeader = std::make_unique<GenLumiInfoHeader>();
  
     //fill information on randomized configs for parameter scans
     genLumiInfoHeader->setRandomConfigIndex(randomIndex_);
     if (randomIndex_ >= 0) {
       genLumiInfoHeader->setConfigDescription(randomInitConfigDescription());
     }
  
     return genLumiInfoHeader;
   }

References genWeightsTable_cfi::genLumiInfoHeader, randomIndex_, and randomInitConfigDescription().

◆ getGenRunInfo()

GenRunInfoProduct& gen::BaseHadronizer::getGenRunInfo ( )

inline

Definition at line 52 of file BaseHadronizer.h.

52 { return genRunInfo_; }

References genRunInfo_.

◆ getLHEEvent()

std::unique_ptr<lhef::LHEEvent> gen::BaseHadronizer::getLHEEvent ( )

inline

Definition at line 56 of file BaseHadronizer.h.

56 { return std::move(lheEvent_); }

References lheEvent_, and eostools::move().

◆ getLHERunInfo()

const std::shared_ptr<lhef::LHERunInfo>& gen::BaseHadronizer::getLHERunInfo ( ) const

inline

Definition at line 62 of file BaseHadronizer.h.

62 { return lheRunInfo_; }

References lheRunInfo_.

◆ gridpackPath()

const std::string& gen::BaseHadronizer::gridpackPath ( ) const

inline

Definition at line 78 of file BaseHadronizer.h.

78 { return gridpackPaths_[std::max(randomIndex_, 0)]; }

References gridpackPaths_, SiStripPI::max, and randomIndex_.

Referenced by generateLHE().

◆ lheEvent()

lhef::LHEEvent* gen::BaseHadronizer::lheEvent ( )

inlineprotected

Definition at line 89 of file BaseHadronizer.h.

89 { return lheEvent_.get(); }

References lheEvent_.

Referenced by gen::Pythia6Hadronizer::finalizeEvent(), Pythia8Hadronizer::finalizeEvent(), Herwig6Hadronizer::finalizeEvent(), Pythia8Hadronizer::generatePartonsAndHadronize(), gen::Pythia6Hadronizer::hadronize(), Pythia8Hadronizer::hadronize(), Herwig6Hadronizer::hadronize(), and Herwig6Hadronizer::upEvnt().

◆ lheRunInfo()

lhef::LHERunInfo* gen::BaseHadronizer::lheRunInfo ( )

inlineprotected

Definition at line 90 of file BaseHadronizer.h.

90 { return lheRunInfo_.get(); }

References lheRunInfo_.

Referenced by gen::Pythia6Hadronizer::finalizeEvent(), Herwig6Hadronizer::finalizeEvent(), Herwig6Hadronizer::initialize(), gen::Pythia6Hadronizer::initializeForExternalPartons(), Pythia8Hadronizer::initializeForExternalPartons(), Herwig6Hadronizer::readSettings(), and Herwig6Hadronizer::upInit().

◆ randomIndex()

int gen::BaseHadronizer::randomIndex ( ) const

inline

Definition at line 76 of file BaseHadronizer.h.

76 { return randomIndex_; }

References randomIndex_.

Referenced by gen::Py8InterfaceBase::readSettings().

◆ randomInitConfigDescription()

const std::string& gen::BaseHadronizer::randomInitConfigDescription ( ) const

inline

Definition at line 77 of file BaseHadronizer.h.

77 { return randomInitConfigDescriptions_[randomIndex_]; }

References randomIndex_, and randomInitConfigDescriptions_.

Referenced by getGenLumiInfoHeader().

◆ randomizeIndex()

void gen::BaseHadronizer::randomizeIndex	(	edm::LuminosityBlock const &	lumi,
		CLHEP::HepRandomEngine *	rengine
	)

Definition at line 52 of file BaseHadronizer.cc.

                                                                                                    {
     if (!randomInitWeights_.empty()) {
       //randomly select from a list of provided configuration sets (for parameter scans)
  
       //seeds std 32-bit mersene twister with HepRandomEngine state plus run and lumi section numbers
       //(random engine state will be the same for every lumi section in a job)
       std::vector<long unsigned int> seeds = rengine->put();
       seeds.push_back(lumi.id().run());
       seeds.push_back(lumi.id().luminosityBlock());
       std::seed_seq seedseq(seeds.begin(), seeds.end());
       std::mt19937 randgen(seedseq);
       std::discrete_distribution<int> randdist(randomInitWeights_.begin(), randomInitWeights_.end());
  
       randomIndex_ = randdist(randgen);
     }
   }