Inheritance diagram for MVAJetPuIdProducer:

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

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

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, MVAJetPuId * > >	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_

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

Detailed Description

Definition at line 24 of file MVAJetPuIdProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 54 of file MVAJetPuIdProducer.cc.

References jets_cff::algos, algos_, applyJec_, edm::ParameterSet::getParameter(), input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, inputIsCorrected_, jec_, jecCor_, jetids_, jets_, 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");
      
      jecCor_ = nullptr;
  
      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_.push_back( std::make_pair(label,new MVAJetPuId(*it)) );
          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_); 
  
  }

Member Function Documentation

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

static

Definition at line 211 of file MVAJetPuIdProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addVPSet(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<bool>("runMvas", true);
   desc.add<bool>("inputIsCorrected", true);
   desc.add<edm::InputTag>("vertexes", edm::InputTag("hltPixelVertices"));
   desc.add<bool>("produceJetIds", true);
   desc.add<std::string>("jec", "AK4PF");
   desc.add<bool>("residualsFromTxt", false);
   desc.add<bool>("applyJec", false);
   desc.add<edm::InputTag>("jetids", edm::InputTag(""));
   desc.add<edm::InputTag>("rho", edm::InputTag("hltFixedGridRhoFastjetAll"));
   desc.add<edm::InputTag>("jets", edm::InputTag("hltAK4PFJetsCorrected"));
     edm::ParameterSetDescription vpsd1;
     vpsd1.add<std::vector<std::string>>("tmvaVariables", {
       "rho",
       "nParticles",
       "nCharged",
       "majW",
       "minW",
       "frac01",
       "frac02",
       "frac03",
       "frac04",
       "ptD",
       "beta",
       "betaStar",
       "dR2Mean",
       "pull",
       "jetR",
       "jetRchg",
     });
     vpsd1.add<std::string>("tmvaMethod", "JetID");
     vpsd1.add<bool>("cutBased", false);
     vpsd1.add<std::string>("tmvaWeights", "RecoJets/JetProducers/data/MVAJetPuID.weights.xml.gz");
     vpsd1.add<std::vector<std::string>>("tmvaSpectators", {
       "jetEta",
       "jetPt",
     });
     vpsd1.add<std::string>("label", "CATEv0");
     vpsd1.add<int>("version", -1);
     {
       edm::ParameterSetDescription psd0;
       psd0.add<std::vector<double>>("Pt2030_Tight", {
         0.73,
         0.05,
         -0.26,
         -0.42,
       });
       psd0.add<std::vector<double>>("Pt2030_Loose", {
         -0.63,
         -0.6,
         -0.55,
         -0.45,
       });
       psd0.add<std::vector<double>>("Pt3050_Medium", {
         0.1,
         -0.36,
         -0.54,
         -0.54,
       });
       psd0.add<std::vector<double>>("Pt1020_Tight", {
         -0.83,
         -0.81,
         -0.74,
         -0.81,
       });
       psd0.add<std::vector<double>>("Pt2030_Medium", {
         0.1,
         -0.36,
         -0.54,
         -0.54,
       });
       psd0.add<std::vector<double>>("Pt010_Tight", {
         -0.83,
         -0.81,
         -0.74,
         -0.81,
       });
       psd0.add<std::vector<double>>("Pt1020_Loose", {
         -0.95,
         -0.96,
         -0.94,
         -0.95,
       });
       psd0.add<std::vector<double>>("Pt010_Medium", {
         -0.83,
         -0.92,
         -0.9,
         -0.92,
       });
       psd0.add<std::vector<double>>("Pt1020_Medium", {
         -0.83,
         -0.92,
         -0.9,
         -0.92,
       });
       psd0.add<std::vector<double>>("Pt010_Loose", {
         -0.95,
         -0.96,
         -0.94,
         -0.95,
       });
       psd0.add<std::vector<double>>("Pt3050_Loose", {
         -0.63,
         -0.6,
         -0.55,
         -0.45,
       });
       psd0.add<std::vector<double>>("Pt3050_Tight", {
         0.73,
         0.05,
         -0.26,
         -0.42,
       });
       vpsd1.add<edm::ParameterSetDescription>("JetIdParams", psd0);
     }
     vpsd1.add<double>("impactParTkThreshold", 1.0);
     std::vector<edm::ParameterSet> temp1;
     temp1.reserve(1);
 
     desc.addVPSet("algos", vpsd1, temp1);
 
   descriptions.add("MVAJetPuIdProducer", desc);
 
  }

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

