Inheritance diagram for GenWeightsTableProducer:

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

	debug_ (params.getUntrackedParameter< bool >("debug", false))

	debugRun_ (debug_.load())

void	fillLHEPdfWeightTablesFromGenInfo (Counter counter, const DynamicWeightChoiceGenInfo weightChoice, double genWeight, const GenEventInfoProduct &genProd, std::unique_ptr< nanoaod::FlatTable > &outScale, std::unique_ptr< nanoaod::FlatTable > &outPdf, std::unique_ptr< nanoaod::FlatTable > &outNamed, std::unique_ptr< nanoaod::FlatTable > &outPS) const

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

	genLumiInfoHeadTag_ (mayConsume< GenLumiInfoHeader, edm::InLumi >(params.getParameter< edm::InputTag >("genLumiInfoHeader")))

	GenWeightsTableProducer (edm::ParameterSet const &params)

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

std::shared_ptr< CounterMap >	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 &, CounterMap const *runCounterMap) const override

void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, CounterMap *runCounterMap) const override

	hasIssuedWarning_ (false)

	keepAllPSWeights_ (params.getParameter< bool >("keepAllPSWeights"))

	lheRunTag_ (edm::vector_transform(lheLabel_, [this](const edm::InputTag &tag){return mayConsume< LHERunInfoProduct, edm::InRun >(tag);}))

	lheWeightPrecision_ (params.getParameter< int32_t >("lheWeightPrecision"))

	maxPdfWeights_ (params.getParameter< uint32_t >("maxPdfWeights"))

	namedWeightIDs_ (params.getParameter< std::vector< std::string >>("namedWeightIDs"))

	namedWeightLabels_ (params.getParameter< std::vector< std::string >>("namedWeightLabels"))

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

	psWeightWarning_ (false)

void	setPSWeightInfo (const std::vector< double > &genWeights, const DynamicWeightChoiceGenInfo *genWeightChoice, std::vector< double > &wPS, std::string &psWeightDocStr) const

void	streamBeginLuminosityBlock (edm::StreamID id, edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &eventSetup) 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 &, CounterMap *runCounterMap) const override

	~GenWeightsTableProducer () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () 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

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

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

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::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 < GenLumiInfoHeader >	genLumiInfoHeadTag_

const edm::EDGetTokenT < GenEventInfoProduct >	genTag_

std::atomic< bool >	hasIssuedWarning_

bool	keepAllPSWeights_

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_

std::atomic< bool >	psWeightWarning_

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

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

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

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

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

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

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

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

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 247 of file GenWeightsTableProducer.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 252 of file GenWeightsTableProducer.cc.

References GlobalPosition_Frontier_DevDB_cff::tag.

       : 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); })),

GenWeightsTableProducer::~GenWeightsTableProducer ( )

inlineoverride

Definition at line 290 of file GenWeightsTableProducer.cc.

290 {}

Member Function Documentation

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

inlineoverride

Definition at line 937 of file GenWeightsTableProducer.cc.

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

GenWeightsTableProducer::debug_ ( params.getUntrackedParameter< bool > "debug", false )

GenWeightsTableProducer::debugRun_ ( debug_. load() )

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

inlinestatic

Definition at line 1135 of file GenWeightsTableProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addVPSet(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, 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>("genLumiInfoHeader", edm::InputTag("generator"))
         ->setComment("tag for the GenLumiInfoProduct, to get the model string");
     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.add<bool>("keepAllPSWeights")->setComment("Store all PS weights found");
     desc.addOptionalUntracked<bool>("debug")->setComment("dump out all LHE information for one event");
     descriptions.add("genWeightsTable", desc);
   }

void GenWeightsTableProducer::fillLHEPdfWeightTablesFromGenInfo	(	Counter *	counter,
		const DynamicWeightChoiceGenInfo *	weightChoice,
		double	genWeight,
		const GenEventInfoProduct &	genProd,
		std::unique_ptr< nanoaod::FlatTable > &	outScale,
		std::unique_ptr< nanoaod::FlatTable > &	outPdf,
		std::unique_ptr< nanoaod::FlatTable > &	outNamed,
		std::unique_ptr< nanoaod::FlatTable > &	outPS
	)		const

inline

Definition at line 440 of file GenWeightsTableProducer.cc.

