PileupJetIdProducer Class Reference

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

Inheritance diagram for PileupJetIdProducer:

Public Member Functions
	PileupJetIdProducer (const edm::ParameterSet &, GBRForestsAndConstants const *)
	~PileupJetIdProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< GBRForestsAndConstants > >
	EDProducer ()=default
bool	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
static void	globalEndJob (GBRForestsAndConstants *)
static std::unique_ptr< GBRForestsAndConstants >	initializeGlobalCache (edm::ParameterSet const &pset)

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

Private Attributes
std::vector< std::pair< std::string, std::unique_ptr< PileupJetIdAlgo > > >	algos_
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_
std::unique_ptr< FactorizedJetCorrector >	jecCor_
std::vector< JetCorrectorParameters >	jetCorPars_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< GBRForestsAndConstants > >
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

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 80 of file PileupJetIdProducer.h.

Constructor & Destructor Documentation

PileupJetIdProducer::PileupJetIdProducer ( const edm::ParameterSet &  iConfig, GBRForestsAndConstants const *  globalCache  )

explicit

Definition at line 44 of file PileupJetIdProducer.cc.

References edm::ParameterSet::getParameter(), diffTwoXMLs::label, GBRForestsAndConstants::produceJetIds(), GBRForestsAndConstants::runMvas(), AlCaHLTBitMon_QueryRunRegistry::string, and GBRForestsAndConstants::vAlgoGBRForestsAndConstants().

{
    if ( globalCache->produceJetIds() ) {
        produces<edm::ValueMap<StoredPileupJetIdentifier> > ("");
    }
    for (auto const& algoGBRForestsAndConstants : globalCache->vAlgoGBRForestsAndConstants()) {
        std::string const& label = algoGBRForestsAndConstants.label();
        algos_.emplace_back(label, std::make_unique<PileupJetIdAlgo>(&algoGBRForestsAndConstants));
        if ( globalCache->runMvas() ) {
            produces<edm::ValueMap<float> > (label+"Discriminant");
            produces<edm::ValueMap<int> > (label+"Id");
        }
    }

    input_jet_token_ = consumes<edm::View<reco::Jet> >(iConfig.getParameter<edm::InputTag>("jets"));
    input_vertex_token_ = consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertexes"));
    input_vm_pujetid_token_ = consumes<edm::ValueMap<StoredPileupJetIdentifier> >(iConfig.getParameter<edm::InputTag>("jetids"));
    input_rho_token_ = consumes<double>(iConfig.getParameter<edm::InputTag>("rho"));
}

PileupJetIdProducer::~PileupJetIdProducer ( )

override

Definition at line 67 of file PileupJetIdProducer.cc.

{
}

Member Function Documentation

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

static

Definition at line 231 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);
}

static void PileupJetIdProducer::globalEndJob ( GBRForestsAndConstants *  )

inlinestatic

Definition at line 91 of file PileupJetIdProducer.h.

{ }

static std::unique_ptr<GBRForestsAndConstants> PileupJetIdProducer::initializeGlobalCache ( edm::ParameterSet const &  pset )

inlinestatic

Definition at line 87 of file PileupJetIdProducer.h.

References muonDTDigis_cfi::pset.

                                                                                                  {
    return std::make_unique<GBRForestsAndConstants>(pset);
  }

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

private

Definition at line 242 of file PileupJetIdProducer.cc.

References DEFINE_FWK_MODULE, edm::FileInPath::fullPath(), edm::EventSetup::get(), GBRForestsAndConstants::jec(), GBRForestsAndConstants::residualsFromTxt(), and GBRForestsAndConstants::residualsTxt().

