Inheritance diagram for JetIDStudiesSelector:

Public Member Functions
vector< pat::Jet > const &	allCaloJets () const

vector< pat::Jet > const &	allPFJets () const

index_type const &	caloCuts () const

index_type const &	caloDeltaPhi () const

pat::Jet const &	caloJet0 () const

pat::Jet const &	caloJet1 () const

index_type const &	caloJetID () const

index_type const &	caloKin () const

	JetIDStudiesSelector (edm::ParameterSet const &caloJetIdParams, edm::ParameterSet const &pfJetIdParams, edm::ParameterSet const &params)

std::shared_ptr< JetIDSelectionFunctor > const &	jetSel () const

bool	operator() (edm::EventBase const &event, pat::strbitset &ret) override

index_type const &	pfCuts () const

index_type const &	pfDeltaPhi () const

pat::Jet const &	pfJet0 () const

pat::Jet const &	pfJet1 () const

index_type const &	pfJetID () const

std::shared_ptr< PFJetIDSelectionFunctor > const &	pfJetSel () const

index_type const &	pfKin () const

	~JetIDStudiesSelector () override

Protected Attributes
index_type	caloCuts_

index_type	caloDeltaPhi_

edm::Ptr< pat::Jet >	caloJet0_

edm::Ptr< pat::Jet >	caloJet1_

index_type	caloJetID_

index_type	caloKin_

edm::Handle< vector< pat::Jet > >	h_jets_

edm::Handle< vector< pat::Jet > >	h_pfjets_

std::shared_ptr< JetIDSelectionFunctor >	jetSel_

edm::InputTag	jetSrc_

index_type	pfCuts_

index_type	pfDeltaPhi_

edm::Ptr< pat::Jet >	pfJet0_

edm::Ptr< pat::Jet >	pfJet1_

index_type	pfJetID_

std::shared_ptr< PFJetIDSelectionFunctor >	pfJetSel_

edm::InputTag	pfJetSrc_

index_type	pfKin_

Detailed Description

Definition at line 55 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Constructor & Destructor Documentation

◆ JetIDStudiesSelector()

JetIDStudiesSelector::JetIDStudiesSelector	(	edm::ParameterSet const &	caloJetIdParams,
		edm::ParameterSet const &	pfJetIdParams,
		edm::ParameterSet const &	params
	)

inline

Definition at line 57 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

       : jetSel_(new JetIDSelectionFunctor(caloJetIdParams)),
         pfJetSel_(new PFJetIDSelectionFunctor(pfJetIdParams)),
         jetSrc_(params.getParameter<edm::InputTag>("jetSrc")),
         pfJetSrc_(params.getParameter<edm::InputTag>("pfJetSrc")) {
     bool useCalo = params.getParameter<bool>("useCalo");
  
     push_back("Calo Cuts");
     push_back("Calo Kin Cuts");
     push_back("Calo Delta Phi");
     push_back("Calo Jet ID");
     push_back("PF Cuts");
     push_back("PF Kin Cuts");
     push_back("PF Delta Phi");
     push_back("PF Jet ID");
  
     set("Calo Cuts", useCalo);
     set("Calo Kin Cuts", useCalo);
     set("Calo Delta Phi", useCalo);
     set("Calo Jet ID", useCalo);
     set("PF Cuts", !useCalo);
     set("PF Kin Cuts", !useCalo);
     set("PF Delta Phi", !useCalo);
     set("PF Jet ID", !useCalo);
  
     // Indices for fast caching
     caloCuts_ = index_type(&bits_, std::string("Calo Cuts"));
     caloKin_ = index_type(&bits_, std::string("Calo Kin Cuts"));
     caloDeltaPhi_ = index_type(&bits_, std::string("Calo Delta Phi"));
     caloJetID_ = index_type(&bits_, std::string("Calo Jet ID"));
     pfCuts_ = index_type(&bits_, std::string("PF Cuts"));
     pfKin_ = index_type(&bits_, std::string("PF Kin Cuts"));
     pfDeltaPhi_ = index_type(&bits_, std::string("PF Delta Phi"));
     pfJetID_ = index_type(&bits_, std::string("PF Jet ID"));
   }

References CalibrationSummaryClient_cfi::params, AlCaHLTBitMon_QueryRunRegistry::string, and HLT_FULL_cff::useCalo.

◆ ~JetIDStudiesSelector()

JetIDStudiesSelector::~JetIDStudiesSelector ( )

inlineoverride

Definition at line 95 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

95 {}

Member Function Documentation

◆ allCaloJets()

vector<pat::Jet> const& JetIDStudiesSelector::allCaloJets ( ) const

inline

Definition at line 165 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

165 { return *h_jets_; }

Referenced by main().

