#include <Example/ExternalLHEProducer/src/ExternalLHEProducer.cc>

Inheritance diagram for ExternalLHEProducer:

Classes
class	FileCloseSentry

Public Member Functions
	ExternalLHEProducer (const edm::ParameterSet &iConfig)

Public Member Functions inherited from edm::one::EDProducer< edm::BeginRunProducer, edm::one::WatchRuns >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	beginRunProduce (edm::Run &run, edm::EventSetup const &es) override

int	closeDescriptors (int preserve) const

void	endRun (edm::Run const &, edm::EventSetup const &) override

void	executeScript (std::vector< std::string > const &args, int id) const

std::unique_ptr< LHERunInfoProduct >	generateRunInfo (std::vector< std::string > const &files) const

std::vector< std::string >	makeArgs (uint32_t nEvents, unsigned int nThreads, std::uint32_t seed) const

void	nextEvent ()

void	preallocThreads (unsigned int) override

void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
const std::vector< std::string >	args_

edm::EDPutTokenT< LHERunInfoProduct >	beginRunPutToken_

edm::EDPutTokenT< LHEEventProduct >	eventPutToken_

bool	generateConcurrently_ {false}

uint32_t	nEvents_

uint32_t	npars_

std::map< unsigned, std::pair< unsigned, unsigned > >	nPartonMapping_ {}

unsigned int	nThreads_ {1}

std::string	outputContents_

std::string	outputFile_

std::shared_ptr< lhef::LHEEvent >	partonLevel_

std::unique_ptr< lhef::LHEReader >	reader_

std::string	scriptName_

bool	storeXML_

bool	wasMerged_

edm::EDPutTokenT< LHEXMLStringProduct >	xmlPutToken_

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 68 of file ExternalLHEProducer.cc.

Constructor & Destructor Documentation

◆ ExternalLHEProducer()

ExternalLHEProducer::ExternalLHEProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 127 of file ExternalLHEProducer.cc.

     : scriptName_((iConfig.getParameter<edm::FileInPath>("scriptName")).fullPath()),
       outputFile_(iConfig.getParameter<std::string>("outputFile")),
       args_(iConfig.getParameter<std::vector<std::string>>("args")),
       npars_(iConfig.getParameter<uint32_t>("numberOfParameters")),
       nEvents_(iConfig.getUntrackedParameter<uint32_t>("nEvents")),
       storeXML_(iConfig.getUntrackedParameter<bool>("storeXML")),
       generateConcurrently_(iConfig.getUntrackedParameter<bool>("generateConcurrently")) {
   if (npars_ != args_.size())
     throw cms::Exception("ExternalLHEProducer")
         << "Problem with configuration: " << args_.size() << " script arguments given, expected " << npars_;
  
   if (iConfig.exists("nPartonMapping")) {
     auto& processMap(iConfig.getParameterSetVector("nPartonMapping"));
     for (auto& cfg : processMap) {
       unsigned processId(cfg.getParameter<unsigned>("idprup"));
  
       auto orderStr(cfg.getParameter<std::string>("order"));
       unsigned order(0);
       if (orderStr == "LO")
         order = 0;
       else if (orderStr == "NLO")
         order = 1;
       else
         throw cms::Exception("ExternalLHEProducer")
             << "Invalid order specification for process " << processId << ": " << orderStr;
  
       unsigned np(cfg.getParameter<unsigned>("np"));
  
       nPartonMapping_.emplace(processId, std::make_pair(order, np));
     }
   }
  
   xmlPutToken_ = produces<LHEXMLStringProduct, edm::Transition::BeginRun>("LHEScriptOutput");
  
   eventPutToken_ = produces<LHEEventProduct>();
   beginRunPutToken_ = produces<LHERunInfoProduct, edm::Transition::BeginRun>();
 }

References args_, beginRunPutToken_, looper::cfg, eventPutToken_, Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameterSetVector(), np, npars_, nPartonMapping_, eventshapeDQM_cfi::order, AlCaHLTBitMon_QueryRunRegistry::string, and xmlPutToken_.

Member Function Documentation

◆ beginRun()

void ExternalLHEProducer::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	es
	)

overrideprivate

Definition at line 328 of file ExternalLHEProducer.cc.

328 {}

◆ beginRunProduce()

void ExternalLHEProducer::beginRunProduce	(	edm::Run &	run,
		edm::EventSetup const &	es
	)

overrideprivate

