Example class that can be used both within FWLite and within the full framework. More...

#include "PhysicsTools/UtilAlgos/interface/AnalysisTasksAnalyzerBTag.h"

Inheritance diagram for AnalysisTasksAnalyzerBTag:

Public Member Functions
	AnalysisTasksAnalyzerBTag (const edm::ParameterSet &cfg, TFileDirectory &fs)
	default constructor More...

void	analyze (const edm::EventBase &event)
	everything that needs to be done during the event loop More...

void	beginJob ()
	everything that needs to be done before the event loop More...

void	endJob ()
	everything that needs to be done after the event loop More...

virtual	~AnalysisTasksAnalyzerBTag ()
	default destructor More...

Public Member Functions inherited from edm::BasicAnalyzer
	BasicAnalyzer (const edm::ParameterSet &cfg, TFileDirectory &fileService)
	default constructor More...

virtual	~BasicAnalyzer ()
	default destructor More...

Private Attributes
unsigned int	bins_

std::string	bTagAlgo_

std::map< std::string, TH1 * >	hists_
	histograms More...

edm::InputTag	Jets_
	input tag for mouns More...

double	lowerbin_

bool	skip_

std::string	softMuonTagInfoLabel_

double	upperbin_

Detailed Description

Example class that can be used both within FWLite and within the full framework.

This is an example for keeping classes that can be used both within FWLite and within the full framework. The class is derived from the BasicAnalyzer base class, which is an interface for the two wrapper classes EDAnalyzerWrapper and FWLiteAnalyzerWrapper. The latter provides basic configuration file reading and event looping equivalent to the FWLiteHistograms executable of this package. You can see the FWLiteAnalyzerWrapper class at work in the FWLiteWithBasicAnalyzer executable of this package.

Definition at line 19 of file AnalysisTasksAnalyzerBTag.h.

Constructor & Destructor Documentation

AnalysisTasksAnalyzerBTag::AnalysisTasksAnalyzerBTag	(	const edm::ParameterSet &	cfg,
		TFileDirectory &	fs
	)

default constructor

Definition at line 8 of file AnalysisTasksAnalyzerBTag.cc.

References bins_, hists_, lowerbin_, TFileDirectory::make(), and upperbin_.

                                                                                                   : 
   edm::BasicAnalyzer::BasicAnalyzer(cfg, fs),
   Jets_(cfg.getParameter<edm::InputTag>("Jets")),
   bTagAlgo_(cfg.getParameter<std::string>("bTagAlgo")),
   bins_(cfg.getParameter<unsigned int>("bins")),
   lowerbin_(cfg.getParameter<double>("lowerbin")),
   upperbin_(cfg.getParameter<double>("upperbin"))
 {
   hists_["NumSoftMuons"] = fs.make<TH1F>("NumSoftMuons"  , "NumSoftMuons"  ,4,  -0.5, 3.5);
   hists_["BTag_b"] = fs.make<TH1F>("BTag_b"  , "BTag_b"  ,  bins_,  lowerbin_, upperbin_);
   hists_["BTag_g"] = fs.make<TH1F>("BTag_g" , "BTag_g" ,  bins_, lowerbin_,   upperbin_);
   hists_["BTag_c"] = fs.make<TH1F>("BTag_c" , "BTag_c" ,  bins_, lowerbin_,   upperbin_); 
   hists_["BTag_uds"] = fs.make<TH1F>("BTag_uds", "BTag_uds",   bins_, lowerbin_, upperbin_);
   hists_["BTag_other"] = fs.make<TH1F>("BTag_other", "BTag_other",   bins_, lowerbin_, upperbin_);
   hists_["effBTag_b"] = fs.make<TH1F>("effBTag_b"  , "effBTag_b"  ,  bins_,  lowerbin_, upperbin_);
   hists_["effBTag_g"] = fs.make<TH1F>("effBTag_g" , "effBTag_g" ,  bins_, lowerbin_,  upperbin_);
   hists_["effBTag_c"] = fs.make<TH1F>("effBTag_c" , "effBTag_c" ,  bins_, lowerbin_, upperbin_); 
   hists_["effBTag_uds"] = fs.make<TH1F>("effBTag_uds", "effBTag_uds",   bins_, lowerbin_, upperbin_);
   hists_["effBTag_other"] = fs.make<TH1F>("effBTag_other", "effBTag_other",  bins_, lowerbin_, upperbin_);
 }