References lheWeightPrecision_, setPSWeightInfo(), AlCaHLTBitMon_QueryRunRegistry::string, GenEventInfoProduct::weights(), and HLT_FULL_cff::weights.

Referenced by produce().

                                                                                        {
     const std::vector<unsigned int>& scaleWeightIDs = weightChoice->scaleWeightIDs;
     const std::vector<unsigned int>& pdfWeightIDs = weightChoice->pdfWeightIDs;
 
     auto weights = genProd.weights();
     double w0 = (weights.size() > 1) ? weights.at(1) : 1.;
     double originalXWGTUP = (weights.size() > 1) ? weights.at(1) : 1.;
 
     std::vector<double> wScale, wPDF, wPS;
     for (auto id : scaleWeightIDs)
       wScale.push_back(weights.at(id) / w0);
     for (auto id : pdfWeightIDs) {
       wPDF.push_back(weights.at(id) / w0);
     }
 
     std::string psWeightsDocStr;
     setPSWeightInfo(genProd.weights(), weightChoice, wPS, psWeightsDocStr);
 
     outScale = std::make_unique<nanoaod::FlatTable>(wScale.size(), "LHEScaleWeight", false);
     outScale->addColumn<float>("", wScale, weightChoice->scaleWeightsDoc, lheWeightPrecision_);
 
     outPdf = std::make_unique<nanoaod::FlatTable>(wPDF.size(), "LHEPdfWeight", false);
     outPdf->addColumn<float>("", wPDF, weightChoice->pdfWeightsDoc, lheWeightPrecision_);
 
     outPS = std::make_unique<nanoaod::FlatTable>(wPS.size(), "PSWeight", false);
     outPS->addColumn<float>("", wPS, psWeightsDocStr, lheWeightPrecision_);
 
     outNamed = std::make_unique<nanoaod::FlatTable>(1, "LHEWeight", true);
     outNamed->addColumnValue<float>("originalXWGTUP", originalXWGTUP, "Nominal event weight in the LHE file");
     /*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", lheWeightPrecision_);
       }*/
 
     counter->incLHE(genWeight, wScale, wPDF, std::vector<double>(), std::vector<double>(), wPS);
   }

void GenWeightsTableProducer::fillLHEWeightTables	(	Counter *	counter,
		const DynamicWeightChoice *	weightChoice,
		const DynamicWeightChoiceGenInfo *	genWeightChoice,
		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 369 of file GenWeightsTableProducer.cc.

References debug_, spr::find(), mps_fire::i, lheWeightPrecision_, dqmiodumpmetadata::n, namedWeightIDs_, namedWeightLabels_, LHEEventProduct::originalXWGTUP(), gpuVertexFinder::printf(), setPSWeightInfo(), AlCaHLTBitMon_QueryRunRegistry::string, histoStyle::weight, GenEventInfoProduct::weights(), and LHEEventProduct::weights().

Referenced by produce().

                                                                          {
     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;
     }
 
     std::vector<double> wPS;
     std::string psWeightDocStr;
     setPSWeightInfo(genProd.weights(), genWeightChoice, wPS, psWeightDocStr);
 
     outPS = std::make_unique<nanoaod::FlatTable>(wPS.size(), "PSWeight", false);
     outPS->addColumn<float>("", wPS, psWeightDocStr, lheWeightPrecision_);
 
     outScale = std::make_unique<nanoaod::FlatTable>(wScale.size(), "LHEScaleWeight", false);
     outScale->addColumn<float>("", wScale, weightChoice->scaleWeightsDoc, lheWeightPrecision_);
 
     outPdf = std::make_unique<nanoaod::FlatTable>(wPDF.size(), "LHEPdfWeight", false);
     outPdf->addColumn<float>("", wPDF, weightChoice->pdfWeightsDoc, lheWeightPrecision_);
 
     outRwgt = std::make_unique<nanoaod::FlatTable>(wRwgt.size(), "LHEReweightingWeight", false);
     outRwgt->addColumn<float>("", wRwgt, weightChoice->rwgtWeightDoc, lheWeightPrecision_);
 
     outNamed = std::make_unique<nanoaod::FlatTable>(1, "LHEWeight", true);
     outNamed->addColumnValue<float>("originalXWGTUP", lheProd.originalXWGTUP(), "Nominal event weight in the LHE file");
     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",
                                       lheWeightPrecision_);
     }
 
     counter->incLHE(genWeight, wScale, wPDF, wRwgt, wNamed, wPS);
   }

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

