#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::EndRunProducer >
	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::vector< ModuleDescription const * > &modules, 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	beginRunProduce (edm::Run &run, edm::EventSetup const &es) override

int	closeDescriptors (int preserve) const

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

void	executeScript (std::vector< std::string > const &args, int id) 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_

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::shared_ptr< lhef::LHERunInfo >	runInfo_

std::shared_ptr< lhef::LHERunInfo >	runInfoLast_

std::deque< std::unique_ptr< LHERunInfoProduct > >	runInfoProducts_

std::string	scriptName_

bool	storeXML_

bool	wasMerged

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 69 of file ExternalLHEProducer.cc.

Constructor & Destructor Documentation

◆ ExternalLHEProducer()

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

explicit

Definition at line 126 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));
     }
   }
  
   produces<LHEXMLStringProduct, edm::Transition::BeginRun>("LHEScriptOutput");
  
   produces<LHEEventProduct>();
   produces<LHERunInfoProduct, edm::Transition::BeginRun>();
   produces<LHERunInfoProduct, edm::Transition::EndRun>();
 }

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

Member Function Documentation

◆ beginRunProduce()

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

overrideprivate

Definition at line 255 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::empty_task* waitTask = new (tbb::task::allocate_root()) tbb::empty_task;
       waitTask->set_ref_count(1 + nThreads_);
  
       for (unsigned int t = 0; t < nThreads_; ++t) {
         uint32_t nEvents = nEventsAve;
         if (nEvents_ % nThreads_ != 0 and t >= overflow) {
           nEvents += 1;
         }
         auto task = edm::make_functor_task(tbb::task::allocate_root(),
                                            [t, this, &infiles, seed, nEvents, &except, &exceptSet, waitTask]() {
                                              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);
                                                }
                                              }
                                              waitTask->decrement_ref_count();
                                            });
         tbb::task::spawn(*task);
       }
       waitTask->wait_for_all();
       tbb::task::destroy(*waitTask);
     });
     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(std::move(p), "LHEScriptOutput");
  
   // 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();
   if (runInfoLast_) {
     runInfo_ = runInfoLast_;
  
     std::unique_ptr<LHERunInfoProduct> product(new LHERunInfoProduct(*runInfo_->getHEPRUP()));
     std::for_each(runInfo_->getHeaders().begin(),
                   runInfo_->getHeaders().end(),
                   std::bind(&LHERunInfoProduct::addHeader, product.get(), std::placeholders::_1));
     std::for_each(runInfo_->getComments().begin(),
                   runInfo_->getComments().end(),
                   std::bind(&LHERunInfoProduct::addComment, product.get(), std::placeholders::_1));
  
     // keep a copy around in case of merging
     runInfoProducts_.emplace_back(new LHERunInfoProduct(*product));
     wasMerged = false;
  
     run.put(std::move(product));
  
     runInfo_.reset();
   }
 }

References LHERunInfoProduct::addComment(), LHERunInfoProduct::addHeader(), CMS_SA_ALLOW, Exception, executeScript(), FrontierConditions_GlobalTag_cff::file, generateConcurrently_, edm::Service< T >::isAvailable(), lhe2HepMCConverter_cff::LHERunInfoProduct, edm::make_functor_task(), 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, runInfo_, runInfoLast_, runInfoProducts_, alignCSCRings::s, fileCollector::seed, optionsL1T::skip, storeXML_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, TrackValidation_cff::task, and wasMerged.

◆ closeDescriptors()

int ExternalLHEProducer::closeDescriptors ( int preserve ) const

private

Definition at line 426 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().

◆ endRunProduce()

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

overrideprivate

Definition at line 370 of file ExternalLHEProducer.cc.

                                                                             {
   if (!runInfoProducts_.empty()) {
     std::unique_ptr<LHERunInfoProduct> product(runInfoProducts_.front().release());
     runInfoProducts_.pop_front();
     run.put(std::move(product));
   }
  
   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_, eostools::move(), nextEvent(), nThreads_, MillePedeFileConverter_cfg::out, outputFile_, partonLevel_, castor_dqm_sourceclient_file_cfg::path, reader_, writedatasetfile::run, runInfoProducts_, alignCSCRings::s, and submitPVValidationJobs::t.

◆ executeScript()

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

private

Definition at line 463 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 559 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.

◆ makeArgs()

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

private

Definition at line 404 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 584 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_);
   }
   if (!partonLevel_)
     return;
  
   std::shared_ptr<lhef::LHERunInfo> runInfoThis = partonLevel_->getRunInfo();
   if (runInfoThis != runInfoLast_) {
     runInfo_ = runInfoThis;
     runInfoLast_ = runInfoThis;
   }
 }