Definition at line 234 of file ExternalLHEProducer.cc.

                                                                               {
   // pass the number of events as previous to last argument
  
   // pass the random number generator seed as last argument
  
   edm::Service<edm::RandomNumberGenerator> rng;
  
   if (!rng.isAvailable()) {
     throw cms::Exception("Configuration")
         << "The ExternalLHEProducer module requires the RandomNumberGeneratorService\n"
            "which is not present in the configuration file.  You must add the service\n"
            "in the configuration file if you want to run ExternalLHEProducer";
   }
  
   std::vector<std::string> infiles;
   auto const seed = rng->mySeed();
   if (generateConcurrently_) {
     infiles.resize(nThreads_);
     auto const nEventsAve = nEvents_ / nThreads_;
     unsigned int const overflow = nThreads_ - (nEvents_ % nThreads_);
     std::exception_ptr except;
     std::atomic<char> exceptSet{0};
  
     tbb::this_task_arena::isolate([this, &except, &infiles, &exceptSet, nEventsAve, overflow, seed]() {
       tbb::task_group group;
       for (unsigned int t = 0; t < nThreads_; ++t) {
         uint32_t nEvents = nEventsAve;
         if (nEvents_ % nThreads_ != 0 and t >= overflow) {
           nEvents += 1;
         }
         group.run([t, this, &infiles, seed, nEvents, &except, &exceptSet]() {
           CMS_SA_ALLOW try {
             using namespace std::filesystem;
             using namespace std::string_literals;
             auto out = path("thread"s + std::to_string(t)) / path(outputFile_);
             infiles[t] = out.native();
             executeScript(makeArgs(nEvents, 1, seed + t), t);
           } catch (...) {
             char expected = 0;
             if (exceptSet.compare_exchange_strong(expected, 1)) {
               except = std::current_exception();
               exceptSet.store(2);
             }
           }
         });
       }
       group.wait();
     });
     if (exceptSet != 0) {
       std::rethrow_exception(except);
     }
   } else {
     infiles = std::vector<std::string>(1, outputFile_);
     executeScript(makeArgs(nEvents_, nThreads_, seed), 0);
   }
  
   //fill LHEXMLProduct (streaming read directly into compressed buffer to save memory)
   std::unique_ptr<LHEXMLStringProduct> p(new LHEXMLStringProduct);
  
   //store the XML file only if explictly requested
   if (storeXML_) {
     std::string file;
     if (generateConcurrently_) {
       using namespace std::filesystem;
       file = (path("thread0") / path(outputFile_)).native();
     } else {
       file = outputFile_;
     }
     std::ifstream instream(file);
     if (!instream) {
       throw cms::Exception("OutputOpenError") << "Unable to open script output file " << outputFile_ << ".";
     }
     instream.seekg(0, instream.end);
     int insize = instream.tellg();
     instream.seekg(0, instream.beg);
     p->fillCompressedContent(instream, 0.25 * insize);
     instream.close();
   }
   run.put(xmlPutToken_, std::move(p));
  
   //Read the beginning of each file to get the run info in order to do the merge
   auto runInfo = generateRunInfo(infiles);
   if (runInfo) {
     run.put(beginRunPutToken_, std::move(runInfo));
   }
  
   // LHE C++ classes translation
   // (read back uncompressed file from disk in streaming mode again to save memory)
   unsigned int skip = 0;
   reader_ = std::make_unique<lhef::LHEReader>(infiles, skip);
  
   nextEvent();
 }

References beginRunPutToken_, CMS_SA_ALLOW, Exception, executeScript(), FrontierConditions_GlobalTag_cff::file, generateConcurrently_, generateRunInfo(), watchdog::group, edm::Service< T >::isAvailable(), makeArgs(), eostools::move(), edm::RandomNumberGenerator::mySeed(), nEvents, nEvents_, nextEvent(), nThreads_, MillePedeFileConverter_cfg::out, outputFile_, AlCaHLTBitMon_ParallelJobs::p, castor_dqm_sourceclient_file_cfg::path, reader_, writedatasetfile::run, submitPVValidationJobs::runInfo, alignCSCRings::s, fileCollector::seed, optionsL1T::skip, storeXML_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, and xmlPutToken_.

◆ closeDescriptors()

int ExternalLHEProducer::closeDescriptors ( int preserve ) const

private