inline

Definition at line 483 of file GenWeightsTableProducer.cc.

References lheWeightPrecision_, setPSWeightInfo(), AlCaHLTBitMon_QueryRunRegistry::string, and GenEventInfoProduct::weights().

Referenced by produce().

                                                                            {
     std::vector<double> wPS;
     std::string psWeightDocStr;
     setPSWeightInfo(genProd.weights(), genWeightChoice, wPS, psWeightDocStr);
     outPS = std::make_unique<nanoaod::FlatTable>(wPS.size(), "PSWeight", false);
     outPS->addColumn<float>("", wPS, psWeightDocStr, lheWeightPrecision_);
 
     counter->incGenOnly(genWeight);
     counter->incPSOnly(genWeight, wPS);
   }

GenWeightsTableProducer::genLumiInfoHeadTag_ ( mayConsume< GenLumiInfoHeader, edm::InLumi > params.getParameter< edm::InputTag >("genLumiInfoHeader") )

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

inlineoverride

Definition at line 544 of file GenWeightsTableProducer.cc.

References filterCSVwithJSON::copy, gather_cfg::cout, debugRun_, dataset::end, spr::find(), first, newFWLiteAna::found, edm::Run::getByLabel(), gpuClustering::id, edm::HandleBase::isValid(), lhaNameToID_, lheLabel_, groupFilesInBlocks::lines, maxPdfWeights_, submitDQMOfflineCAF::nLines, preferredPDFLHAIDs_, gpuVertexFinder::printf(), 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;
       bool isFirstGroup = true;
 
       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 scalewmg26xNew(
           "<weight\\s*((?:[mM][uU][fF]|facscfact)=\"(\\S+)\"\\s+(?:[mM][uU][Rr]|renscfact)=\"(\\S+)\").+id=\"(\\d+)\"(."
           "*)?</weight>");
 
       //<weight MUF="1.0" MUR="2.0" PDF="306000" id="1006"> MUR=2.0  </weight>
       std::regex scalew(
           "<weight\\s+(?:.*\\s+)?id=\"(\\d+|\\d+-NNLOPS)\">\\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>");
       //<weightgroup combine="symmhessian+as" name="NNPDF31_nnlo_as_0118_mc_hessian_pdfas">
 
       //<weight MUF="1.0" MUR="1.0" PDF="325300" id="1048"> PDF=325300 MemberID=0 </weight>
       std::regex pdfwmg26xNew(
           "<weight\\s+MUF=\"(?:\\S+)\"\\s*MUR=\"(?:\\S+)\"\\s*PDF=\"(?:\\S+)\"\\s*id=\"(\\S+)\"\\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;
         bool ismg26xNew = 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;
           } else if (std::regex_search(lines[iLine], groups, scalewmg26xNew) ||
                      std::regex_search(lines[iLine], groups, pdfwmg26xNew)) {
             ismg26xNew = 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" || isFirstGroup) {
               if (lheDebug && groupname.find("scale_variation") != 0 && groupname != "Central scale variation")
                 std::cout << ">>> First weight is not scale variation, but assuming is the Central Weight" << std::endl;
               else if (lheDebug)
                 std::cout << ">>> Looks like scale variation for theory uncertainties" << std::endl;
               isFirstGroup = false;
               for (++iLine; iLine < nLines; ++iLine) {
                 if (lheDebug) {
                   std::cout << "    " << lines[iLine];
                 }
                 if (std::regex_search(
                         lines[iLine], groups, ismg26x ? scalewmg26x : (ismg26xNew ? scalewmg26xNew : scalew))) {
                   if (lheDebug)
                     std::cout << "    >>> Scale weight " << groups[1].str() << " for " << groups[3].str() << " , "
                               << groups[4].str() << " , " << groups[5].str() << std::endl;
                   if (ismg26xNew) {
                     scaleVariationIDs.emplace_back(groups.str(4), groups.str(1), groups.str(3), groups.str(2));
                   } else {
                     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 || ismg26xNew)
                     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 || ismg26xNew)
                     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 || ismg26xNew)
                     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 : (ismg26xNew ? pdfwmg26xNew : pdfwOld))) {
                   unsigned int member = 0;
                   if (!ismg26x && !ismg26xNew) {
                     member = std::stoi(groups.str(2));
                   } else if (ismg26xNew) {
                     if (!groups.str(3).empty()) {
                       member = std::stoi(groups.str(3));
                     }
                   } 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 || ismg26xNew)
                     missed_weightgroup = true;
                   --iLine;  // rewind by one, and go back to the outer loop
                   break;
                 }
               }
             } else if (groupname == "mass_variation" || groupname == "sthw2_variation" ||
                        groupname == "width_variation") {
               if (lheDebug)
                 std::cout << ">>> Looks like an EW parameter weight" << 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;
                 }
               }
             } 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 || ismg26xNew)
                     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 (const auto& pw : pdfSetWeightIDs) {
           for (uint32_t lhaid : preferredPDFLHAIDs_) {
             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<CounterMap> GenWeightsTableProducer::globalBeginRunSummary	(	edm::Run const &	,
		edm::EventSetup const &
	)		const

inlineoverride

Definition at line 1071 of file GenWeightsTableProducer.cc.

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

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

inlineoverride

Definition at line 1133 of file GenWeightsTableProducer.cc.

1133 {}

void GenWeightsTableProducer::globalEndRunProduce	(	edm::Run &	iRun,
		edm::EventSetup const &	,
		CounterMap const *	runCounterMap
	)		const

inlineoverride

Definition at line 1084 of file GenWeightsTableProducer.cc.

References mps_fire::i, label, eostools::move(), dqmiodumpmetadata::n, namedWeightLabels_, submitPVResolutionJobs::out, edm::Run::put(), AlCaHLTBitMon_QueryRunRegistry::string, hgcalPerformanceValidation::val, and x.

                                                                                                                {
     auto out = std::make_unique<nanoaod::MergeableCounterTable>();
 
     for (const auto& x : runCounterMap->countermap) {
       auto runCounter = &(x.second);
       std::string label = (!x.first.empty()) ? (std::string("_") + x.first) : "";
       std::string doclabel = (!x.first.empty()) ? (std::string(", for model label ") + x.first) : "";
 
       out->addInt("genEventCount" + label, "event count" + doclabel, runCounter->num);
       out->addFloat("genEventSumw" + label, "sum of gen weights" + doclabel, runCounter->sumw);
       out->addFloat("genEventSumw2" + label, "sum of gen (weight^2)" + doclabel, runCounter->sumw2);
 
       double norm = runCounter->sumw ? 1.0 / runCounter->sumw : 1;
       auto sumScales = runCounter->sumScale;
       for (auto& val : sumScales)
         val *= norm;
       out->addVFloatWithNorm("LHEScaleSumw" + label,
                              "Sum of genEventWeight * LHEScaleWeight[i], divided by genEventSumw" + doclabel,
                              sumScales,
                              runCounter->sumw);
       auto sumPDFs = runCounter->sumPDF;
       for (auto& val : sumPDFs)
         val *= norm;
       out->addVFloatWithNorm("LHEPdfSumw" + label,
                              "Sum of genEventWeight * LHEPdfWeight[i], divided by genEventSumw" + doclabel,
                              sumPDFs,
                              runCounter->sumw);
       if (!runCounter->sumRwgt.empty()) {
         auto sumRwgts = runCounter->sumRwgt;
         for (auto& val : sumRwgts)
           val *= norm;
         out->addVFloatWithNorm("LHEReweightingSumw" + label,
                                "Sum of genEventWeight * LHEReweightingWeight[i], divided by genEventSumw" + doclabel,
                                sumRwgts,
                                runCounter->sumw);
       }
       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->addFloatWithNorm(
               "LHESumw_" + namedWeightLabels_[i] + label,
               "Sum of genEventWeight * LHEWeight_" + namedWeightLabels_[i] + ", divided by genEventSumw" + doclabel,
               runCounter->sumNamed[i] * norm,
               runCounter->sumw);
         }
       }
     }
     iRun.put(std::move(out));
   }