{
    GBRForestsAndConstants const* gc = globalCache();

    //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 && ! gc->residualsFromTxt() ) jecLevels.push_back("L2L3Residual");

    //check the corrector parameters needed according to the correction levels
    edm::ESHandle<JetCorrectorParametersCollection> parameters;
    iSetup.get<JetCorrectionsRecord>().get(gc->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 && gc->residualsFromTxt() ) {
        jetCorPars_.push_back(JetCorrectorParameters(gc->residualsTxt().fullPath()));
    }
    
    //instantiate the jet corrector
    jecCor_ = std::make_unique<FactorizedJetCorrector>(jetCorPars_);
}

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

overrideprivate

Definition at line 74 of file PileupJetIdProducer.cc.

References GBRForestsAndConstants::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(), photons_cff::ids, GBRForestsAndConstants::inputIsCorrected(), edm::EventBase::isRealData(), GBRForestsAndConstants::jec(), metsig::jet, reco::Jet::jetArea(), StoredPileupJetIdentifier::jetEta(), PileupJetIdentifier::jetPhi(), StoredPileupJetIdentifier::jetPt(), fwrapper::jets, eostools::move(), PileupJetIdentifier::mva(), DetachedQuadStep_cff::mva, RecoTauHPSTancTauProdcuer_cfi::mvas, reco::LeafCandidate::phi(), GBRForestsAndConstants::produceJetIds(), edm::Handle< T >::product(), reco::LeafCandidate::pt(), edm::Event::put(), edm::View< T >::refAt(), rho, GBRForestsAndConstants::runMvas(), Scenarios_cff::scale, PileupJetIdAlgo::set(), edm::View< T >::size(), hltMVAJetPuId_cff::vertexes, and badGlobalMuonTaggersAOD_cff::vtx.

{
    GBRForestsAndConstants const* gc = globalCache();

    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(  gc->produceJetIds() ) {
            iEvent.getByToken(input_vertex_token_, vertexHandle);
    }
    const VertexCollection & vertexes = *(vertexHandle.product());
    // input variables
    Handle<ValueMap<StoredPileupJetIdentifier> > vmap;
    if( ! gc->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( gc->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 = nullptr;
        if(ispat) {
            patjet=dynamic_cast<const pat::Jet *>(&jet);
            ispat = patjet != nullptr;
        }
        
        // Get jet energy correction
        float jec = 0.;
        if( gc->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 = gc->applyJec() && ( ispat || !gc->inputIsCorrected() );
        std::unique_ptr<reco::Jet> corrJet;
        
        if( applyJec ) {
            float scale = jec;
            if( ispat ) {
                corrJet.reset(new pat::Jet(patjet->correctedJet(0))) ;
            } else {
                corrJet.reset(dynamic_cast<reco::Jet *>( jet.clone() ));
            }
            corrJet->scaleEnergy(scale);
        }
        const reco::Jet * theJet = ( applyJec ? corrJet.get() : &jet );
    
        PileupJetIdentifier puIdentifier;
        if( gc->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( gc->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() );
            }
        }
    }
    
    // Produce the output value maps
    if( gc->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( gc->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));
    }
}

Member Data Documentation

std::vector<std::pair<std::string, std::unique_ptr<PileupJetIdAlgo> > > PileupJetIdProducer::algos_

private

Definition at line 99 of file PileupJetIdProducer.h.

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

private

Definition at line 104 of file PileupJetIdProducer.h.

edm::EDGetTokenT<double> PileupJetIdProducer::input_rho_token_

private

Definition at line 107 of file PileupJetIdProducer.h.

edm::EDGetTokenT<reco::VertexCollection> PileupJetIdProducer::input_vertex_token_

private

Definition at line 105 of file PileupJetIdProducer.h.

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

private

Definition at line 106 of file PileupJetIdProducer.h.

std::unique_ptr<FactorizedJetCorrector> PileupJetIdProducer::jecCor_

private

Definition at line 101 of file PileupJetIdProducer.h.

std::vector<JetCorrectorParameters> PileupJetIdProducer::jetCorPars_

private

Definition at line 102 of file PileupJetIdProducer.h.