Definition at line 380 of file ExternalLHEProducer.cc.

                                                             {
   int maxfd = 1024;
   int fd;
 #ifdef __linux__
   DIR* dir;
   struct dirent* dp;
   maxfd = preserve;
   if ((dir = opendir("/proc/self/fd"))) {
     errno = 0;
     while ((dp = readdir(dir)) != nullptr) {
       if ((strcmp(dp->d_name, ".") == 0) || (strcmp(dp->d_name, "..") == 0)) {
         continue;
       }
       if (sscanf(dp->d_name, "%d", &fd) != 1) {
         //throw cms::Exception("closeDescriptors") << "Found unexpected filename in /proc/self/fd: " << dp->d_name;
         return -1;
       }
       if (fd > maxfd) {
         maxfd = fd;
       }
     }
     if (errno) {
       //throw cms::Exception("closeDescriptors") << "Unable to determine the number of fd (errno=" << errno << ", " << strerror(errno) << ").";
       return errno;
     }
     closedir(dir);
   }
 #endif
   // TODO: assert for an unreasonable number of fds?
   for (fd = 3; fd < maxfd + 1; fd++) {
     if (fd != preserve)
       close(fd);
   }
   return 0;
 }

References dqmPostProcessing_online::DIR, DeadROC_duringRun::dir, Calorimetry_cff::dp, and ztee::fd.

Referenced by executeScript().

◆ endRun()

void ExternalLHEProducer::endRun	(	edm::Run const &	run,
		edm::EventSetup const &	es
	)

overrideprivate

Definition at line 330 of file ExternalLHEProducer.cc.

                                                                            {
   nextEvent();
   if (partonLevel_) {
     throw edm::Exception(edm::errors::EventGenerationFailure)
         << "Error in ExternalLHEProducer::endRunProduce().  "
         << "Event loop is over, but there are still lhe events to process."
         << "This could happen if lhe file contains more events than requested.  This is never expected to happen.";
   }
  
   reader_.reset();
   if (generateConcurrently_) {
     for (unsigned int t = 0; t < nThreads_; ++t) {
       using namespace std::filesystem;
       using namespace std::string_literals;
       auto out = path("thread"s + std::to_string(t)) / path(outputFile_);
       if (unlink(out.c_str())) {
         throw cms::Exception("OutputDeleteError") << "Unable to delete original script output file " << out
                                                   << " (errno=" << errno << ", " << strerror(errno) << ").";
       }
     }
   } else {
     if (unlink(outputFile_.c_str())) {
       throw cms::Exception("OutputDeleteError") << "Unable to delete original script output file " << outputFile_
                                                 << " (errno=" << errno << ", " << strerror(errno) << ").";
     }
   }
 }

References edm::errors::EventGenerationFailure, Exception, generateConcurrently_, nextEvent(), nThreads_, MillePedeFileConverter_cfg::out, outputFile_, partonLevel_, castor_dqm_sourceclient_file_cfg::path, reader_, alignCSCRings::s, and submitPVValidationJobs::t.

◆ executeScript()

void ExternalLHEProducer::executeScript	(	std::vector< std::string > const &	args,
		int	id
	)		const

private

