#include <CMGTools/PileupJetIdProducer/src/PileupJetIdProducer.cc>

Inheritance diagram for PileupJetIdProducer:

Public Member Functions
	PileupJetIdProducer (const edm::ParameterSet &)

	~PileupJetIdProducer ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
void	initJetEnergyCorrector (const edm::EventSetup &iSetup, bool isData)

virtual void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< std::pair< std::string, std::unique_ptr< PileupJetIdAlgo > > >	algos_

bool	applyJec_

edm::EDGetTokenT< edm::View< reco::Jet > >	input_jet_token_

edm::EDGetTokenT< double >	input_rho_token_

edm::EDGetTokenT< reco::VertexCollection >	input_vertex_token_

edm::EDGetTokenT< edm::ValueMap< StoredPileupJetIdentifier > >	input_vm_pujetid_token_

bool	inputIsCorrected_

std::string	jec_

std::unique_ptr< FactorizedJetCorrector >	jecCor_

std::vector< JetCorrectorParameters >	jetCorPars_

edm::InputTag	jetids_

edm::InputTag	jets_

bool	produceJetIds_

bool	residualsFromTxt_

edm::FileInPath	residualsTxt_

edm::InputTag	rho_

bool	runMvas_

edm::InputTag	vertexes_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Description: Produces a value map of jet –> pileup jet ID

Implementation: [Notes on implementation]

Definition at line 49 of file PileupJetIdProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 24 of file PileupJetIdProducer.cc.

References hltMVAJetPuId_cff::algos, algos_, applyJec_, edm::ParameterSet::getParameter(), input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, inputIsCorrected_, jec_, jetids_, jets_, diffTwoXMLs::label, produceJetIds_, residualsFromTxt_, residualsTxt_, rho_, runMvas_, AlCaHLTBitMon_QueryRunRegistry::string, and vertexes_.

 {
     runMvas_ = iConfig.getParameter<bool>("runMvas");
     produceJetIds_ = iConfig.getParameter<bool>("produceJetIds");
     jets_ = iConfig.getParameter<edm::InputTag>("jets");
     vertexes_ = iConfig.getParameter<edm::InputTag>("vertexes");
     jetids_  = iConfig.getParameter<edm::InputTag>("jetids");
     inputIsCorrected_ = iConfig.getParameter<bool>("inputIsCorrected");
     applyJec_ = iConfig.getParameter<bool>("applyJec");
     jec_ =  iConfig.getParameter<std::string>("jec");
     rho_ = iConfig.getParameter<edm::InputTag>("rho");
     residualsFromTxt_ = iConfig.getParameter<bool>("residualsFromTxt");
     if(residualsFromTxt_) residualsTxt_ = iConfig.getParameter<edm::FileInPath>("residualsTxt");
     std::vector<edm::ParameterSet> algos = iConfig.getParameter<std::vector<edm::ParameterSet> >("algos");
     
 
     if( ! runMvas_ ) assert( algos.size() == 1 );
     
     if( produceJetIds_ ) {
         produces<edm::ValueMap<StoredPileupJetIdentifier> > ("");
     }
     for(std::vector<edm::ParameterSet>::iterator it=algos.begin(); it!=algos.end(); ++it) {
         std::string label = it->getParameter<std::string>("label");
         algos_.emplace_back( label, std::make_unique<PileupJetIdAlgo>(*it, runMvas_));
         if( runMvas_ ) {
             produces<edm::ValueMap<float> > (label+"Discriminant");
             produces<edm::ValueMap<int> > (label+"Id");
         }
     }
 
     input_jet_token_ = consumes<edm::View<reco::Jet> >(jets_);
     input_vertex_token_ = consumes<reco::VertexCollection>(vertexes_);
         input_vm_pujetid_token_ = consumes<edm::ValueMap<StoredPileupJetIdentifier> >(jetids_);
         input_rho_token_ = consumes<double>(rho_); 
 
 }

PileupJetIdProducer::~PileupJetIdProducer ( )

Definition at line 64 of file PileupJetIdProducer.cc.

65 {

66 }

Member Function Documentation

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

static

Definition at line 229 of file PileupJetIdProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                                 {
     //The following says we do not know what parameters are allowed so do no validation
     // Please change this to state exactly what you do use, even if it is no parameters
     edm::ParameterSetDescription desc;
     desc.setUnknown();
     descriptions.addDefault(desc);
 }

