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)

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

virtual 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

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

index_type const &	pfKin () const

virtual	~JetIDStudiesSelector ()

Public Member Functions inherited from EventSelector
const std::vector< std::string > &	description ()

	EventSelector ()

	EventSelector (const edm::ParameterSet &iConfig, edm::ConsumesCollector &&iC)

	EventSelector (const edm::ParameterSet &iConfig, edm::ConsumesCollector &iC)

const std::string &	name () const
	name of the module (from configuration) More...

virtual bool	select (const edm::Event &) const =0
	decision of the selector module More...

virtual	~EventSelector ()

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_

boost::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_

boost::shared_ptr < PFJetIDSelectionFunctor >	pfJetSel_

edm::InputTag	pfJetSrc_

index_type	pfKin_

Protected Attributes inherited from EventSelector
std::vector< std::string >	description_

std::string	name_

Detailed Description

Definition at line 57 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 59 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

References edm::ParameterSet::getParameter(), AlCaHLTBitMon_QueryRunRegistry::string, and PatBasicFWLiteJetAnalyzer_Selector_cfg::useCalo.

                                              :
     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"));
     
   }

virtual JetIDStudiesSelector::~JetIDStudiesSelector ( )

inlinevirtual

Definition at line 99 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

99 {}

Member Function Documentation

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

inline

Definition at line 178 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

178 { return *h_jets_; }

JetIDStudiesSelector::h_jets_

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

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:205

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

inline

Definition at line 179 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

179 { return *h_pfjets_; }

JetIDStudiesSelector::h_pfjets_

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

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:206

index_type const& JetIDStudiesSelector::caloCuts ( ) const

inline

Definition at line 189 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

189 {return caloCuts_;}

JetIDStudiesSelector::caloCuts_

index_type caloCuts_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:215

index_type const& JetIDStudiesSelector::caloDeltaPhi ( ) const

inline

Definition at line 191 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

191 {return caloDeltaPhi_;}

JetIDStudiesSelector::caloDeltaPhi_

index_type caloDeltaPhi_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:217

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

inline

Definition at line 181 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

181 { return *caloJet0_; }

JetIDStudiesSelector::caloJet0_

edm::Ptr< pat::Jet > caloJet0_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:208

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

inline

Definition at line 182 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

182 { return *caloJet1_; }

JetIDStudiesSelector::caloJet1_

edm::Ptr< pat::Jet > caloJet1_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:209

index_type const& JetIDStudiesSelector::caloJetID ( ) const

inline

Definition at line 192 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

192 {return caloJetID_;}

JetIDStudiesSelector::caloJetID_

index_type caloJetID_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:218

index_type const& JetIDStudiesSelector::caloKin ( ) const

inline

Definition at line 190 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

Referenced by main().

190 {return caloKin_;}

JetIDStudiesSelector::caloKin_

index_type caloKin_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:216

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

inline

Definition at line 175 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

175 { return jetSel_;}

JetIDStudiesSelector::jetSel_

boost::shared_ptr< JetIDSelectionFunctor > jetSel_

Definition: PatBasicFWLiteJetAnalyzer_Selector.cc:200

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

inlineoverridevirtual

Definition at line 101 of file PatBasicFWLiteJetAnalyzer_Selector.cc.

References reco::LeafCandidate::phi(), Pi, run_regression::ret, and pat::strbitset::set().

                                                                                    {
 
     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