Definition at line 417 of file ExternalLHEProducer.cc.

                                                                                       {
   // Fork a script, wait until it finishes.
  
   int rc = 0, rc2 = 0;
   int filedes[2], fd_flags;
  
   if (pipe(filedes)) {
     throw cms::Exception("Unable to create a new pipe");
   }
   FileCloseSentry sentry1(filedes[0]), sentry2(filedes[1]);
  
   if ((fd_flags = fcntl(filedes[1], F_GETFD, NULL)) == -1) {
     throw cms::Exception("ExternalLHEProducer")
         << "Failed to get pipe file descriptor flags (errno=" << rc << ", " << strerror(rc) << ")";
   }
   if (fcntl(filedes[1], F_SETFD, fd_flags | FD_CLOEXEC) == -1) {
     throw cms::Exception("ExternalLHEProducer")
         << "Failed to set pipe file descriptor flags (errno=" << rc << ", " << strerror(rc) << ")";
   }
  
   unsigned int argc = 1 + args.size();
   // TODO: assert that we have a reasonable number of arguments
   char** argv = new char*[argc + 1];
   argv[0] = strdup(scriptName_.c_str());
   for (unsigned int i = 1; i < argc; i++) {
     argv[i] = strdup(args[i - 1].c_str());
   }
   argv[argc] = nullptr;
  
   pid_t pid = fork();
   if (pid == 0) {
     // The child process
     if (!(rc = closeDescriptors(filedes[1]))) {
       if (generateConcurrently_) {
         using namespace std::filesystem;
         using namespace std::string_literals;
         std::error_code ec;
         auto newDir = path("thread"s + std::to_string(id));
         create_directory(newDir, ec);
         current_path(newDir, ec);
       }
       execvp(argv[0], argv);  // If execv returns, we have an error.
       rc = errno;
     }
     while ((write(filedes[1], &rc, sizeof(int)) == -1) && (errno == EINTR)) {
     }
     _exit(1);
   }
  
   // Free the arg vector ASAP
   for (unsigned int i = 0; i < args.size() + 1; i++) {
     free(argv[i]);
   }
   delete[] argv;
  
   if (pid == -1) {
     throw cms::Exception("ForkException")
         << "Unable to fork a child (errno=" << errno << ", " << strerror(errno) << ")";
   }
  
   close(filedes[1]);
   // If the exec succeeds, the read will fail.
   while (((rc2 = read(filedes[0], &rc, sizeof(int))) == -1) && (errno == EINTR)) {
     rc2 = 0;
   }
   if ((rc2 == sizeof(int)) && rc) {
     throw cms::Exception("ExternalLHEProducer")
         << "Failed to execute script (errno=" << rc << ", " << strerror(rc) << ")";
   }
   close(filedes[0]);
  
   int status = 0;
   errno = 0;
   do {
     if (waitpid(pid, &status, 0) < 0) {
       if (errno == EINTR) {
         continue;
       } else {
         throw cms::Exception("ExternalLHEProducer")
             << "Failed to read child status (errno=" << errno << ", " << strerror(errno) << ")";
       }
     }
     if (WIFSIGNALED(status)) {
       throw cms::Exception("ExternalLHEProducer") << "Child exited due to signal " << WTERMSIG(status) << ".";
     }
     if (WIFEXITED(status)) {
       rc = WEXITSTATUS(status);
       break;
     }
   } while (true);
   if (rc) {
     throw cms::Exception("ExternalLHEProducer") << "Child failed with exit code " << rc << ".";
   }
 }

References dir2webdir::argc, writedatasetfile::args, cmsBatch::argv, closeDescriptors(), Exception, generateConcurrently_, mps_fire::i, NULL, castor_dqm_sourceclient_file_cfg::path, pipe::pipe(), readEcalDQMStatus::read, alignCSCRings::s, scriptName_, mps_update::status, and writeEcalDQMStatus::write.

Referenced by beginRunProduce().

◆ fillDescriptions()

void ExternalLHEProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 513 of file ExternalLHEProducer.cc.

                                                                                      {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setComment("Executes an external script and places its output file into an EDM collection");
  
   edm::FileInPath thePath;
   desc.add<edm::FileInPath>("scriptName", thePath);
   desc.add<std::string>("outputFile", "myoutput");
   desc.add<std::vector<std::string>>("args");
   desc.add<uint32_t>("numberOfParameters");
   desc.addUntracked<uint32_t>("nEvents");
   desc.addUntracked<bool>("storeXML", false);
   desc.addUntracked<bool>("generateConcurrently", false)
       ->setComment("If true, run the script concurrently in separate processes.");
  
   edm::ParameterSetDescription nPartonMappingDesc;
   nPartonMappingDesc.add<unsigned>("idprup");
   nPartonMappingDesc.add<std::string>("order");
   nPartonMappingDesc.add<unsigned>("np");
   desc.addVPSetOptional("nPartonMapping", nPartonMappingDesc);
  
   descriptions.addDefault(desc);
 }

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ generateRunInfo()

std::unique_ptr< LHERunInfoProduct > ExternalLHEProducer::generateRunInfo ( std::vector< std::string > const & files ) const

private

Definition at line 538 of file ExternalLHEProducer.cc.

                                                                                                               {
   std::unique_ptr<LHERunInfoProduct> retValue;
   //read each file in turn and only get the header info
   for (auto const& file : iFiles) {
     unsigned int skip = 0;
     std::vector<std::string> infiles(1, file);
     auto reader = std::make_unique<lhef::LHEReader>(infiles, skip);
     auto parton = reader->next();
     if (!parton) {
       break;
     }
     auto runInfo = parton->getRunInfo();
     LHERunInfoProduct product(*runInfo->getHEPRUP());
  
     std::for_each(runInfo->getHeaders().begin(),
                   runInfo->getHeaders().end(),
                   std::bind(&LHERunInfoProduct::addHeader, &product, std::placeholders::_1));
     std::for_each(runInfo->getComments().begin(),
                   runInfo->getComments().end(),
                   std::bind(&LHERunInfoProduct::addComment, &product, std::placeholders::_1));
     if (not retValue) {
       retValue = std::make_unique<LHERunInfoProduct>(std::move(product));
     } else {
       retValue->mergeProduct(product);
     }
   }
  
   return retValue;
 }

