Inheritance diagram for GenWeightsTableProducer:

Public Member Functions
std::unique_ptr< Counter >	beginStream (edm::StreamID) const override

void	fillLHEWeightTables (Counter counter, const DynamicWeightChoice weightChoice, double genWeight, const LHEEventProduct &lheProd, std::unique_ptr< nanoaod::FlatTable > &outScale, std::unique_ptr< nanoaod::FlatTable > &outPdf, std::unique_ptr< nanoaod::FlatTable > &outNamed) const

	GenWeightsTableProducer (edm::ParameterSet const &params)

std::shared_ptr< DynamicWeightChoice >	globalBeginRun (edm::Run const &iRun, edm::EventSetup const &) const override

std::shared_ptr< Counter >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &) const override

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

void	globalEndRunProduce (edm::Run &iRun, edm::EventSetup const &, Counter const *runCounter) const override

void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, Counter *runCounter) const override

void	produce (edm::StreamID id, edm::Event &iEvent, const edm::EventSetup &iSetup) const override

void	streamBeginRun (edm::StreamID id, edm::Run const &, edm::EventSetup const &) const override

void	streamEndRunSummary (edm::StreamID id, edm::Run const &, edm::EventSetup const &, Counter *runCounter) const override

	~GenWeightsTableProducer () override

Public Member Functions inherited from edm::global::EDProducer< edm::StreamCache< Counter >, edm::RunCache< DynamicWeightChoice >, edm::RunSummaryCache< Counter >, edm::EndRunProducer >
	EDProducer ()=default

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

ModuleDescription const &	moduleDescription () 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)

virtual	~ProducerBase () noexcept(false)

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Attributes
std::atomic< bool >	debug_

std::atomic< bool >	debugRun_

const edm::EDGetTokenT< GenEventInfoProduct >	genTag_

std::atomic< bool >	hasIssuedWarning_

std::unordered_map< std::string, uint32_t >	lhaNameToID_

const edm::InputTag	lheLabel_

const edm::EDGetTokenT< LHERunInfoProduct >	lheRunTag_

const edm::EDGetTokenT< LHEEventProduct >	lheTag_

int	lheWeightPrecision_

unsigned int	maxPdfWeights_

std::vector< std::string >	namedWeightIDs_

std::vector< std::string >	namedWeightLabels_

std::vector< uint32_t >	preferredPDFLHAIDs_

Additional Inherited Members
Public Types inherited from edm::global::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::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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 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)

Detailed Description

Definition at line 119 of file GenWeightsTableProducer.cc.

Constructor & Destructor Documentation

GenWeightsTableProducer::GenWeightsTableProducer ( edm::ParameterSet const & params )

inline

Definition at line 121 of file GenWeightsTableProducer.cc.

References Exception, edm::ParameterSet::getParameter(), nano_cff::lhaid, dataset::name, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                   :
             genTag_(consumes<GenEventInfoProduct>(params.getParameter<edm::InputTag>("genEvent"))),
             lheLabel_(params.getParameter<edm::InputTag>("lheInfo")),
             lheTag_(consumes<LHEEventProduct>(lheLabel_)),
             lheRunTag_(consumes<LHERunInfoProduct, edm::InRun>(lheLabel_)),
             namedWeightIDs_(params.getParameter<std::vector<std::string>>("namedWeightIDs")),
             namedWeightLabels_(params.getParameter<std::vector<std::string>>("namedWeightLabels")),
             lheWeightPrecision_(params.getParameter<int32_t>("lheWeightPrecision")),
             maxPdfWeights_(params.getParameter<uint32_t>("maxPdfWeights")),
             debug_(params.getUntrackedParameter<bool>("debug",false)), debugRun_(debug_.load()),
             hasIssuedWarning_(false)
         {
             produces<nanoaod::FlatTable>();
             produces<nanoaod::FlatTable>("LHEScale");
             produces<nanoaod::FlatTable>("LHEPdf");
             produces<nanoaod::FlatTable>("LHENamed");
             produces<nanoaod::MergeableCounterTable,edm::Transition::EndRun>();
             if (namedWeightIDs_.size() != namedWeightLabels_.size()) {
                 throw cms::Exception("Configuration", "Size mismatch between namedWeightIDs & namedWeightLabels");
             }
             for (const edm::ParameterSet & pdfps : params.getParameter<std::vector<edm::ParameterSet>>("preferredPDFs")) {
                 const std::string & name = pdfps.getParameter<std::string>("name");
                 uint32_t lhaid = pdfps.getParameter<uint32_t>("lhaid");
                 preferredPDFLHAIDs_.push_back(lhaid);
                 lhaNameToID_[name] = lhaid;
                 lhaNameToID_[name+".LHgrid"] = lhaid;
             }
         }