private

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

overrideprivate

Definition at line 94 of file MVAJetPuIdProducer.cc.

References algos_, jets_cff::applyJec, applyJec_, reco::CompositePtrCandidate::clone(), MVAJetPuId::computeIdVariables(), MVAJetPuId::computeMva(), reco::LeafCandidate::eta(), edm::Event::getByToken(), FactorizedJetCorrector::getCorrection(), mps_fire::i, input_jet_token_, input_rho_token_, input_vertex_token_, input_vm_pujetid_token_, inputIsCorrected_, patTestJEC_cfi::jec, jecCor_, metsig::jet, reco::Jet::jetArea(), StoredPileupJetIdentifier::jetEta(), PileupJetIdentifier::jetPhi(), StoredPileupJetIdentifier::jetPt(), fwrapper::jets, eostools::move(), DetachedQuadStep_cff::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(), MVAJetPuId::set(), FactorizedJetCorrector::setJetA(), FactorizedJetCorrector::setJetEta(), FactorizedJetCorrector::setJetPt(), FactorizedJetCorrector::setRho(), edm::View< T >::size(), jets_cff::vertexes, and badGlobalMuonTaggersAOD_cff::vtx.

  {
      using namespace edm;
      using namespace std;
      using namespace reco;
      
      Handle<View<Jet> > jetHandle;
      iEvent.getByToken(input_jet_token_,jetHandle);
      const View<Jet> & jets = *jetHandle;
      Handle<VertexCollection> vertexHandle;
      if(  produceJetIds_ ) {
              iEvent.getByToken(input_vertex_token_, vertexHandle);
      }
      const VertexCollection & vertexes = *(vertexHandle.product());
      Handle<ValueMap<StoredPileupJetIdentifier> > vmap;
      if( ! produceJetIds_ ) {
          iEvent.getByToken(input_vm_pujetid_token_, vmap);
      }
      edm::Handle< double > rhoH;
      double rho = 0.;
      
      vector<StoredPileupJetIdentifier> ids; 
      map<string, vector<float> > mvas;
      map<string, vector<int> > idflags;
  
      VertexCollection::const_iterator vtx;
      if( produceJetIds_ ) {
          vtx = vertexes.begin();
          while( vtx != vertexes.end() && ( vtx->isFake() || vtx->ndof() < 4 ) ) {
              ++vtx;
          }
          if( vtx == vertexes.end() ) { vtx = vertexes.begin(); }
     }
     
     for ( unsigned int i=0; i<jets.size(); ++i ) {
         vector<pair<string,MVAJetPuId *> >::iterator algoi = algos_.begin();
         MVAJetPuId * ialgo = algoi->second;
         
         const Jet & jet = jets[i];
          
          float jec = 0.;
          if( applyJec_ ) {
              if( rho == 0. ) {
                  iEvent.getByToken(input_rho_token_,rhoH);
                  rho = *rhoH;
              }
              jecCor_->setJetPt(jet.pt());
              jecCor_->setJetEta(jet.eta());
              jecCor_->setJetA(jet.jetArea());
              jecCor_->setRho(rho);
              jec = jecCor_->getCorrection();
          }
          
          bool applyJec = applyJec_ || !inputIsCorrected_;
          reco::Jet * corrJet = nullptr;
          if( applyJec ) {
              float scale = jec;
                          corrJet = dynamic_cast<reco::Jet *>( jet.clone() );
              corrJet->scaleEnergy(scale);
          }
          const reco::Jet * theJet = ( applyJec ? corrJet : &jet );
          PileupJetIdentifier puIdentifier;
          if( produceJetIds_ ) {
              puIdentifier = ialgo->computeIdVariables(theJet, jec,  &(*vtx), vertexes, runMvas_);
              ids.push_back( puIdentifier );
          } else {
              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_ ) {
              for( ; algoi!=algos_.end(); ++algoi) {
                  ialgo = algoi->second;
                  ialgo->set(puIdentifier);
                  PileupJetIdentifier id = ialgo->computeMva();
                  mvas[algoi->first].push_back( id.mva() );
                  idflags[algoi->first].push_back( id.idFlag() );
              }
          }
          
          if( corrJet ) { delete corrJet; }
      }
      
      if( runMvas_ ) {
          for(vector<pair<string,MVAJetPuId *> >::iterator ialgo = algos_.begin(); ialgo!=algos_.end(); ++ialgo) {
              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");
              
              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");
          }
      }
      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));
      }
  }