References LHERunInfoProduct::addComment(), LHERunInfoProduct::addHeader(), FrontierConditions_GlobalTag_cff::file, eostools::move(), DQM::reader, submitPVValidationJobs::runInfo, and optionsL1T::skip.

Referenced by beginRunProduce().

◆ makeArgs()

std::vector< std::string > ExternalLHEProducer::makeArgs	(	uint32_t	nEvents,
		unsigned int	nThreads,
		std::uint32_t	seed
	)		const

private

Definition at line 358 of file ExternalLHEProducer.cc.

                                                                                {
   std::vector<std::string> args;
   args.reserve(3 + args_.size());
  
   args.push_back(args_.front());
   args.push_back(std::to_string(nEvents));
  
   args.push_back(std::to_string(seed));
  
   args.push_back(std::to_string(nThreads));
   std::copy(args_.begin() + 1, args_.end(), std::back_inserter(args));
  
   for (unsigned int iArg = 0; iArg < args.size(); iArg++) {
     LogDebug("LHEInputArgs") << "arg [" << iArg << "] = " << args[iArg];
   }
  
   return args;
 }

References writedatasetfile::args, args_, filterCSVwithJSON::copy, LogDebug, nEvents, runTheMatrix::nThreads, and fileCollector::seed.

Referenced by beginRunProduce().

◆ nextEvent()

void ExternalLHEProducer::nextEvent ( )

private

Definition at line 568 of file ExternalLHEProducer.cc.

                                     {
   if (partonLevel_)
     return;
  
   if (not reader_) {
     return;
   }
  
   partonLevel_ = reader_->next();
   if (!partonLevel_) {
     //see if we have another file to read;
     bool newFileOpened;
     do {
       newFileOpened = false;
       partonLevel_ = reader_->next(&newFileOpened);
     } while (newFileOpened && !partonLevel_);
   }
 }

References partonLevel_, and reader_.

Referenced by beginRunProduce(), endRun(), and produce().

◆ preallocThreads()

void ExternalLHEProducer::preallocThreads ( unsigned int iThreads )

overrideprivatevirtual

Reimplemented from edm::one::EDProducerBase.

Definition at line 171 of file ExternalLHEProducer.cc.

171 { nThreads_ = iThreads; }

References nThreads_.

◆ produce()

void ExternalLHEProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDProducerBase.

Definition at line 174 of file ExternalLHEProducer.cc.

                                                                                {
   nextEvent();
   if (!partonLevel_) {
     throw edm::Exception(edm::errors::EventGenerationFailure)
         << "No lhe event found in ExternalLHEProducer::produce().  "
         << "The likely cause is that the lhe file contains fewer events than were requested, which is possible "
         << "in case of phase space integration or uneweighting efficiency problems.";
   }
  
   std::unique_ptr<LHEEventProduct> product(
       new LHEEventProduct(*partonLevel_->getHEPEUP(), partonLevel_->originalXWGTUP()));
   if (partonLevel_->getPDF()) {
     product->setPDF(*partonLevel_->getPDF());
   }
   std::for_each(partonLevel_->weights().begin(),
                 partonLevel_->weights().end(),
                 std::bind(&LHEEventProduct::addWeight, product.get(), std::placeholders::_1));
   product->setScales(partonLevel_->scales());
   if (nPartonMapping_.empty()) {
     product->setNpLO(partonLevel_->npLO());
     product->setNpNLO(partonLevel_->npNLO());
   } else {
     // overwrite npLO and npNLO values by user-specified mapping
     unsigned processId(partonLevel_->getHEPEUP()->IDPRUP);
     unsigned order(0);
     unsigned np(0);
     try {
       auto procDef(nPartonMapping_.at(processId));
       order = procDef.first;
       np = procDef.second;
     } catch (std::out_of_range&) {
       throw cms::Exception("ExternalLHEProducer")
           << "Unexpected IDPRUP encountered: " << partonLevel_->getHEPEUP()->IDPRUP;
     }
  
     switch (order) {
       case 0:
         product->setNpLO(np);
         product->setNpNLO(-1);
         break;
       case 1:
         product->setNpLO(-1);
         product->setNpNLO(np);
         break;
       default:
         break;
     }
   }
  
   std::for_each(partonLevel_->getComments().begin(),
                 partonLevel_->getComments().end(),
                 std::bind(&LHEEventProduct::addComment, product.get(), std::placeholders::_1));
  
   iEvent.put(eventPutToken_, std::move(product));
  
   partonLevel_.reset();
   return;
 }