GenWeightsTableProducer::~GenWeightsTableProducer ( )

inlineoverride

Definition at line 150 of file GenWeightsTableProducer.cc.

150 {}

Member Function Documentation

std::unique_ptr<Counter> GenWeightsTableProducer::beginStream ( edm::StreamID ) const

inlineoverride

Definition at line 414 of file GenWeightsTableProducer.cc.

                                                                        { 
             return std::make_unique<Counter>(); 
         }

static void GenWeightsTableProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

inlinestatic

Definition at line 454 of file GenWeightsTableProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addVPSet(), edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   {
             edm::ParameterSetDescription desc;
             desc.add<edm::InputTag>("genEvent", edm::InputTag("generator"))->setComment("tag for the GenEventInfoProduct, to get the main weight");
             desc.add<edm::InputTag>("lheInfo", edm::InputTag("externalLHEProducer"))->setComment("tag for the LHE information (LHEEventProduct and LHERunInfoProduct)");
 
             edm::ParameterSetDescription prefpdf;
             prefpdf.add<std::string>("name");
             prefpdf.add<uint32_t>("lhaid");
             desc.addVPSet("preferredPDFs", prefpdf, std::vector<edm::ParameterSet>())->setComment("LHA PDF Ids of the preferred PDF sets, in order of preference (the first matching one will be used)");
             desc.add<std::vector<std::string>>("namedWeightIDs")->setComment("set of LHA weight IDs for named LHE weights");
             desc.add<std::vector<std::string>>("namedWeightLabels")->setComment("output names for the namedWeightIDs (in the same order)");
             desc.add<int32_t>("lheWeightPrecision")->setComment("Number of bits in the mantissa for LHE weights");
             desc.add<uint32_t>("maxPdfWeights")->setComment("Maximum number of PDF weights to save (to crop NN replicas)");
             desc.addOptionalUntracked<bool>("debug")->setComment("dump out all LHE information for one event");
             descriptions.add("genWeightsTable", desc);
         }

void GenWeightsTableProducer::fillLHEWeightTables	(	Counter *	counter,
		const DynamicWeightChoice *	weightChoice,
		double	genWeight,
		const LHEEventProduct &	lheProd,
		std::unique_ptr< nanoaod::FlatTable > &	outScale,
		std::unique_ptr< nanoaod::FlatTable > &	outPdf,
		std::unique_ptr< nanoaod::FlatTable > &	outNamed
	)		const

inline

Definition at line 193 of file GenWeightsTableProducer.cc.