void GenWeightsTableProducer::globalEndRunSummary	(	edm::Run const &	,
		edm::EventSetup const &	,
		CounterMap *	runCounterMap
	)		const

inlineoverride

Definition at line 1082 of file GenWeightsTableProducer.cc.

1082 {}

GenWeightsTableProducer::hasIssuedWarning_ ( false )

GenWeightsTableProducer::keepAllPSWeights_ ( params.getParameter< bool > "keepAllPSWeights" )

GenWeightsTableProducer::lheRunTag_ ( edm:: vector_transformlheLabel_,[this](const edm::InputTag &tag){return mayConsume< LHERunInfoProduct, edm::InRun >(tag);} )

GenWeightsTableProducer::lheWeightPrecision_ ( params.getParameter< int32_t > "lheWeightPrecision" )

GenWeightsTableProducer::maxPdfWeights_ ( params.getParameter< uint32_t > "maxPdfWeights" )

GenWeightsTableProducer::namedWeightIDs_ ( params.getParameter< std::vector< std::string >> "namedWeightIDs" )

GenWeightsTableProducer::namedWeightLabels_ ( params.getParameter< std::vector< std::string >> "namedWeightLabels" )

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

inlineoverridevirtual

Implements edm::global::EDProducerBase.

Definition at line 292 of file GenWeightsTableProducer.cc.

