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, const GenEventInfoProduct &genProd, std::unique_ptr< nanoaod::FlatTable > &outScale, std::unique_ptr< nanoaod::FlatTable > &outPdf, std::unique_ptr< nanoaod::FlatTable > &outRwgt, std::unique_ptr< nanoaod::FlatTable > &outNamed, std::unique_ptr< nanoaod::FlatTable > &outPS) const

void	fillOnlyPSWeightTable (Counter *counter, double genWeight, const GenEventInfoProduct &genProd, std::unique_ptr< nanoaod::FlatTable > &outPS) 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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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)

	~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

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

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::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 std::vector< edm::InputTag >	lheLabel_

const std::vector< edm::EDGetTokenT< LHERunInfoProduct > >	lheRunTag_

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

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

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 141 of file GenWeightsTableProducer.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 143 of file GenWeightsTableProducer.cc.

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

                                                                   :
             genTag_(consumes<GenEventInfoProduct>(params.getParameter<edm::InputTag>("genEvent"))),
             lheLabel_(params.getParameter<std::vector<edm::InputTag>>("lheInfo")),
             lheTag_(edm::vector_transform(lheLabel_, [this](const edm::InputTag & tag) { return mayConsume<LHEEventProduct>(tag); })),
             lheRunTag_(edm::vector_transform(lheLabel_, [this](const edm::InputTag & tag) { return mayConsume<LHERunInfoProduct, edm::InRun>(tag); })),
             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>("LHEReweighting");
             produces<nanoaod::FlatTable>("LHENamed");
             produces<nanoaod::FlatTable>("PS");
             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 174 of file GenWeightsTableProducer.cc.

174 {}

Member Function Documentation

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

inlineoverride

Definition at line 568 of file GenWeightsTableProducer.cc.

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

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

inlinestatic

Definition at line 612 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<std::vector<edm::InputTag>>("lheInfo", std::vector<edm::InputTag>{{"externalLHEProducer"},{"source"}})->setComment("tag(s) 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,
		const GenEventInfoProduct &	genProd,
		std::unique_ptr< nanoaod::FlatTable > &	outScale,
		std::unique_ptr< nanoaod::FlatTable > &	outPdf,
		std::unique_ptr< nanoaod::FlatTable > &	outRwgt,
		std::unique_ptr< nanoaod::FlatTable > &	outNamed,
		std::unique_ptr< nanoaod::FlatTable > &	outPS
	)		const

inline

Definition at line 227 of file GenWeightsTableProducer.cc.

References spr::find(), nanoaod::FlatTable::FloatColumn, mps_fire::i, gen::n, LHEEventProduct::originalXWGTUP(), GenEventInfoProduct::weights(), 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;
             const std::vector<std::string> & rwgtWeightIDs  = weightChoice->rwgtIDs;
 
             double w0 = lheProd.originalXWGTUP();
 
             std::vector<double> wScale(scaleWeightIDs.size(), 1), wPDF(pdfWeightIDs.size(), 1), wRwgt(rwgtWeightIDs.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 mRwgt = std::find(rwgtWeightIDs.begin(), rwgtWeightIDs.end(), weight.id);
                 if (mRwgt != rwgtWeightIDs.end()) wRwgt[mRwgt-rwgtWeightIDs.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;
             } 
 
             int vectorSize = (genProd.weights().size() == 14 || genProd.weights().size() == 46) ? 4 : 1;
             std::vector<double> wPS(vectorSize, 1);
             if (vectorSize > 1 ) {
                 for (unsigned int i=6; i<10; i++){
                     wPS[i-6] = (genProd.weights()[i])/w0;
                 }
             }
             outPS.reset(new nanoaod::FlatTable(wPS.size(), "PSWeight", false));
             outPS->addColumn<float>("", wPS, vectorSize > 1 ? "PS weights (w_var / w_nominal); [0] is ISR=0.5 FSR=1; [1] is ISR=1 FSR=0.5; [2] is ISR=2 FSR=1; [3] is ISR=1 FSR=2 " : "dummy PS weight (1.0) ", nanoaod::FlatTable::FloatColumn, lheWeightPrecision_);
 
             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_);
 
             outRwgt.reset(new nanoaod::FlatTable(wRwgt.size(), "LHEReweightingWeight", false));
             outRwgt->addColumn<float>("", wRwgt, weightChoice->rwgtWeightDoc, 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, wRwgt, wNamed, wPS);
         }

void GenWeightsTableProducer::fillOnlyPSWeightTable	(	Counter *	counter,
		double	genWeight,
		const GenEventInfoProduct &	genProd,
		std::unique_ptr< nanoaod::FlatTable > &	outPS
	)		const

inline

Definition at line 292 of file GenWeightsTableProducer.cc.