References spr::find(), nanoaod::FlatTable::FloatColumn, mps_fire::i, gen::n, LHEEventProduct::originalXWGTUP(), and LHEEventProduct::weights().

         {
             bool lheDebug = debug_.exchange(false); // make sure only the first thread dumps out this (even if may still be mixed up with other output, but nevermind)
 
             const std::vector<std::string> & scaleWeightIDs = weightChoice->scaleWeightIDs;
             const std::vector<std::string> & pdfWeightIDs   = weightChoice->pdfWeightIDs;
 
             double w0 = lheProd.originalXWGTUP();
 
             std::vector<double> wScale(scaleWeightIDs.size(), 1), wPDF(pdfWeightIDs.size(), 1), wNamed(namedWeightIDs_.size(), 1);
             for (auto & weight : lheProd.weights()) {
                 if (lheDebug) printf("Weight  %+9.5f   rel %+9.5f   for id %s\n", weight.wgt, weight.wgt/w0,  weight.id.c_str());
                 // now we do it slowly, can be optimized
                 auto mScale = std::find(scaleWeightIDs.begin(), scaleWeightIDs.end(), weight.id);
                 if (mScale != scaleWeightIDs.end()) wScale[mScale-scaleWeightIDs.begin()] = weight.wgt/w0;
 
                 auto mPDF = std::find(pdfWeightIDs.begin(), pdfWeightIDs.end(), weight.id);
                 if (mPDF != pdfWeightIDs.end()) wPDF[mPDF-pdfWeightIDs.begin()] = weight.wgt/w0;
 
                 auto mNamed = std::find(namedWeightIDs_.begin(), namedWeightIDs_.end(), weight.id);
                 if (mNamed != namedWeightIDs_.end()) wNamed[mNamed-namedWeightIDs_.begin()] = weight.wgt/w0;
             } 
 
             outScale.reset(new nanoaod::FlatTable(wScale.size(), "LHEScaleWeight", false));
             outScale->addColumn<float>("", wScale, weightChoice->scaleWeightsDoc, nanoaod::FlatTable::FloatColumn, lheWeightPrecision_); 
 
             outPdf.reset(new nanoaod::FlatTable(wPDF.size(), "LHEPdfWeight", false));
             outPdf->addColumn<float>("", wPDF, weightChoice->pdfWeightsDoc, nanoaod::FlatTable::FloatColumn, lheWeightPrecision_); 
 
             outNamed.reset(new nanoaod::FlatTable(1, "LHEWeight", true));
             outNamed->addColumnValue<float>("originalXWGTUP", lheProd.originalXWGTUP(), "Nominal event weight in the LHE file", nanoaod::FlatTable::FloatColumn);
             for (unsigned int i = 0, n = wNamed.size(); i < n; ++i) {
                 outNamed->addColumnValue<float>(namedWeightLabels_[i], wNamed[i], "LHE weight for id "+namedWeightIDs_[i]+", relative to nominal", nanoaod::FlatTable::FloatColumn, lheWeightPrecision_);
             }
             
             counter->incLHE(genWeight, wScale, wPDF, wNamed);
         }

std::shared_ptr<DynamicWeightChoice> GenWeightsTableProducer::globalBeginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &
	)		const

inlineoverride

Definition at line 239 of file GenWeightsTableProducer.cc.