References counter, fillLHEPdfWeightTablesFromGenInfo(), fillLHEWeightTables(), fillOnlyPSWeightTable(), genTag_, edm::Event::getByToken(), edm::Event::getRun(), hasIssuedWarning_, edm::Run::index(), edm::HandleBase::isValid(), lheTag_, eostools::move(), submitPVResolutionJobs::out, edm::Event::put(), AlCaHLTBitMon_QueryRunRegistry::string, and histoStyle::weight.

                                                                                              {
     // get my counter for weights
     Counter* counter = streamCache(id)->countermap.get();
 
     // 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");
     iEvent.put(std::move(out));
 
     std::string model_label = streamCache(id)->countermap.getLabel();
     auto outM = std::make_unique<std::string>((!model_label.empty()) ? std::string("GenModel_") + model_label : "");
     iEvent.put(std::move(outM), "genModel");
     bool getLHEweightsFromGenInfo = !model_label.empty();
 
     // 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;
       }
     }
 
     const auto genWeightChoice = &(streamCache(id)->weightChoice);
     if (lheInfo.isValid()) {
       if (getLHEweightsFromGenInfo && !hasIssuedWarning_.exchange(true))
         edm::LogWarning("LHETablesProducer")
             << "Found both a LHEEventProduct and a GenLumiInfoHeader: will only save weights from LHEEventProduct.\n";
       // get the dynamic choice of weights
       const DynamicWeightChoice* weightChoice = runCache(iEvent.getRun().index());
       // go fill tables
       fillLHEWeightTables(counter,
                           weightChoice,
                           genWeightChoice,
                           weight,
                           *lheInfo,
                           *genInfo,
                           lheScaleTab,
                           lhePdfTab,
                           lheRwgtTab,
                           lheNamedTab,
                           genPSTab);
     } else if (getLHEweightsFromGenInfo) {
       fillLHEPdfWeightTablesFromGenInfo(
           counter, genWeightChoice, weight, *genInfo, lheScaleTab, lhePdfTab, lheNamedTab, genPSTab);
       lheRwgtTab = std::make_unique<nanoaod::FlatTable>(1, "LHEReweightingWeights", true);
       //lheNamedTab.reset(new nanoaod::FlatTable(1, "LHENamedWeights", true));
       //genPSTab.reset(new nanoaod::FlatTable(1, "PSWeight", true));
     } else {
       // Still try to add the PS weights
       fillOnlyPSWeightTable(counter, genWeightChoice, weight, *genInfo, genPSTab);
       // make dummy values
       lheScaleTab = std::make_unique<nanoaod::FlatTable>(1, "LHEScaleWeights", true);
       lhePdfTab = std::make_unique<nanoaod::FlatTable>(1, "LHEPdfWeights", true);
       lheRwgtTab = std::make_unique<nanoaod::FlatTable>(1, "LHEReweightingWeights", true);
       lheNamedTab = std::make_unique<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");
   }

GenWeightsTableProducer::psWeightWarning_ ( false )

inline

Definition at line 269 of file GenWeightsTableProducer.cc.

References Exception, lhaNameToID_, mergeVDriftHistosByStation::name, namedWeightIDs_, namedWeightLabels_, submitPVValidationJobs::params, preferredPDFLHAIDs_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                 {
     produces<nanoaod::FlatTable>();
     produces<std::string>("genModel");
     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;
     }
   }

