#include <HLTBTagHarvestingAnalyzer.h>

Inheritance diagram for HLTBTagHarvestingAnalyzer:

Public Member Functions
TH1F	calculateEfficiency1D (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, TH1 &num, TH1 &den, std::string name)

virtual void	dqmEndJob (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter)

bool	GetNumDenumerators (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, std::string num, std::string den, TH1 &ptrnum, TH1 &ptrden, int type)

	HLTBTagHarvestingAnalyzer (const edm::ParameterSet &)

void	mistagrate (DQMStore::IBooker &ibooker, DQMStore::IGetter &igetter, TH1F num, TH1F den, std::string effName)

	~HLTBTagHarvestingAnalyzer ()

Public Member Functions inherited from DQMEDHarvester
virtual void	analyze (edm::Event const &, edm::EventSetup const &) final

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

virtual void	beginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDHarvester (void)

virtual void	dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	endJob () final

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

virtual void	endRun (edm::Run const &, edm::EventSetup const &)

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::WatchLuminosityBlocks, edm::one::SharedResources >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef unsigned int	flavour_t

typedef std::vector< flavour_t >	flavours_t

Private Attributes
std::map< std::string, MonitorElement * >	H1_

std::vector< std::string >	hltPathNames_

std::vector< std::string >	m_histoName

std::vector< flavours_t >	m_mcFlavours

std::vector< std::string >	m_mcLabels

bool	m_mcMatching

double	m_minTag

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Code used to produce DQM validation plots for b-tag at HLT. This class read the plots producted by HLTBTagPerformanceAnalyzer and make plots of: b-tag efficiency vs discr, b-tag efficiency vs jet pt, b-tag efficiency vs mistag rate

Definition at line 27 of file HLTBTagHarvestingAnalyzer.h.

Member Typedef Documentation

typedef unsigned int HLTBTagHarvestingAnalyzer::flavour_t

private

Definition at line 40 of file HLTBTagHarvestingAnalyzer.h.

typedef std::vector<flavour_t> HLTBTagHarvestingAnalyzer::flavours_t

private

Definition at line 41 of file HLTBTagHarvestingAnalyzer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 3 of file HLTBTagHarvestingAnalyzer.cc.

References edm::ParameterSet::getParameter(), hltPathNames_, m_histoName, m_mcLabels, and m_minTag.

 {
     //getParameter
     hltPathNames_           = iConfig.getParameter< std::vector<std::string> > ("HLTPathNames");
     edm::ParameterSet mc    = iConfig.getParameter<edm::ParameterSet>("mcFlavours");
     m_mcLabels              = mc.getParameterNamesForType<std::vector<unsigned int> >();
     m_histoName             = iConfig.getParameter<std::vector<std::string> >("histoName");
     m_minTag                = iConfig.getParameter<double>("minTag");
 }

HLTBTagHarvestingAnalyzer::~HLTBTagHarvestingAnalyzer ( )

Definition at line 13 of file HLTBTagHarvestingAnalyzer.cc.

14 {

15 }

Member Function Documentation

TH1F HLTBTagHarvestingAnalyzer::calculateEfficiency1D	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		TH1 &	num,
		TH1 &	den,
		std::string	name
	)

Definition at line 163 of file HLTBTagHarvestingAnalyzer.cc.

References DQMStore::IBooker::book1D(), ztail::d, alignCSCRings::e, i, gen::n, MonitorElement::setEfficiencyFlag(), and mathSSE::sqrt().

Referenced by dqmEndJob().

                                                                                                                                                    {
     //calculate the efficiency as num/den ratio
     TH1F eff;
     if(num.GetXaxis()->GetXbins()->GetSize()==0){
          eff = TH1F(effName.c_str(),effName.c_str(),num.GetXaxis()->GetNbins(),num.GetXaxis()->GetXmin(),num.GetXaxis()->GetXmax());
     }else{
         eff = TH1F(effName.c_str(),effName.c_str(),num.GetXaxis()->GetNbins(),num.GetXaxis()->GetXbins()->GetArray());
     } 
     eff.SetTitle(effName.c_str());
     eff.SetXTitle( num.GetXaxis()->GetTitle() );
     eff.SetYTitle("Efficiency");
     eff.SetOption("PE");
     eff.SetLineColor(2);
     eff.SetLineWidth(2);
     eff.SetMarkerStyle(20);
     eff.SetMarkerSize(0.8);
     eff.GetYaxis()->SetRangeUser(-0.001,1.001);
     for(int i=1;i<=num.GetNbinsX();i++){
         double d, n,err;
         d= den.GetBinContent(i);
         n= num.GetBinContent(i);
         double e;
         if(d!=0){
             e=n/d;
             err =  sqrt(e*(1-e)/d); //from binomial standard deviation
         }
         else{
             e=0;
             err=0;
         }       
         eff.SetBinContent( i, e );
         eff.SetBinError( i, err );
     }
     
     MonitorElement *me;
     me = ibooker.book1D(effName,&eff);
     me->setEfficiencyFlag();
     
     return eff;
 }