References gather_cfg::cout, end, plotBeamSpotDB::first, runEdmFileComparison::found, edm::Run::getByLabel(), LHERunInfoProduct::headers_begin(), LHERunInfoProduct::headers_end(), triggerObjects_cff::id, nano_cff::lhaid, nano_cff::lheInfo, groupFilesInBlocks::lines, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                    {
             edm::Handle<LHERunInfoProduct> lheInfo;
 
             bool lheDebug = debugRun_.exchange(false); // make sure only the first thread dumps out this (even if may still be mixed up with other output, but nevermind)
             auto weightChoice = std::make_shared<DynamicWeightChoice>();
 
             // getByToken throws since we're not in the endRun (see https://github.com/cms-sw/cmssw/pull/18499)
             //if (iRun.getByToken(lheRunTag_, lheInfo)) {
             if (iRun.getByLabel(lheLabel_, lheInfo)) { 
                 std::vector<ScaleVarWeight> scaleVariationIDs;
                 std::vector<PDFSetWeights>  pdfSetWeightIDs;
                 
                 std::regex weightgroup("<weightgroup\\s+combine=\"(.*)\"\\s+(?:name|type)=\"(.*)\"\\s*>");
                 std::regex endweightgroup("</weightgroup>");
                 std::regex scalew("<weight\\s+(?:.*\\s+)?id=\"(\\d+)\">\\s*(?:lhapdf=\\d+|dyn=\\s*-?\\d+)?\\s*((?:mu[rR]|renscfact)=(\\S+)\\s+(?:mu[Ff]|facscfact)=(\\S+)(\\s+.*)?)</weight>");
                 std::regex pdfw("<weight\\s+id=\"(\\d+)\">\\s*(?:PDF set|lhapdf|PDF|pdfset)\\s*=\\s*(\\d+)\\s*(?:\\s.*)?</weight>");
                 std::regex pdfwOld("<weight\\s+(?:.*\\s+)?id=\"(\\d+)\">\\s*Member \\s*(\\d+)\\s*(?:.*)</weight>");
                 std::smatch groups;
                 for (auto iter=lheInfo->headers_begin(), end = lheInfo->headers_end(); iter != end; ++iter) {
                     if (iter->tag() != "initrwgt") {
                         if (lheDebug) std::cout << "Skipping LHE header with tag" << iter->tag() << std::endl;
                         continue;
                     }
                     if (lheDebug) std::cout << "Found LHE header with tag" << iter->tag() << std::endl;
                     const std::vector<std::string> & lines = iter->lines();
                     for (unsigned int iLine = 0, nLines = lines.size(); iLine < nLines; ++iLine) {
                         if (lheDebug) std::cout << lines[iLine];
                         if (std::regex_search(lines[iLine], groups, weightgroup)) {
                             std::string groupname = groups.str(2);
                             if (lheDebug) std::cout << ">>> Looks like the beginning of a weight group for '" << groupname << "'" << std::endl;
                             if (groupname.find("scale_variation") == 0 || groupname == "Central scale variation") {
                                 if (lheDebug) std::cout << ">>> Looks like scale variation for theory uncertainties" << std::endl;
                                 for ( ++iLine; iLine < nLines; ++iLine) {
                                     if (lheDebug) std::cout << "    " << lines[iLine];
                                     if (std::regex_search(lines[iLine], groups, scalew)) {
                                         if (lheDebug) std::cout << "    >>> Scale weight " << groups[1].str() << " for " << groups[3].str() << " , " << groups[4].str() << " , " << groups[5].str() << std::endl;
                                         scaleVariationIDs.emplace_back(groups.str(1), groups.str(2), groups.str(3), groups.str(4));
                                     } else if (std::regex_search(lines[iLine], endweightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the end of a weight group" << std::endl;
                                         break;
                                     } else if (std::regex_search(lines[iLine], weightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the beginning of a new weight group, I will assume I missed the end of the group." << std::endl;
                                         --iLine; // rewind by one, and go back to the outer loop
                                         break;
                                     }
                                 }
                             } else if (groupname == "PDF_variation" || groupname.find("PDF_variation ") == 0) {
                                 if (lheDebug) std::cout << ">>> Looks like a new-style block of PDF weights for one or more pdfs" << std::endl;
                                 for ( ++iLine; iLine < nLines; ++iLine) {
                                     if (lheDebug) std::cout << "    " << lines[iLine];
                                     if (std::regex_search(lines[iLine], groups, pdfw)) {
                                         unsigned int lhaID = std::stoi(groups.str(2));
                                         if (lheDebug) std::cout << "    >>> PDF weight " << groups.str(1) << " for " << groups.str(2) << " = " << lhaID << std::endl;
                                         if (pdfSetWeightIDs.empty() || ! pdfSetWeightIDs.back().maybe_add(groups.str(1),lhaID)) {
                                             pdfSetWeightIDs.emplace_back(groups.str(1),lhaID);
                                         }
                                     } else if (std::regex_search(lines[iLine], endweightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the end of a weight group" << std::endl;
                                         break;
                                     } else if (std::regex_search(lines[iLine], weightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the beginning of a new weight group, I will assume I missed the end of the group." << std::endl;
                                         --iLine; // rewind by one, and go back to the outer loop
                                         break;
                                     }
                                 }
                             } else if (groupname == "PDF_variation1" || groupname == "PDF_variation2") { 
                                 if (lheDebug) std::cout << ">>> Looks like a new-style block of PDF weights for multiple pdfs" << std::endl;
                                 unsigned int lastid = 0;
                                 for ( ++iLine; iLine < nLines; ++iLine) {
                                     if (lheDebug) std::cout << "    " << lines[iLine];
                                     if (std::regex_search(lines[iLine], groups, pdfw)) {
                                         unsigned int id = std::stoi(groups.str(1));
                                         unsigned int lhaID = std::stoi(groups.str(2));
                                         if (lheDebug) std::cout << "    >>> PDF weight " << groups.str(1) << " for " << groups.str(2) << " = " << lhaID << std::endl;
                                         if (id != (lastid+1) || pdfSetWeightIDs.empty()) {
                                             pdfSetWeightIDs.emplace_back(groups.str(1),lhaID);
                                         } else {
                                             pdfSetWeightIDs.back().add(groups.str(1),lhaID);
                                         }
                                         lastid = id;
                                     } else if (std::regex_search(lines[iLine], endweightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the end of a weight group" << std::endl;
                                         break;
                                     } else if (std::regex_search(lines[iLine], weightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the beginning of a new weight group, I will assume I missed the end of the group." << std::endl;
                                         --iLine; // rewind by one, and go back to the outer loop
                                         break;
                                     }
                                 }
                             } else if (lhaNameToID_.find(groupname) != lhaNameToID_.end()) {
                                 if (lheDebug) std::cout << ">>> Looks like an old-style PDF weight for an individual pdf" << std::endl;
                                 unsigned int firstLhaID = lhaNameToID_.find(groupname)->second;
                                 bool first = true;
                                 for ( ++iLine; iLine < nLines; ++iLine) {
                                     if (lheDebug) std::cout << "    " << lines[iLine];
                                     if (std::regex_search(lines[iLine], groups, pdfwOld)) {
                                         unsigned int member = std::stoi(groups.str(2));
                                         unsigned int lhaID = member+firstLhaID;
                                         if (lheDebug) std::cout << "    >>> PDF weight " << groups.str(1) << " for " << groups.str(2) << " = " << lhaID << std::endl;
                                         //if (member == 0) continue; // let's keep also the central value for now
                                         if (first) {
                                             pdfSetWeightIDs.emplace_back(groups.str(1),lhaID);
                                             first = false;
                                         } else {
                                             pdfSetWeightIDs.back().add(groups.str(1),lhaID);
                                         }
                                     } else if (std::regex_search(lines[iLine], endweightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the end of a weight group" << std::endl;
                                         break;
                                     } else if (std::regex_search(lines[iLine], weightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the beginning of a new weight group, I will assume I missed the end of the group." << std::endl;
                                         --iLine; // rewind by one, and go back to the outer loop
                                         break;
                                     }
                                 }
                             } else {
                                 for ( ++iLine; iLine < nLines; ++iLine) {
                                     if (lheDebug) std::cout << "    " << lines[iLine];
                                     if (std::regex_search(lines[iLine], groups, endweightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the end of a weight group" << std::endl;
                                         break;
                                     } else if (std::regex_search(lines[iLine], weightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the beginning of a new weight group, I will assume I missed the end of the group." << std::endl;
                                         --iLine; // rewind by one, and go back to the outer loop
                                         break;
                                     }
                                 }
                             }
                         }
                     }
                     //std::cout << "============= END [ " << iter->tag() << " ] ============ \n\n" << std::endl;
 
                     // ----- SCALE VARIATIONS -----
                     std::sort(scaleVariationIDs.begin(), scaleVariationIDs.end());
                     if (lheDebug) std::cout << "Found " << scaleVariationIDs.size() << " scale variations: " << std::endl;
                     std::stringstream scaleDoc; scaleDoc << "LHE scale variation weights (w_var / w_nominal); ";
                     for (unsigned int isw = 0, nsw = scaleVariationIDs.size(); isw < nsw; ++isw) {
                         const auto & sw = scaleVariationIDs[isw];
                         if (isw) scaleDoc << "; ";
                         scaleDoc << "[" << isw << "] is " << sw.label;
                         weightChoice->scaleWeightIDs.push_back(sw.wid);
                         if (lheDebug) printf("    id %s: scales ren = % .2f  fact = % .2f  text = %s\n", sw.wid.c_str(), sw.scales.first, sw.scales.second, sw.label.c_str());
                     }
                     if (!scaleVariationIDs.empty()) weightChoice->scaleWeightsDoc = scaleDoc.str();
 
                     // ------ PDF VARIATIONS (take the preferred one) -----
                     if (lheDebug) {
                         std::cout << "Found " << pdfSetWeightIDs.size() << " PDF set errors: " << std::endl;
                         for (const auto & pw : pdfSetWeightIDs) printf("lhaIDs %6d - %6d (%3lu weights: %s, ... )\n", pw.lhaIDs.first, pw.lhaIDs.second, pw.wids.size(), pw.wids.front().c_str());
                     }
                     
                     std::stringstream pdfDoc; pdfDoc << "LHE pdf variation weights (w_var / w_nominal) for LHA IDs ";
                     bool found = false;
                     for (uint32_t lhaid : preferredPDFLHAIDs_) {
                         for (const auto & pw : pdfSetWeightIDs) {
                             if (pw.lhaIDs.first != lhaid && pw.lhaIDs.first != (lhaid+1)) continue; // sometimes the first weight is not saved if that PDF is the nominal one for the sample
                             if (pw.wids.size() == 1) continue; // only consider error sets
                             pdfDoc << pw.lhaIDs.first << " - " << pw.lhaIDs.second;
                             weightChoice->pdfWeightIDs = pw.wids;
                             if (maxPdfWeights_ < pw.wids.size()) {
                                 weightChoice->pdfWeightIDs.resize(maxPdfWeights_); // drop some replicas
                                 pdfDoc << ", truncated to the first " << maxPdfWeights_ << " replicas";
                             } 
                             weightChoice->pdfWeightsDoc = pdfDoc.str(); 
                             found = true; break;
                         }
                         if (found) break;
                     }
                 }
             }
             return weightChoice; 
         }

std::shared_ptr<Counter> GenWeightsTableProducer::globalBeginRunSummary	(	edm::Run const &	,
		edm::EventSetup const &
	)		const

inlineoverride

Definition at line 422 of file GenWeightsTableProducer.cc.

                                                                                                          { 
             return std::make_shared<Counter>(); 
         }

void GenWeightsTableProducer::globalEndRun	(	edm::Run const &	,
		edm::EventSetup const &
	)		const

inlineoverride

Definition at line 452 of file GenWeightsTableProducer.cc.

452 { }

void GenWeightsTableProducer::globalEndRunProduce	(	edm::Run &	iRun,
		edm::EventSetup const &	,
		Counter const *	runCounter
	)		const

inlineoverride

Definition at line 433 of file GenWeightsTableProducer.cc.

References mps_fire::i, eostools::move(), gen::n, MillePedeFileConverter_cfg::out, edm::Run::put(), and heppy_batch::val.

                                                                                                                {
             auto out = std::make_unique<nanoaod::MergeableCounterTable>();
             out->addInt("genEventCount", "event count", runCounter->num);
             out->addFloat("genEventSumw", "sum of gen weights", runCounter->sumw);
             out->addFloat("genEventSumw2", "sum of gen (weight^2)", runCounter->sumw2);
 
             double norm = runCounter->sumw ? 1.0/runCounter->sumw : 1;
             auto sumScales = runCounter->sumScale; for (auto & val : sumScales) val *= norm;
             out->addVFloat("LHEScaleSumw", "Sum of genEventWeight * LHEScaleWeight[i], divided by genEventSumw", sumScales);
             auto sumPDFs = runCounter->sumPDF; for (auto & val : sumPDFs) val *= norm;
             out->addVFloat("LHEPdfSumw", "Sum of genEventWeight * LHEPdfWeight[i], divided by genEventSumw", sumPDFs);
             if (!runCounter->sumNamed.empty()) { // it could be empty if there's no LHE info in the sample
                 for (unsigned int i = 0, n = namedWeightLabels_.size(); i < n; ++i) {
                     out->addFloat("LHESumw_"+namedWeightLabels_[i], "Sum of genEventWeight * LHEWeight_"+namedWeightLabels_[i]+", divided by genEventSumw", runCounter->sumNamed[i] * norm);
                 }
             }
             iRun.put(std::move(out));
         }

void GenWeightsTableProducer::globalEndRunSummary	(	edm::Run const &	,
		edm::EventSetup const &	,
		Counter *	runCounter
	)		const

inlineoverride

Definition at line 430 of file GenWeightsTableProducer.cc.

430 {

431 }

void GenWeightsTableProducer::produce	(	edm::StreamID	id,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

inlineoverride

Definition at line 152 of file GenWeightsTableProducer.cc.

References nanoaod::FlatTable::FloatColumn, edm::Event::getByToken(), edm::Event::getRun(), edm::Run::index(), nano_cff::lheInfo, eostools::move(), MillePedeFileConverter_cfg::out, edm::Event::put(), GenEventInfoProduct::weight(), and mps_merge::weight.

                                                                                                    {
             // get my counter for weights
             Counter * counter = streamCache(id);
 
             // generator information (always available)
             edm::Handle<GenEventInfoProduct> genInfo;
             iEvent.getByToken(genTag_, genInfo);
             double weight = genInfo->weight();
             
             // table for gen info, always available
             auto out = std::make_unique<nanoaod::FlatTable>(1, "genWeight", true);
             out->setDoc("generator weight");
             out->addColumnValue<float>("", weight, "generator weight", nanoaod::FlatTable::FloatColumn);
             iEvent.put(std::move(out));
 
             // tables for LHE weights, may not be filled
             std::unique_ptr<nanoaod::FlatTable> lheScaleTab, lhePdfTab, lheNamedTab;
 
             edm::Handle<LHEEventProduct> lheInfo;
             if (iEvent.getByToken(lheTag_, lheInfo)) {
                 // get the dynamic choice of weights
                 const DynamicWeightChoice * weightChoice = runCache(iEvent.getRun().index());
                 // go fill tables
                 fillLHEWeightTables(counter, weightChoice, weight, *lheInfo, lheScaleTab, lhePdfTab, lheNamedTab); 
             } else {
                 // minimal book-keeping of weights
                 counter->incGenOnly(weight);
                 // make dummy values 
                 lheScaleTab.reset(new nanoaod::FlatTable(1, "LHEScaleWeights", true));
                 lhePdfTab.reset(new nanoaod::FlatTable(1, "LHEPdfWeights", true));
                 lheNamedTab.reset(new nanoaod::FlatTable(1, "LHENamedWeights", true));
                 if (!hasIssuedWarning_.exchange(true)) {
                     edm::LogWarning("LHETablesProducer") << "No LHEEventProduct, so there will be no LHE Tables\n";
                 }
             }
 
             iEvent.put(std::move(lheScaleTab), "LHEScale");
             iEvent.put(std::move(lhePdfTab), "LHEPdf");
             iEvent.put(std::move(lheNamedTab), "LHENamed");
         }

void GenWeightsTableProducer::streamBeginRun	(	edm::StreamID	id,
		edm::Run const &	,
		edm::EventSetup const &
	)		const

inlineoverride

Definition at line 418 of file GenWeightsTableProducer.cc.

                                                                                                 { 
             streamCache(id)->clear(); 
         }

void GenWeightsTableProducer::streamEndRunSummary	(	edm::StreamID	id,
		edm::Run const &	,
		edm::EventSetup const &	,
		Counter *	runCounter
	)		const

inlineoverride

Definition at line 426 of file GenWeightsTableProducer.cc.

                                                                                                                           { 
             runCounter->merge(*streamCache(id)); 
         }