void GenWeightsTableProducer::setPSWeightInfo	(	const std::vector< double > &	genWeights,
		const DynamicWeightChoiceGenInfo *	genWeightChoice,
		std::vector< double > &	wPS,
		std::string &	psWeightDocStr
	)		const

inline

Definition at line 498 of file GenWeightsTableProducer.cc.

References mps_fire::i, keepAllPSWeights_, and psWeightWarning_.

Referenced by fillLHEPdfWeightTablesFromGenInfo(), fillLHEWeightTables(), and fillOnlyPSWeightTable().

                                                         {
     wPS.clear();
     // isRegularPSSet = keeping all weights and the weights are a usual size, ie
     //                  all weights are PS weights (don't use header incase missing names)
     bool isRegularPSSet = keepAllPSWeights_ && (genWeights.size() == 14 || genWeights.size() == 46);
     if (!genWeightChoice->psWeightIDs.empty() && !isRegularPSSet) {
       psWeightDocStr = genWeightChoice->psWeightsDoc;
       double psNom = genWeights.at(genWeightChoice->psBaselineID);
       for (auto wgtidx : genWeightChoice->psWeightIDs) {
         wPS.push_back(genWeights.at(wgtidx) / psNom);
       }
     } else {
       int vectorSize =
           keepAllPSWeights_ ? (genWeights.size() - 2) : ((genWeights.size() == 14 || genWeights.size() == 46) ? 4 : 1);
 
       if (vectorSize > 1) {
         double nominal = genWeights.at(1);  // Called 'Baseline' in GenLumiInfoHeader
         if (keepAllPSWeights_) {
           for (int i = 0; i < vectorSize; i++) {
             wPS.push_back(genWeights.at(i + 2) / nominal);
           }
           psWeightDocStr = "All PS weights (w_var / w_nominal)";
         } else {
           if (!psWeightWarning_.exchange(true))
             edm::LogWarning("LHETablesProducer")
                 << "GenLumiInfoHeader not found: Central PartonShower weights will fill with the 6-10th entries \n"
                 << "    This may incorrect for some mcs (madgraph 2.6.1 with its `isr:murfact=0.5` have a differnt "
                    "order )";
           for (std::size_t i = 6; i < 10; i++) {
             wPS.push_back(genWeights.at(i) / nominal);
           }
           psWeightDocStr =
               "PS weights (w_var / w_nominal);   [0] is ISR=2 FSR=1; [1] is ISR=1 FSR=2"
               "[2] is ISR=0.5 FSR=1; [3] is ISR=1 FSR=0.5;";
         }
       } else {
         wPS.push_back(1.0);
         psWeightDocStr = "dummy PS weight (1.0) ";
       }
     }
   }

void GenWeightsTableProducer::streamBeginLuminosityBlock	(	edm::StreamID	id,
		edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	eventSetup
	)		const

inlineoverride

Definition at line 944 of file GenWeightsTableProducer.cc.