void HLTBTagHarvestingAnalyzer::dqmEndJob	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter
	)

virtual

for mc labels

save mistagrate vs b-eff plots

for triggers

Implements DQMEDHarvester.

Definition at line 19 of file HLTBTagHarvestingAnalyzer.cc.

References calculateEfficiency1D(), reco::flavour(), GetNumDenumerators(), hltPathNames_, i, diffTwoXMLs::label, edm::errors::LogicError, m_histoName, m_mcLabels, mistagrate(), NULL, pileupDistInMC::num, DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

 {
     using namespace edm;
     Exception excp(errors::LogicError);
     std::string dqmFolder_hist;
 
     //for each hltPath and for each flavour, do the "b-tag efficiency vs jet pt" and "b-tag efficiency vs mistag rate" plots
     for (unsigned int ind=0; ind<hltPathNames_.size();ind++) 
     {
         dqmFolder_hist = Form("HLT/BTag/Discriminator/%s",hltPathNames_[ind].c_str());
         std::string effDir = Form("HLT/BTag/Discriminator/%s/efficiency",hltPathNames_[ind].c_str());
         ibooker.setCurrentFolder(effDir);
         TH1 *den =NULL;
         TH1 *num =NULL; 
         std::map<TString,TH1F> effics;
         std::map<TString,bool> efficsOK;
         for (unsigned int i = 0; i < m_mcLabels.size(); ++i)
         {
             bool isOK=false;
             TString label= m_histoName.at(ind) + std::string("__"); //"JetTag__";
             TString flavour= m_mcLabels[i].c_str();
             label+=flavour;
             isOK=GetNumDenumerators(ibooker,igetter,(TString(dqmFolder_hist)+"/"+label).Data(),(TString(dqmFolder_hist)+"/"+label).Data(),num,den,0);
             if (isOK){
             
                 //do the 'b-tag efficiency vs discr' plot
                 effics[flavour]=calculateEfficiency1D(ibooker,igetter,*num,*den,(label+"_efficiency_vs_disc").Data());
                 efficsOK[flavour]=isOK;
             }
             label= m_histoName.at(ind)+std::string("___");
             label+=flavour+TString("_disc_pT");
             isOK=GetNumDenumerators (ibooker,igetter,(TString(dqmFolder_hist)+"/"+label).Data(),(TString(dqmFolder_hist)+"/"+label).Data(),num,den,1);
             if (isOK) {
             
                 //do the 'b-tag efficiency vs pT' plot
                 TH1F eff=calculateEfficiency1D(ibooker,igetter,*num,*den,(label+"_efficiency_vs_pT").Data());
             }
         } 
         
         if (efficsOK["b"] && efficsOK["c"])      mistagrate(ibooker,igetter,&effics["b"], &effics["c"], m_histoName.at(ind)+"_b_c_mistagrate" );
         if (efficsOK["b"] && efficsOK["light"])  mistagrate(ibooker,igetter,&effics["b"], &effics["light"], m_histoName.at(ind)+"_b_light_mistagrate" );
         if (efficsOK["b"] && efficsOK["g"])      mistagrate(ibooker,igetter,&effics["b"], &effics["g"], m_histoName.at(ind)+"_b_g_mistagrate" );
     } 
 }

bool HLTBTagHarvestingAnalyzer::GetNumDenumerators	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		std::string	num,
		std::string	den,
		TH1 *&	ptrnum,
		TH1 *&	ptrden,
		int	type
	)

numerator preparing

denominator preparing

Definition at line 65 of file HLTBTagHarvestingAnalyzer.cc.

References DQMStore::IGetter::get(), j, edm::errors::LogicError, m_minTag, NULL, and cms::Exception::raise().

