#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

	EDProducer (const EDProducer &)=delete

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

const EDProducer &	operator= (const EDProducer &)=delete

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

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)

	~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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

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, bool isPost) 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_

std::string	outputContents_

std::string	outputFile_

std::shared_ptr< lhef::LHEEvent >	partonLevel_

const std::vector< std::string >	postGenerationCommand_

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

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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

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<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

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

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

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

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 69 of file ExternalLHEProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 129 of file ExternalLHEProducer.cc.

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

     : 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")),
       postGenerationCommand_(iConfig.getUntrackedParameter<std::vector<std::string>>("postGenerationCommand")) {
   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>();
 }

Member Function Documentation

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

overrideprivate

Definition at line 342 of file ExternalLHEProducer.cc.

342 {}

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

overrideprivate

Definition at line 237 of file ExternalLHEProducer.cc.

References beginRunPutToken_, CMS_SA_ALLOW, alignCSCRings::e, Exception, executeScript(), mergeVDriftHistosByStation::file, edm::FileInPath::fullPath(), generateConcurrently_, generateRunInfo(), watchdog::group, edm::Service< T >::isAvailable(), makeArgs(), eostools::move(), edm::RandomNumberGenerator::mySeed(), submitPVValidationJobs::nEvents, nEvents_, nextEvent(), nThreads_, submitPVResolutionJobs::out, outputFile_, AlCaHLTBitMon_ParallelJobs::p, fed_dqm_sourceclient-live_cfg::path, postGenerationCommand_, edm::Run::put(), reader_, submitPVValidationJobs::runInfo, alignCSCRings::s, fileCollector::seed, createPayload::skip, storeXML_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, cond::impl::to_string(), and xmlPutToken_.

                                                                               {
   // 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, false);
           } 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, false);
   }
 
   //run post-generation command if specified
   if (!postGenerationCommand_.empty()) {
     std::vector<std::string> postcmd = postGenerationCommand_;
     try {
       postcmd[0] = edm::FileInPath(postcmd[0]).fullPath();
     } catch (const edm::Exception& e) {
       edm::LogWarning("ExternalLHEProducer") << postcmd[0] << " is not a relative path. Run it as a shell command.";
     }
     executeScript(postcmd, 0, true);
   }
 
   //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();
 }

int ExternalLHEProducer::closeDescriptors ( int preserve ) const

private

Definition at line 400 of file ExternalLHEProducer.cc.

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

Referenced by executeScript().

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

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

overrideprivate

Definition at line 344 of file ExternalLHEProducer.cc.

References edm::errors::EventGenerationFailure, Exception, generateConcurrently_, nextEvent(), nThreads_, submitPVResolutionJobs::out, outputFile_, partonLevel_, fed_dqm_sourceclient-live_cfg::path, reader_, alignCSCRings::s, submitPVValidationJobs::t, and cond::impl::to_string().

                                                                            {
   nextEvent();
   if (partonLevel_) {
     // VALIDATION_RUN env variable allows to finish event processing early without errors by sending SIGINT
     if (std::getenv("VALIDATION_RUN") != nullptr) {
       edm::LogWarning("ExternalLHEProducer")
           << "Event loop is over, but there are still lhe events to process, ignoring...";
     } else {
       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) << ").";
     }
   }
 }

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

private

Definition at line 437 of file ExternalLHEProducer.cc.

References dir2webdir::argc, cmsStageWithFailover::argv, closeDescriptors(), Exception, generateConcurrently_, mps_fire::i, NULL, fed_dqm_sourceclient-live_cfg::path, pipe::pipe(), SiPixelLorentzAngle_cfi::read, alignCSCRings::s, scriptName_, mps_update::status, cond::impl::to_string(), and TablePrint::write.

Referenced by beginRunProduce().

                                                                                                    {
   // 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_pre = 0;
   // For generation command the first argument gives to the scriptName
   if (!isPost) {
     argc_pre = 1;
   }
   unsigned int argc = argc_pre + args.size();
   // TODO: assert that we have a reasonable number of arguments
   char** argv = new char*[argc + 1];
   if (!isPost) {
     argv[0] = strdup(scriptName_.c_str());
   }
   for (unsigned int i = 0; i < args.size(); i++) {
     argv[argc_pre + i] = strdup(args[i].c_str());
   }
   argv[argc] = nullptr;
 
   pid_t pid = fork();
   if (pid == 0) {
     // The child process
     if (!(rc = closeDescriptors(filedes[1]))) {
       if (!isPost && 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 << ".";
   }
 }

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

static

Definition at line 540 of file ExternalLHEProducer.cc.

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

                                                                                      {
   //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.");
   desc.addUntracked<std::vector<std::string>>("postGenerationCommand", std::vector<std::string>())
       ->setComment(
           "Command to run after the generation script has completed. The first argument can be a relative path.");
 
   edm::ParameterSetDescription nPartonMappingDesc;
   nPartonMappingDesc.add<unsigned>("idprup");
   nPartonMappingDesc.add<std::string>("order");
   nPartonMappingDesc.add<unsigned>("np");
   desc.addVPSetOptional("nPartonMapping", nPartonMappingDesc);
 
   descriptions.addDefault(desc);
 }

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

private

Definition at line 568 of file ExternalLHEProducer.cc.

References LHERunInfoProduct::addComment(), LHERunInfoProduct::addHeader(), mergeVDriftHistosByStation::file, LHERunInfoProduct::mergeProduct(), eostools::move(), DQM::reader, submitPVValidationJobs::runInfo, and createPayload::skip.

Referenced by beginRunProduce().

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

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

private

Definition at line 378 of file ExternalLHEProducer.cc.

References writedatasetfile::args, args_, filterCSVwithJSON::copy, LogDebug, and cond::impl::to_string().

Referenced by beginRunProduce().

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

void ExternalLHEProducer::nextEvent ( )

private

Definition at line 598 of file ExternalLHEProducer.cc.

References partonLevel_, and reader_.

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

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

void ExternalLHEProducer::preallocThreads ( unsigned int iThreads )

overrideprivatevirtual

Reimplemented from edm::one::EDProducerBase.

Definition at line 174 of file ExternalLHEProducer.cc.

References nThreads_.

174 { nThreads_ = iThreads; }

ExternalLHEProducer::nThreads_

unsigned int nThreads_

Definition: ExternalLHEProducer.cc:96

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

overrideprivatevirtual

Implements edm::one::EDProducerBase.

Definition at line 177 of file ExternalLHEProducer.cc.

References LHEEventProduct::addComment(), LHEEventProduct::addWeight(), edm::errors::EventGenerationFailure, eventPutToken_, Exception, eostools::move(), nextEvent(), np, nPartonMapping_, partonLevel_, and edm::Event::put().

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