References newFWLiteAna::found, genLumiInfoHeadTag_, edm::LuminosityBlock::getByToken(), watchdog::group, mps_fire::i, edm::HandleBase::isValid(), keepAllPSWeights_, label, lhaNameToID_, geometryCSVtoXML::line, maxPdfWeights_, AlCaHLTBitMon_QueryRunRegistry::string, and x.

                                                                                   {
     auto counterMap = &(streamCache(id)->countermap);
     edm::Handle<GenLumiInfoHeader> genLumiInfoHead;
     lumiBlock.getByToken(genLumiInfoHeadTag_, genLumiInfoHead);
     if (!genLumiInfoHead.isValid())
       edm::LogWarning("LHETablesProducer")
           << "No GenLumiInfoHeader product found, will not fill generator model string.\n";
 
     std::string label;
     if (genLumiInfoHead.isValid()) {
       label = genLumiInfoHead->configDescription();
       boost::replace_all(label, "-", "_");
       boost::replace_all(label, "/", "_");
     }
     counterMap->setLabel(label);
 
     if (genLumiInfoHead.isValid()) {
       auto weightChoice = &(streamCache(id)->weightChoice);
 
       std::vector<ScaleVarWeight> scaleVariationIDs;
       std::vector<PDFSetWeights> pdfSetWeightIDs;
       weightChoice->psWeightIDs.clear();
 
       std::regex scalew("LHE,\\s+id\\s+=\\s+(\\d+),\\s+(.+)\\,\\s+mur=(\\S+)\\smuf=(\\S+)");
       std::regex pdfw("LHE,\\s+id\\s+=\\s+(\\d+),\\s+(.+),\\s+Member\\s+(\\d+)\\s+of\\ssets\\s+(\\w+\\b)");
       std::regex mainPSw("sr(Def|:murfac=)(Hi|Lo|_dn|_up|0.5|2.0)");
       std::smatch groups;
       auto weightNames = genLumiInfoHead->weightNames();
       std::unordered_map<std::string, uint32_t> knownPDFSetsFromGenInfo_;
       unsigned int weightIter = 0;
       for (const auto& line : weightNames) {
         if (std::regex_search(line, groups, scalew)) {  // scale variation
           auto id = groups.str(1);
           auto group = groups.str(2);
           auto mur = groups.str(3);
           auto muf = groups.str(4);
           if (group.find("Central scale variation") != std::string::npos)
             scaleVariationIDs.emplace_back(groups.str(1), groups.str(2), groups.str(3), groups.str(4));
         } else if (std::regex_search(line, groups, pdfw)) {  // PDF variation
           auto id = groups.str(1);
           auto group = groups.str(2);
           auto memberid = groups.str(3);
           auto pdfset = groups.str(4);
           if (group.find(pdfset) != std::string::npos) {
             if (knownPDFSetsFromGenInfo_.find(pdfset) == knownPDFSetsFromGenInfo_.end()) {
               knownPDFSetsFromGenInfo_[pdfset] = std::atoi(id.c_str());
               pdfSetWeightIDs.emplace_back(id, std::atoi(id.c_str()));
             } else
               pdfSetWeightIDs.back().add(id, std::atoi(id.c_str()));
           }
         } else if (line == "Baseline") {
           weightChoice->psBaselineID = weightIter;
         } else if (line.find("isr") != std::string::npos || line.find("fsr") != std::string::npos) {
           weightChoice->matchPS_alt = line.find("sr:") != std::string::npos;  // (f/i)sr: for new weights
           if (keepAllPSWeights_) {
             weightChoice->psWeightIDs.push_back(weightIter);  // PS variations
           } else if (std::regex_search(line, groups, mainPSw)) {
             if (weightChoice->psWeightIDs.empty())
               weightChoice->psWeightIDs = std::vector<unsigned int>(4, -1);
             int psIdx = (line.find("fsr") != std::string::npos) ? 1 : 0;
             psIdx += (groups.str(2) == "Hi" || groups.str(2) == "_up" || groups.str(2) == "2.0") ? 0 : 2;
             weightChoice->psWeightIDs[psIdx] = weightIter;
           }
         }
         weightIter++;
       }
       if (keepAllPSWeights_) {
         weightChoice->psWeightsDoc = "All PS weights (w_var / w_nominal)";
       } else if (weightChoice->psWeightIDs.size() == 4) {
         weightChoice->psWeightsDoc =
             "PS weights (w_var / w_nominal);   [0] is ISR=2 FSR=1; [1] is ISR=1 FSR=2"
             "[2] is ISR=0.5 FSR=1; [3] is ISR=1 FSR=0.5;";
         for (int i = 0; i < 4; i++) {
           if (static_cast<int>(weightChoice->psWeightIDs[i]) == -1)
             weightChoice->setMissingWeight(i);
         }
       } else {
         weightChoice->psWeightsDoc = "dummy PS weight (1.0) ";
       }
 
       weightChoice->scaleWeightIDs.clear();
       weightChoice->pdfWeightIDs.clear();
 
       std::sort(scaleVariationIDs.begin(), scaleVariationIDs.end());
       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(std::atoi(sw.wid.c_str()));
       }
       if (!scaleVariationIDs.empty())
         weightChoice->scaleWeightsDoc = scaleDoc.str();
       std::stringstream pdfDoc;
       pdfDoc << "LHE pdf variation weights (w_var / w_nominal) for LHA names ";
       bool found = false;
       for (const auto& pw : pdfSetWeightIDs) {
         if (pw.wids.size() == 1)
           continue;  // only consider error sets
         for (const auto& wantedpdf : lhaNameToID_) {
           auto pdfname = wantedpdf.first;
           if (knownPDFSetsFromGenInfo_.find(pdfname) == knownPDFSetsFromGenInfo_.end())
             continue;
           uint32_t lhaid = knownPDFSetsFromGenInfo_.at(pdfname);
           if (pw.lhaIDs.first != lhaid)
             continue;
           pdfDoc << pdfname;
           for (const auto& x : pw.wids)
             weightChoice->pdfWeightIDs.push_back(std::atoi(x.c_str()));
           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;
       }
     }
   }

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