References nanoaod::FlatTable::FloatColumn, mps_fire::i, and GenEventInfoProduct::weights().

         {
             int vectorSize = (genProd.weights().size() == 14 || genProd.weights().size() == 46) ? 4 : 1;
 
             std::vector<double> wPS(vectorSize, 1);
             if (vectorSize > 1 ){
                 for (unsigned int i=6; i<10; i++){
                     wPS[i-6] = (genProd.weights()[i])/genWeight;
                 }
             }
 
             outPS.reset(new nanoaod::FlatTable(wPS.size(), "PSWeight", false));
             outPS->addColumn<float>("", wPS, vectorSize > 1 ? "PS weights (w_var / w_nominal); [0] is ISR=0.5 FSR=1; [1] is ISR=1 FSR=0.5; [2] is ISR=2 FSR=1; [3] is ISR=1 FSR=2 " : "dummy PS weight (1.0) " , nanoaod::FlatTable::FloatColumn, lheWeightPrecision_);
 
             counter->incGenOnly(genWeight);
             counter->incPSOnly(genWeight,wPS);
         }

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

inlineoverride

Definition at line 317 of file GenWeightsTableProducer.cc.

References popcon2dropbox::copy(), gather_cfg::cout, end, spr::find(), plotBeamSpotDB::first, runEdmFileComparison::found, edm::Run::getByLabel(), LHERunInfoProduct::headers_begin(), LHERunInfoProduct::headers_end(), triggerObjects_cff::id, edm::HandleBase::isValid(), 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)) {
             for (const auto & lheLabel: lheLabel_) {
                 iRun.getByLabel(lheLabel, lheInfo);
                 if (lheInfo.isValid()) {
                     break;
                 }
             }
             if (lheInfo.isValid()) {
                 std::vector<ScaleVarWeight> scaleVariationIDs;
                 std::vector<PDFSetWeights>  pdfSetWeightIDs;
                 std::vector<std::string>    lheReweighingIDs;
                 
                 std::regex weightgroupmg26x("<weightgroup\\s+(?:name|type)=\"(.*)\"\\s+combine=\"(.*)\"\\s*>");
                 std::regex weightgroup("<weightgroup\\s+combine=\"(.*)\"\\s+(?:name|type)=\"(.*)\"\\s*>");
                 std::regex weightgroupRwgt("<weightgroup\\s+(?:name|type)=\"(.*)\"\\s*>");
                 std::regex endweightgroup("</weightgroup>");
                 std::regex scalewmg26x("<weight\\s+(?:.*\\s+)?id=\"(\\d+)\"\\s*(?:lhapdf=\\d+|dyn=\\s*-?\\d+)?\\s*((?:[mM][uU][rR]|renscfact)=\"(\\S+)\"\\s+(?:[mM][uU][Ff]|facscfact)=\"(\\S+)\")(\\s+.*)?</weight>");
                 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::regex pdfwmg26x("<weight\\s+id=\"(\\d+)\"\\s*MUR=\"(?:\\S+)\"\\s*MUF=\"(?:\\S+)\"\\s*(?:PDF set|lhapdf|PDF|pdfset)\\s*=\\s*\"(\\d+)\"\\s*>\\s*(?:PDF=(\\d+)\\s*MemberID=(\\d+))?\\s*(?:\\s.*)?</weight>");
                 std::regex rwgt("<weight\\s+id=\"(.+)\">(.+)?(</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;
                     std::vector<std::string>  lines = iter->lines();
                     bool missed_weightgroup=false; //Needed because in some of the samples ( produced with MG26X ) a small part of the header info is ordered incorrectly
                     bool ismg26x=false;
                     for (unsigned int iLine = 0, nLines = lines.size(); iLine < nLines; ++iLine) { //First start looping through the lines to see which weightgroup pattern is matched
                         boost::replace_all(lines[iLine],"&lt;", "<");
                         boost::replace_all(lines[iLine],"&gt;", ">");
                         if(std::regex_search(lines[iLine],groups,weightgroupmg26x)){
                             ismg26x=true;
                         }
                     }
                     for (unsigned int iLine = 0, nLines = lines.size(); iLine < nLines; ++iLine) {
                         if (lheDebug) std::cout << lines[iLine];
                         if (std::regex_search(lines[iLine], groups, ismg26x ? weightgroupmg26x : weightgroup) ) {
                             std::string groupname = groups.str(2);
                             if (ismg26x) groupname = groups.str(1);
                             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, ismg26x ? scalewmg26x : 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;
                                         if (!missed_weightgroup){
                                             break;
                                         } else missed_weightgroup=false;
                                     } else if (std::regex_search(lines[iLine], ismg26x ? weightgroupmg26x : 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;
                                         if (ismg26x) missed_weightgroup=true;
                                         --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;
                                         if (!missed_weightgroup){ 
                                             break;
                                         } else missed_weightgroup=false;
                                     } else if (std::regex_search(lines[iLine], ismg26x ? weightgroupmg26x : 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;
                                         if (ismg26x) missed_weightgroup=true;
                                         --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;
                                         if(!missed_weightgroup) {
                                             break;
                                         } else missed_weightgroup=false;
                                     } else if (std::regex_search(lines[iLine], ismg26x ? weightgroupmg26x : 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;
                                         if (ismg26x) missed_weightgroup=true;
                                         --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, ismg26x ? pdfwmg26x : pdfwOld)) {
                                         unsigned int member = 0;
                                         if (ismg26x==0){
                                             member = std::stoi(groups.str(2));
                                         } else {
                                             if (!groups.str(4).empty()){
                                                 member = std::stoi(groups.str(4));
                                              }
                                         }
                                         unsigned int lhaID = member+firstLhaID;
                                         if (lheDebug) std::cout << "    >>> PDF weight " << groups.str(1) << " for " << member << " = " << 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;
                                         if (!missed_weightgroup) {
                                             break;
                                         } else missed_weightgroup=false;
                                     } else if (std::regex_search(lines[iLine], ismg26x ? weightgroupmg26x : 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;
                                         if (ismg26x) missed_weightgroup=true;
                                         --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;
                                         if (!missed_weightgroup){
                                             break;
                                         } else missed_weightgroup=false;
                                     } else if (std::regex_search(lines[iLine], ismg26x ? weightgroupmg26x : 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;
                                         if (ismg26x) missed_weightgroup=true;
                                         --iLine; // rewind by one, and go back to the outer loop
                                         break;
                                     }
                                 }
                             }
                         } else if(std::regex_search(lines[iLine], groups, weightgroupRwgt) ) {
                             std::string groupname = groups.str(1);
                             if (groupname == "mg_reweighting") {
                                 if (lheDebug) std::cout << ">>> Looks like a LHE weights for reweighting" << std::endl;
                                 for ( ++iLine; iLine < nLines; ++iLine) {
                                     if (lheDebug) std::cout << "    " << lines[iLine];
                                     if (std::regex_search(lines[iLine], groups, rwgt)) {
                                         std::string rwgtID = groups.str(1);
                                         if (lheDebug) std::cout << "    >>> LHE reweighting weight: " << rwgtID << std::endl;
                                         if (std::find(lheReweighingIDs.begin(), lheReweighingIDs.end(), rwgtID) == lheReweighingIDs.end()) {
                                             // we're only interested in the beggining of the block
                                             lheReweighingIDs.emplace_back(rwgtID);
                                         }
                                     } else if (std::regex_search(lines[iLine], endweightgroup)) {
                                         if (lheDebug) std::cout << ">>> Looks like the end of a weight group" << std::endl;
                                         if (!missed_weightgroup){
                                             break;
                                         } else missed_weightgroup=false;
                                     } else if (std::regex_search(lines[iLine], ismg26x ? weightgroupmg26x : 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;
                                         if (ismg26x) missed_weightgroup=true;
                                         --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());
                     }
 
                     // ------ LHE REWEIGHTING -------
                     if (lheDebug) {
                         std::cout << "Found " << lheReweighingIDs.size() << " reweighting weights" << std::endl;
                     }
                     std::copy(lheReweighingIDs.begin(), lheReweighingIDs.end(), std::back_inserter(weightChoice->rwgtIDs));
                     
                     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 576 of file GenWeightsTableProducer.cc.

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

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

inlineoverride

Definition at line 610 of file GenWeightsTableProducer.cc.

610 { }

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

inlineoverride

Definition at line 587 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->sumRwgt.empty()) {
                 auto sumRwgts = runCounter->sumRwgt; for (auto & val : sumRwgts) val *= norm;
                 out->addVFloat("LHEReweightingSumw", "Sum of genEventWeight * LHEReweightingWeight[i], divided by genEventSumw", sumRwgts);
             }
             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 584 of file GenWeightsTableProducer.cc.

584 {

585 }

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

inlineoverride

Definition at line 176 of file GenWeightsTableProducer.cc.

References nanoaod::FlatTable::FloatColumn, edm::Event::getByToken(), edm::Event::getRun(), edm::Run::index(), edm::HandleBase::isValid(), 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, lheRwgtTab, lheNamedTab;
             std::unique_ptr<nanoaod::FlatTable> genPSTab;
 
             edm::Handle<LHEEventProduct> lheInfo;
             for (const auto & lheTag: lheTag_) {
                 iEvent.getByToken(lheTag, lheInfo);
                 if (lheInfo.isValid()) {
                     break;
                 }
             }
             if (lheInfo.isValid()) {
                 // get the dynamic choice of weights
                 const DynamicWeightChoice * weightChoice = runCache(iEvent.getRun().index());
                 // go fill tables
                 fillLHEWeightTables(counter, weightChoice, weight, *lheInfo, *genInfo, lheScaleTab, lhePdfTab, lheRwgtTab, lheNamedTab, genPSTab);
             } else {
                 // Still try to add the PS weights
                 fillOnlyPSWeightTable(counter, weight, *genInfo, genPSTab);
                 // make dummy values 
                 lheScaleTab.reset(new nanoaod::FlatTable(1, "LHEScaleWeights", true));
                 lhePdfTab.reset(new nanoaod::FlatTable(1, "LHEPdfWeights", true));
                 lheRwgtTab.reset(new nanoaod::FlatTable(1, "LHEReweightingWeights", 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(lheRwgtTab), "LHEReweighting");
             iEvent.put(std::move(lheNamedTab), "LHENamed");
             iEvent.put(std::move(genPSTab), "PS");
         }

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

inlineoverride

Definition at line 572 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 580 of file GenWeightsTableProducer.cc.

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