Referenced by dqmEndJob().

 {
         using namespace edm;
 /*
    possible types: 
    type =0 for eff_vs_discriminator
    type =1 for eff_vs_pT ot eff_vs_Eta
  */
     MonitorElement *denME = NULL;
     MonitorElement *numME = NULL;
     denME = igetter.get(den);
     numME = igetter.get(num);
     Exception excp(errors::LogicError);
     
     if ( denME == NULL || numME == NULL ) 
     {
         excp << "Plots not found:\n";
         if(denME == NULL) excp << den << "\n";
         if(numME == NULL) excp << num << "\n";
         excp.raise();
     }
     
     if (type==0) //efficiency_vs_discr: fill "ptrnum" with the cumulative function of the DQM plots contained in "num" and "ptrden" with a flat function
     {
         TH1* numH1 = numME->getTH1();
         TH1* denH1 = denME->getTH1();
         ptrden=(TH1*)denH1->Clone("denominator");
         ptrnum=(TH1*)numH1->Clone("numerator");
 
         ptrnum->SetBinContent(1,numH1->Integral());
         ptrden->SetBinContent(1,numH1->Integral());
         for  (int j=2;j<=numH1->GetNbinsX();j++) {
             ptrnum->SetBinContent(j,numH1->Integral()-numH1->Integral(1,j-1));
             ptrden->SetBinContent(j,numH1->Integral());
         }
     }
     
     if (type==1) //efficiency_vs_pT: fill "ptrden" with projection of the plots contained in "den" and fill "ptrnum" with projection of the plots contained in "num", having btag>m_minTag
     {
         TH2F* numH2 = numME->getTH2F();
         TH2F* denH2 = denME->getTH2F();
 
         TCutG * cutg_num= new TCutG("cutg_num",4);
         cutg_num->SetPoint(0,m_minTag,0);
         cutg_num->SetPoint(1,m_minTag,9999);
         cutg_num->SetPoint(2,1.1,9999);
         cutg_num->SetPoint(3,1.1,0);
         ptrnum = numH2->ProjectionY("numerator",0,-1,"[cutg_num]");
 
         TCutG * cutg_den= new TCutG("cutg_den",4);
         cutg_den->SetPoint(0,-10.1,0);
         cutg_den->SetPoint(1,-10.1,9999);
         cutg_den->SetPoint(2,1.1,9999);
         cutg_den->SetPoint(3,1.1,0);
         ptrden = denH2->ProjectionY("denumerator",0,-1,"[cutg_den]");
         delete cutg_num;
         delete cutg_den;
     }
     return true;
 }

void HLTBTagHarvestingAnalyzer::mistagrate	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		TH1F *	num,
		TH1F *	den,
		std::string	effName
	)

Definition at line 129 of file HLTBTagHarvestingAnalyzer.cc.

References DQMStore::IBooker::book1D(), i, and MonitorElement::setEfficiencyFlag().

Referenced by dqmEndJob().

                                                                                                                                       {
     //do the efficiency_vs_mistag_rate plot
     TH1F* eff;
     eff = new TH1F(effName.c_str(),effName.c_str(),100,0,1);
     eff->SetTitle(effName.c_str());
     eff->SetXTitle("b-effficiency");
     eff->SetYTitle("mistag rate");
     eff->SetOption("E");
     eff->SetLineColor(2);
     eff->SetLineWidth(2);
     eff->SetMarkerStyle(20);
     eff->SetMarkerSize(0.8);
     eff->GetYaxis()->SetRangeUser(0.001,1.001);
     eff->GetXaxis()->SetRangeUser(-0.001,1.001);
     eff->SetStats(kFALSE);
     
     //for each bin in the discr -> find efficiency and mistagrate -> put them in a plot
     for(int i=1;i<=num->GetNbinsX();i++){
         double beff=num->GetBinContent(i);
         double miseff=den->GetBinContent(i);
         double miseffErr= den->GetBinError(i);
         int binX = eff->GetXaxis()->FindBin(beff);
         if (eff->GetBinContent(binX)!=0) continue;
         eff->SetBinContent(binX,miseff);
         eff->SetBinError(binX,miseffErr);
     }
     MonitorElement *me;
     me = ibooker.book1D(effName.c_str(),eff);
     me->setEfficiencyFlag();
 
     delete eff;
     return;
 }