PileupJetIdProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    PileupJetIdProducer
// Class:      PileupJetIdProducer
// 
//
// Original Author:  Pasquale Musella,40 2-A12,+41227671706,
//         Created:  Wed Apr 18 15:48:47 CEST 2012
//
//

#include "RecoJets/JetProducers/plugins/PileupJetIdProducer.h"

GBRForestsAndConstants::GBRForestsAndConstants(edm::ParameterSet const& iConfig) :
  runMvas_(iConfig.getParameter<bool>("runMvas")),
  produceJetIds_(iConfig.getParameter<bool>("produceJetIds")),
  inputIsCorrected_(iConfig.getParameter<bool>("inputIsCorrected")),
  applyJec_(iConfig.getParameter<bool>("applyJec")),
  jec_(iConfig.getParameter<std::string>("jec")),
  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");
  for (auto const& algoPset : algos) {
    vAlgoGBRForestsAndConstants_.emplace_back(algoPset, runMvas_);
  }

  if (!runMvas_) {
    assert(algos.size() == 1);
  }
}

// ------------------------------------------------------------------------------------------
PileupJetIdProducer::PileupJetIdProducer(const edm::ParameterSet& iConfig, GBRForestsAndConstants const* globalCache)
{
    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()
{
}


// ------------------------------------------------------------------------------------------
void
PileupJetIdProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
    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));
    }
}



// ------------------------------------------------------------------------------------------
void
PileupJetIdProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
    //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)
{
    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_);
}
//define this as a plug-in
DEFINE_FWK_MODULE(PileupJetIdProducer);