void PileupJetIdProducer::initJetEnergyCorrector	(	const edm::EventSetup &	iSetup,
		bool	isData
	)

private

Definition at line 240 of file PileupJetIdProducer.cc.

References DEFINE_FWK_MODULE, edm::FileInPath::fullPath(), edm::EventSetup::get(), jec_, jecCor_, jetCorPars_, metProducer_cfi::parameters, residualsFromTxt_, and residualsTxt_.

Referenced by produce().

 {
     //jet energy correction levels to apply on raw jet
     std::vector<std::string> jecLevels;
     jecLevels.push_back("L1FastJet");
     jecLevels.push_back("L2Relative");
     jecLevels.push_back("L3Absolute");
     if(isData && ! residualsFromTxt_ ) jecLevels.push_back("L2L3Residual");
 
     //check the corrector parameters needed according to the correction levels
     edm::ESHandle<JetCorrectorParametersCollection> parameters;
     iSetup.get<JetCorrectionsRecord>().get(jec_,parameters);
     for(std::vector<std::string>::const_iterator ll = jecLevels.begin(); ll != jecLevels.end(); ++ll)
     { 
         const JetCorrectorParameters& ip = (*parameters)[*ll];
         jetCorPars_.push_back(ip); 
     } 
     if( isData && residualsFromTxt_ ) {
         jetCorPars_.push_back(JetCorrectorParameters(residualsTxt_.fullPath())); 
     }
     
     //instantiate the jet corrector
     jecCor_ = std::make_unique<FactorizedJetCorrector>(jetCorPars_);
 }

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

overrideprivatevirtual

Definition at line 71 of file PileupJetIdProducer.cc.