◆ allPFJets()

vector<pat::Jet> const& JetIDStudiesSelector::allPFJets ( ) const

inline

Definition at line 166 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

166 { return *h_pfjets_; }

Referenced by main().

◆ caloCuts()

index_type const& JetIDStudiesSelector::caloCuts ( ) const

inline

Definition at line 175 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

175 { return caloCuts_; }

◆ caloDeltaPhi()

index_type const& JetIDStudiesSelector::caloDeltaPhi ( ) const

inline

Definition at line 177 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

177 { return caloDeltaPhi_; }

Referenced by main().

◆ caloJet0()

pat::Jet const& JetIDStudiesSelector::caloJet0 ( ) const

inline

Definition at line 168 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

168 { return *caloJet0_; }

Referenced by main().

◆ caloJet1()

pat::Jet const& JetIDStudiesSelector::caloJet1 ( ) const

inline

Definition at line 169 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

169 { return *caloJet1_; }

Referenced by main().

◆ caloJetID()

index_type const& JetIDStudiesSelector::caloJetID ( ) const

inline

Definition at line 178 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

178 { return caloJetID_; }

Referenced by main().

◆ caloKin()

index_type const& JetIDStudiesSelector::caloKin ( ) const

inline

Definition at line 176 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

176 { return caloKin_; }

Referenced by main().

◆ jetSel()

std::shared_ptr<JetIDSelectionFunctor> const& JetIDStudiesSelector::jetSel ( ) const

inline

Definition at line 162 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

162 { return jetSel_; }

◆ operator()()

bool JetIDStudiesSelector::operator()	(	edm::EventBase const &	event,
		pat::strbitset &	ret
	)

inlineoverride

Definition at line 97 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

                                                                          {
     pat::strbitset retCaloJet = jetSel_->getBitTemplate();
     pat::strbitset retPFJet = pfJetSel_->getBitTemplate();
  
     if (considerCut(caloCuts_)) {
       passCut(ret, caloCuts_);
       event.getByLabel(jetSrc_, h_jets_);
       // Calo Cuts
       if (h_jets_->size() >= 2 || ignoreCut(caloKin_)) {
         passCut(ret, caloKin_);
         pat::Jet const& jet0 = h_jets_->at(0);
         pat::Jet const& jet1 = h_jets_->at(1);
         double dphi = fabs(deltaPhi<double>(jet0.phi(), jet1.phi()));
  
         if (fabs(dphi - TMath::Pi()) < 1.0 || ignoreCut(caloDeltaPhi_)) {
           passCut(ret, caloDeltaPhi_);
  
           retCaloJet.set(false);
           bool pass0 = (*jetSel_)(jet0, retCaloJet);
           retCaloJet.set(false);
           bool pass1 = (*jetSel_)(jet1, retCaloJet);
           if ((pass0 && pass1) || ignoreCut(caloJetID_)) {
             passCut(ret, caloJetID_);
             caloJet0_ = edm::Ptr<pat::Jet>(h_jets_, 0);
             caloJet1_ = edm::Ptr<pat::Jet>(h_jets_, 1);
  
             return (bool)ret;
           }  // end if found 2 "loose" jet ID jets
         }    // end if delta phi
       }      // end calo kin cuts
     }        // end if calo cuts
  
     if (considerCut(pfCuts_)) {
       passCut(ret, pfCuts_);
       event.getByLabel(pfJetSrc_, h_pfjets_);
       // PF Cuts
       if (h_pfjets_->size() >= 2 || ignoreCut(pfKin_)) {
         passCut(ret, pfKin_);
         pat::Jet const& jet0 = h_pfjets_->at(0);
         pat::Jet const& jet1 = h_pfjets_->at(1);
         double dphi = fabs(deltaPhi<double>(jet0.phi(), jet1.phi()));
  
         if (fabs(dphi - TMath::Pi()) < 1.0 || ignoreCut(pfDeltaPhi_)) {
           passCut(ret, pfDeltaPhi_);
  
           retPFJet.set(false);
           bool pass0 = (*pfJetSel_)(jet0, retPFJet);
           retPFJet.set(false);
           bool pass1 = (*pfJetSel_)(jet1, retPFJet);
           if ((pass0 && pass1) || ignoreCut(pfJetID_)) {
             passCut(ret, pfJetID_);
             pfJet0_ = edm::Ptr<pat::Jet>(h_pfjets_, 0);
             pfJet1_ = edm::Ptr<pat::Jet>(h_pfjets_, 1);
  
             return (bool)ret;
           }  // end if found 2 "loose" jet ID jets
         }    // end if delta phi
       }      // end pf kin cuts
     }        // end if pf cuts
  
     setIgnored(ret);
  
     return false;
   }  // end of method