AnalysisTasksAnalyzerBTag::~AnalysisTasksAnalyzerBTag ( )

virtual

default destructor

Definition at line 28 of file AnalysisTasksAnalyzerBTag.cc.

References bins_, hists_, and i.

 {
   for(unsigned int i=0; i< bins_; ++i){
    hists_["effBTag_b"]->SetBinContent(i,hists_["BTag_b"]->Integral(i,hists_["BTag_b"]->GetNbinsX()+1)/hists_["BTag_b"]->Integral(0,hists_["BTag_b"]->GetNbinsX()+1) );
    hists_["effBTag_g"]->SetBinContent(i,hists_["BTag_g"]->Integral(i,hists_["BTag_g"]->GetNbinsX()+1)/hists_["BTag_g"]->Integral(0,hists_["BTag_g"]->GetNbinsX()+1) );
    hists_["effBTag_c"]->SetBinContent(i,hists_["BTag_c"]->Integral(i,hists_["BTag_c"]->GetNbinsX()+1)/hists_["BTag_c"]->Integral(0,hists_["BTag_c"]->GetNbinsX()+1) );
    hists_["effBTag_uds"]->SetBinContent(i,hists_["BTag_uds"]->Integral(i,hists_["BTag_uds"]->GetNbinsX()+1)/hists_["BTag_uds"]->Integral(0,hists_["BTag_uds"]->GetNbinsX()+1) );
    hists_["effBTag_other"]->SetBinContent(i,hists_["BTag_other"]->Integral(i,hists_["BTag_other"]->GetNbinsX()+1)/hists_["BTag_other"]->Integral(0,hists_["BTag_other"]->GetNbinsX()+1) );
   } 
 }

Member Function Documentation

void AnalysisTasksAnalyzerBTag::analyze ( const edm::EventBase & event )

virtual

everything that needs to be done during the event loop

Implements edm::BasicAnalyzer.

Definition at line 40 of file AnalysisTasksAnalyzerBTag.cc.

References abs, pat::Jet::bDiscriminator(), bTagAlgo_, pat::Jet::getPairDiscri(), hists_, METSkim_cff::Jets, Jets_, and pat::Jet::partonFlavour().

 {
   // define what Jet you are using; this is necessary as FWLite is not 
   // capable of reading edm::Views
   using pat::Jet;
 
   // Handle to the Jet collection
   edm::Handle<std::vector<Jet> > Jets;
   event.getByLabel(Jets_, Jets);
 
   // loop Jet collection and fill histograms
   for(std::vector<Jet>::const_iterator Jet_it=Jets->begin(); Jet_it!=Jets->end(); ++Jet_it){
       edm::LogInfo ("hint3") << "\n \n investigate the next jet...\n \n "<<std::endl;
       pat::Jet Jet(*Jet_it);
 
       
       const std::vector< std::pair< std::string, float > > discrPairs = Jet.getPairDiscri();
       for(unsigned int pair_i = 0;pair_i <discrPairs.size(); ++pair_i ){
       edm::LogInfo ("hint3") << "discr name: "<< discrPairs[pair_i].first<<" value: "<< discrPairs[pair_i].second<<std::endl;
       }
       
       //Categorize the Jets
       if( abs(Jet.partonFlavour())==5){
       hists_["BTag_b"]->Fill(Jet.bDiscriminator(bTagAlgo_));
       }
       else{ 
       if( abs(Jet.partonFlavour())==21 || abs(Jet.partonFlavour())==9 ){
           hists_["BTag_g"]->Fill(Jet.bDiscriminator(bTagAlgo_));
       }
       else{
           if( abs(Jet.partonFlavour())==4){
           hists_["BTag_c"]->Fill(Jet.bDiscriminator(bTagAlgo_));
           }
           else{
           if( abs(Jet.partonFlavour())==1 || abs(Jet.partonFlavour())==2 || abs(Jet.partonFlavour())==3){
               hists_["BTag_uds"]->Fill(Jet.bDiscriminator(bTagAlgo_));
           }
           else{
               hists_["BTag_other"]->Fill(Jet.bDiscriminator(bTagAlgo_));
           }
           }
       }
       }
   }
 }