References algos_, hltMVAJetPuId_cff::applyJec, applyJec_, edm::View< T >::at(), reco::CompositePtrCandidate::clone(), PileupJetIdAlgo::computeIdVariables(), PileupJetIdAlgo::computeMva(), pat::Jet::correctedJet(), reco::LeafCandidate::eta(), edm::Event::getByToken(), mps_fire::i, PileupJetIdentifier::idFlag(), initJetEnergyCorrector(), input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, inputIsCorrected_, edm::EventBase::isRealData(), patTestJEC_cfi::jec, jecCor_, configurableAnalysis::Jet, metsig::jet, reco::Jet::jetArea(), StoredPileupJetIdentifier::jetEta(), PileupJetIdentifier::jetPhi(), StoredPileupJetIdentifier::jetPt(), fwrapper::jets, eostools::move(), PileupJetIdentifier::mva(), RecoTauHPSTancTauProdcuer_cfi::mvas, reco::LeafCandidate::phi(), produceJetIds_, edm::Handle< T >::product(), reco::LeafCandidate::pt(), edm::Event::put(), edm::View< T >::refAt(), rho, runMvas_, Scenarios_cff::scale, reco::Jet::scaleEnergy(), PileupJetIdAlgo::set(), edm::View< T >::size(), hltMVAJetPuId_cff::vertexes, and badGlobalMuonTaggersAOD_cff::vtx.

 {
     using namespace edm;
     using namespace std;
     using namespace reco;
     
     // Input jets
     Handle<View<Jet> > jetHandle;
     iEvent.getByToken(input_jet_token_,jetHandle);
     const View<Jet> & jets = *jetHandle;
     // vertexes 
     Handle<VertexCollection> vertexHandle;
     if(  produceJetIds_ ) {
             iEvent.getByToken(input_vertex_token_, vertexHandle);
     }
     const VertexCollection & vertexes = *(vertexHandle.product());
     // input variables
     Handle<ValueMap<StoredPileupJetIdentifier> > vmap;
     if( ! produceJetIds_ ) {
         iEvent.getByToken(input_vm_pujetid_token_, vmap);
     }
     // rho
     edm::Handle< double > rhoH;
     double rho = 0.;
     
     // products
     vector<StoredPileupJetIdentifier> ids; 
     map<string, vector<float> > mvas;
     map<string, vector<int> > idflags;
 
     VertexCollection::const_iterator vtx;
     if( produceJetIds_ ) {
         // require basic quality cuts on the vertexes
         vtx = vertexes.begin();
         while( vtx != vertexes.end() && ( vtx->isFake() || vtx->ndof() < 4 ) ) {
             ++vtx;
         }
         if( vtx == vertexes.end() ) { vtx = vertexes.begin(); }
     }
     
     // Loop over input jets
     bool ispat = true;
     for ( unsigned int i=0; i<jets.size(); ++i ) {
         // Pick the first algo to compute the input variables
         auto algoi = algos_.begin();
         PileupJetIdAlgo * ialgo = algoi->second.get();
         
         const Jet & jet = jets.at(i);
         const pat::Jet * patjet = 0;
         if(ispat) {
             patjet=dynamic_cast<const pat::Jet *>(&jet);
             ispat = patjet != 0;
         }
         
         // Get jet energy correction
         float jec = 0.;
         if( applyJec_ ) {
             // If haven't done it get rho from the event
             if( rho == 0. ) {
                 iEvent.getByToken(input_rho_token_,rhoH);
                 rho = *rhoH;
             }
             // jet corrector
             if( not jecCor_ ) {
                 initJetEnergyCorrector( iSetup, iEvent.isRealData() );
             }
             if( ispat ) {
                 jecCor_->setJetPt(patjet->correctedJet(0).pt());
             } else {
                     jecCor_->setJetPt(jet.pt());
             }
             jecCor_->setJetEta(jet.eta());
             jecCor_->setJetA(jet.jetArea());
             jecCor_->setRho(rho);
             jec = jecCor_->getCorrection();
         }
         // If it was requested AND the input is an uncorrected jet apply the JEC
         bool applyJec = applyJec_ && ( ispat || !inputIsCorrected_ );
         reco::Jet * corrJet = 0;
         
         if( applyJec ) {
             float scale = jec;
             if( ispat ) {
                 corrJet = new pat::Jet(patjet->correctedJet(0)) ;
             } else {
                     corrJet = dynamic_cast<reco::Jet *>( jet.clone() );
             }
             corrJet->scaleEnergy(scale);
         }
         const reco::Jet * theJet = ( applyJec ? corrJet : &jet );
     
         PileupJetIdentifier puIdentifier;
         if( produceJetIds_ ) {
                 // Compute the input variables
                 puIdentifier = ialgo->computeIdVariables(theJet, jec,  &(*vtx), vertexes, rho);
             ids.push_back( puIdentifier );
         } else {
                 // Or read it from the value map
             puIdentifier = (*vmap)[jets.refAt(i)]; 
             puIdentifier.jetPt(theJet->pt());    // make sure JEC is applied when computing the MVA
             puIdentifier.jetEta(theJet->eta());
             puIdentifier.jetPhi(theJet->phi());
             ialgo->set(puIdentifier); 
             puIdentifier = ialgo->computeMva();
         }
     
         if( runMvas_ ) {
                 // Compute the MVA and WP
             mvas[algoi->first].push_back( puIdentifier.mva() );
             idflags[algoi->first].push_back( puIdentifier.idFlag() );
             for( ++algoi; algoi!=algos_.end(); ++algoi) {
                                 ialgo = algoi->second.get();
                 ialgo->set(puIdentifier);
                 PileupJetIdentifier id = ialgo->computeMva();
                 mvas[algoi->first].push_back( id.mva() );
                 idflags[algoi->first].push_back( id.idFlag() );
             }
         }
         
         // cleanup
         if( corrJet ) { delete corrJet; }
     }
     
     // Produce the output value maps
     if( runMvas_ ) {
                 for( const auto& ialgo : algos_) {
             // MVA
             vector<float> & mva = mvas[ialgo.first];
             auto mvaout = std::make_unique<ValueMap<float>>();
             ValueMap<float>::Filler mvafiller(*mvaout);
             mvafiller.insert(jetHandle,mva.begin(),mva.end());
             mvafiller.fill();
             iEvent.put(std::move(mvaout),ialgo.first+"Discriminant");
             
             // WP
             vector<int> & idflag = idflags[ialgo.first];
             auto idflagout = std::make_unique<ValueMap<int>>();
             ValueMap<int>::Filler idflagfiller(*idflagout);
             idflagfiller.insert(jetHandle,idflag.begin(),idflag.end());
             idflagfiller.fill();
             iEvent.put(std::move(idflagout),ialgo.first+"Id");
         }
     }
     // input variables
     if( produceJetIds_ ) {
         assert( jetHandle->size() == ids.size() );
         auto idsout = std::make_unique<ValueMap<StoredPileupJetIdentifier>>();
         ValueMap<StoredPileupJetIdentifier>::Filler idsfiller(*idsout);
         idsfiller.insert(jetHandle,ids.begin(),ids.end());
         idsfiller.fill();
         iEvent.put(std::move(idsout));
     }
 }