References LHEEventProduct::addComment(), LHEEventProduct::addWeight(), edm::errors::EventGenerationFailure, eventPutToken_, Exception, iEvent, lhe2HepMCConverter_cff::LHEEventProduct, eostools::move(), nextEvent(), np, nPartonMapping_, eventshapeDQM_cfi::order, and partonLevel_.

Member Data Documentation

◆ args_

const std::vector<std::string> ExternalLHEProducer::args_

private

Definition at line 91 of file ExternalLHEProducer.cc.

Referenced by ExternalLHEProducer(), makeArgs(), valtools.webpage::parseArgs(), and batchmanager.BatchManager::ParseOptions().

◆ beginRunPutToken_

edm::EDPutTokenT<LHERunInfoProduct> ExternalLHEProducer::beginRunPutToken_

private

Definition at line 108 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), and ExternalLHEProducer().

◆ eventPutToken_

edm::EDPutTokenT<LHEEventProduct> ExternalLHEProducer::eventPutToken_

private

Definition at line 107 of file ExternalLHEProducer.cc.

Referenced by ExternalLHEProducer(), and produce().

◆ generateConcurrently_

bool ExternalLHEProducer::generateConcurrently_ {false}

private

Definition at line 97 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), endRun(), and executeScript().

◆ nEvents_

uint32_t ExternalLHEProducer::nEvents_

private

Definition at line 93 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce().

◆ npars_

uint32_t ExternalLHEProducer::npars_

private

Definition at line 92 of file ExternalLHEProducer.cc.

Referenced by ExternalLHEProducer().

◆ nPartonMapping_

std::map<unsigned, std::pair<unsigned, unsigned> > ExternalLHEProducer::nPartonMapping_ {}

private

Definition at line 100 of file ExternalLHEProducer.cc.

Referenced by ExternalLHEProducer(), and produce().

◆ nThreads_

unsigned int ExternalLHEProducer::nThreads_ {1}

private

Definition at line 95 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), endRun(), and preallocThreads().

◆ outputContents_

std::string ExternalLHEProducer::outputContents_

private

Definition at line 96 of file ExternalLHEProducer.cc.

◆ outputFile_

std::string ExternalLHEProducer::outputFile_

private

Definition at line 90 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), and endRun().

◆ partonLevel_

std::shared_ptr<lhef::LHEEvent> ExternalLHEProducer::partonLevel_

private

Definition at line 103 of file ExternalLHEProducer.cc.

Referenced by endRun(), nextEvent(), and produce().

◆ reader_

std::unique_ptr<lhef::LHEReader> ExternalLHEProducer::reader_

private

Definition at line 102 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), endRun(), and nextEvent().

◆ scriptName_

std::string ExternalLHEProducer::scriptName_

private

Definition at line 89 of file ExternalLHEProducer.cc.

Referenced by executeScript().

◆ storeXML_

bool ExternalLHEProducer::storeXML_

private

Definition at line 94 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce().

◆ wasMerged_

bool ExternalLHEProducer::wasMerged_

private

Definition at line 104 of file ExternalLHEProducer.cc.

◆ xmlPutToken_

edm::EDPutTokenT<LHEXMLStringProduct> ExternalLHEProducer::xmlPutToken_

private

Definition at line 106 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), and ExternalLHEProducer().

Classes

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ExternalLHEProducer()

Member Function Documentation

◆ beginRun()

◆ beginRunProduce()

◆ closeDescriptors()

◆ endRun()

◆ executeScript()

◆ fillDescriptions()

◆ generateRunInfo()

◆ makeArgs()

◆ nextEvent()

◆ preallocThreads()

◆ produce()

Member Data Documentation

◆ args_

◆ beginRunPutToken_

◆ eventPutToken_

◆ generateConcurrently_

◆ nEvents_

◆ npars_

◆ nPartonMapping_

◆ nThreads_

◆ outputContents_

◆ outputFile_

◆ partonLevel_

◆ reader_

◆ scriptName_

◆ storeXML_

◆ wasMerged_

◆ xmlPutToken_