References partonLevel_, reader_, runInfo_, and runInfoLast_.

Referenced by beginRunProduce(), endRunProduce(), 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(std::move(product));
  
   if (runInfo_) {
     std::unique_ptr<LHERunInfoProduct> product(new LHERunInfoProduct(*runInfo_->getHEPRUP()));
     std::for_each(runInfo_->getHeaders().begin(),
                   runInfo_->getHeaders().end(),
                   std::bind(&LHERunInfoProduct::addHeader, product.get(), std::placeholders::_1));
     std::for_each(runInfo_->getComments().begin(),
                   runInfo_->getComments().end(),
                   std::bind(&LHERunInfoProduct::addComment, product.get(), std::placeholders::_1));
  
     if (!runInfoProducts_.empty()) {
       runInfoProducts_.front()->mergeProduct(*product);
       if (!wasMerged) {
         runInfoProducts_.pop_front();
         runInfoProducts_.emplace_front(product.release());
         wasMerged = true;
       }
     }
  
     runInfo_.reset();
   }
  
   partonLevel_.reset();
   return;
 }

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

Member Data Documentation

◆ args_

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

private

Definition at line 90 of file ExternalLHEProducer.cc.

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

◆ generateConcurrently_

bool ExternalLHEProducer::generateConcurrently_ {false}

private

Definition at line 96 of file ExternalLHEProducer.cc.

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

◆ nEvents_

uint32_t ExternalLHEProducer::nEvents_

private

Definition at line 92 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce().

◆ npars_

uint32_t ExternalLHEProducer::npars_

private

Definition at line 91 of file ExternalLHEProducer.cc.

Referenced by ExternalLHEProducer().

◆ nPartonMapping_

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

private

Definition at line 99 of file ExternalLHEProducer.cc.

Referenced by ExternalLHEProducer(), and produce().

◆ nThreads_

unsigned int ExternalLHEProducer::nThreads_ {1}

private

Definition at line 94 of file ExternalLHEProducer.cc.

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

◆ outputContents_

std::string ExternalLHEProducer::outputContents_

private

Definition at line 95 of file ExternalLHEProducer.cc.

◆ outputFile_

std::string ExternalLHEProducer::outputFile_

private

Definition at line 89 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), and endRunProduce().

◆ partonLevel_

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

private

Definition at line 104 of file ExternalLHEProducer.cc.

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

◆ reader_

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

private

Definition at line 101 of file ExternalLHEProducer.cc.

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

◆ runInfo_

std::shared_ptr<lhef::LHERunInfo> ExternalLHEProducer::runInfo_

private

Definition at line 103 of file ExternalLHEProducer.cc.

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

◆ runInfoLast_

std::shared_ptr<lhef::LHERunInfo> ExternalLHEProducer::runInfoLast_

private

Definition at line 102 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), and nextEvent().

◆ runInfoProducts_

std::deque<std::unique_ptr<LHERunInfoProduct> > ExternalLHEProducer::runInfoProducts_

private

Definition at line 105 of file ExternalLHEProducer.cc.

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

◆ scriptName_

std::string ExternalLHEProducer::scriptName_

private

Definition at line 88 of file ExternalLHEProducer.cc.

Referenced by executeScript().

◆ storeXML_

bool ExternalLHEProducer::storeXML_

private

Definition at line 93 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce().

◆ wasMerged

bool ExternalLHEProducer::wasMerged

private

Definition at line 106 of file ExternalLHEProducer.cc.

Referenced by beginRunProduce(), and produce().

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

◆ beginRunProduce()

◆ closeDescriptors()

◆ endRunProduce()

◆ executeScript()

◆ fillDescriptions()

◆ makeArgs()

◆ nextEvent()

◆ preallocThreads()

◆ produce()

Member Data Documentation

◆ args_

◆ generateConcurrently_

◆ nEvents_

◆ npars_

◆ nPartonMapping_

◆ nThreads_

◆ outputContents_

◆ outputFile_

◆ partonLevel_

◆ reader_

◆ runInfo_

◆ runInfoLast_

◆ runInfoProducts_

◆ scriptName_

◆ storeXML_

◆ wasMerged