inlineoverride

Definition at line 941 of file GenWeightsTableProducer.cc.

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

void GenWeightsTableProducer::streamEndRunSummary	(	edm::StreamID	id,
		edm::Run const &	,
		edm::EventSetup const &	,
		CounterMap *	runCounterMap
	)		const

inlineoverride

Definition at line 1075 of file GenWeightsTableProducer.cc.

                                                                      {
     runCounterMap->merge(streamCache(id)->countermap);
   }

Member Data Documentation

std::atomic<bool> GenWeightsTableProducer::debug_

mutableprotected

Definition at line 1175 of file GenWeightsTableProducer.cc.

Referenced by fillLHEWeightTables().

std::atomic<bool> GenWeightsTableProducer::debugRun_

mutableprotected

Definition at line 1175 of file GenWeightsTableProducer.cc.

Referenced by globalBeginRun().

const edm::EDGetTokenT<GenLumiInfoHeader> GenWeightsTableProducer::genLumiInfoHeadTag_

protected

Definition at line 1165 of file GenWeightsTableProducer.cc.

Referenced by streamBeginLuminosityBlock().

const edm::EDGetTokenT<GenEventInfoProduct> GenWeightsTableProducer::genTag_

protected

Definition at line 1161 of file GenWeightsTableProducer.cc.

Referenced by produce().

std::atomic<bool> GenWeightsTableProducer::hasIssuedWarning_

mutableprotected

Definition at line 1175 of file GenWeightsTableProducer.cc.

Referenced by produce().

bool GenWeightsTableProducer::keepAllPSWeights_

protected

Definition at line 1173 of file GenWeightsTableProducer.cc.

Referenced by setPSWeightInfo(), and streamBeginLuminosityBlock().

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

protected

Definition at line 1168 of file GenWeightsTableProducer.cc.

Referenced by globalBeginRun(), psWeightWarning_(), and streamBeginLuminosityBlock().

const std::vector<edm::InputTag> GenWeightsTableProducer::lheLabel_

protected

Definition at line 1162 of file GenWeightsTableProducer.cc.

Referenced by globalBeginRun().

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

protected

Definition at line 1164 of file GenWeightsTableProducer.cc.

const std::vector<edm::EDGetTokenT<LHEEventProduct> > GenWeightsTableProducer::lheTag_

protected

Definition at line 1163 of file GenWeightsTableProducer.cc.

Referenced by produce().

int GenWeightsTableProducer::lheWeightPrecision_

protected

Definition at line 1171 of file GenWeightsTableProducer.cc.

Referenced by fillLHEPdfWeightTablesFromGenInfo(), fillLHEWeightTables(), and fillOnlyPSWeightTable().

unsigned int GenWeightsTableProducer::maxPdfWeights_

protected

Definition at line 1172 of file GenWeightsTableProducer.cc.

Referenced by globalBeginRun(), and streamBeginLuminosityBlock().

std::vector<std::string> GenWeightsTableProducer::namedWeightIDs_

protected

Definition at line 1169 of file GenWeightsTableProducer.cc.

Referenced by fillLHEWeightTables(), and psWeightWarning_().

std::vector<std::string> GenWeightsTableProducer::namedWeightLabels_

protected

Definition at line 1170 of file GenWeightsTableProducer.cc.

Referenced by fillLHEWeightTables(), globalEndRunProduce(), and psWeightWarning_().

std::vector<uint32_t> GenWeightsTableProducer::preferredPDFLHAIDs_

protected

Definition at line 1167 of file GenWeightsTableProducer.cc.

Referenced by globalBeginRun(), and psWeightWarning_().

std::atomic<bool> GenWeightsTableProducer::psWeightWarning_

mutableprotected

Definition at line 1175 of file GenWeightsTableProducer.cc.

Referenced by setPSWeightInfo().

Public Member Functions

Static Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation