#include <BTagPerformanceAnalyzerMC.h>

Inheritance diagram for BTagPerformanceAnalyzerMC:

Classes
struct	JetRefCompare

Public Member Functions
virtual void	analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup)

	BTagPerformanceAnalyzerMC (const edm::ParameterSet &pSet)

virtual void	endJob ()

	~BTagPerformanceAnalyzerMC ()

Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()

std::string	workerType () const

virtual	~EDAnalyzer ()

Private Types
typedef std::map < edm::RefToBase< reco::Jet > , unsigned int, JetRefCompare >	FlavourMap

typedef std::pair< reco::Jet, reco::JetFlavour >	JetWithFlavour

typedef std::map < edm::RefToBase< reco::Jet > , reco::JetFlavour::Leptons, JetRefCompare >	LeptonMap

Private Member Functions
void	bookHistos (const edm::ParameterSet &pSet)

EtaPtBin	getEtaPtBin (const int &iEta, const int &iPt)

bool	getJetWithFlavour (edm::RefToBase< reco::Jet > caloRef, FlavourMap flavours, JetWithFlavour &jetWithFlavour, const edm::EventSetup &es)

Private Attributes
bool	allHisto

std::vector< std::vector < JetTagPlotter * > >	binJetTagPlotters

std::vector< std::vector < TagCorrelationPlotter * > >	binTagCorrelationPlotters

std::vector< std::vector < BaseTagInfoPlotter * > >	binTagInfoPlotters

std::map< BaseTagInfoPlotter *, size_t >	binTagInfoPlottersToModuleConfig

std::vector< std::vector < BTagDifferentialPlot * > >	differentialPlots

bool	electronPlots

std::string	epsBaseName

std::vector< double >	etaRanges

bool	eventInitialized

bool	finalize

bool	finalizeOnly

std::string	inputFile

CorrectJet	jetCorrector

MatchJet	jetMatcher

edm::InputTag	jetMCSrc

AcceptJet	jetSelector

std::vector< edm::InputTag >	jetTagInputTags

bool	makeDiffPlots_

bool	mcPlots_

std::vector< edm::ParameterSet >	moduleConfig

bool	muonPlots

bool	partonKinematics

bool	produceEps

bool	producePs

std::string	psBaseName

double	ptPartonMax

double	ptPartonMin

std::vector< double >	ptRanges

edm::InputTag	slInfoTag

std::vector< std::pair < edm::InputTag, edm::InputTag > >	tagCorrelationInputTags

std::vector< std::vector < edm::InputTag > >	tagInfoInputTags

bool	tauPlots

std::vector< std::string >	tiDataFormatType

bool	update

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

typedef WorkerT< EDAnalyzer >	WorkerType

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

Detailed Description

Top level steering routine for b tag performance analysis.

Definition at line 45 of file BTagPerformanceAnalyzerMC.h.

Member Typedef Documentation

typedef std::map<edm::RefToBase<reco::Jet>, unsigned int, JetRefCompare> BTagPerformanceAnalyzerMC::FlavourMap

private

Definition at line 68 of file BTagPerformanceAnalyzerMC.h.

typedef std::pair<reco::Jet, reco::JetFlavour> BTagPerformanceAnalyzerMC::JetWithFlavour

private

Definition at line 67 of file BTagPerformanceAnalyzerMC.h.

typedef std::map<edm::RefToBase<reco::Jet>, reco::JetFlavour::Leptons, JetRefCompare> BTagPerformanceAnalyzerMC::LeptonMap

private

Definition at line 69 of file BTagPerformanceAnalyzerMC.h.

Constructor & Destructor Documentation

BTagPerformanceAnalyzerMC::BTagPerformanceAnalyzerMC ( const edm::ParameterSet & pSet )

explicit

Definition at line 19 of file BTagPerformanceAnalyzerMC.cc.

References bookHistos(), electronPlots, edm::ParameterSet::getParameter(), jetMatcher, muonPlots, MatchJet::setThreshold(), and tauPlots.

                                                                                 :
   partonKinematics(pSet.getParameter< bool >("partonKinematics")),
   ptPartonMin(pSet.getParameter<double>("ptPartonMin")),
   ptPartonMax(pSet.getParameter<double>("ptPartonMax")),
   jetSelector(
     pSet.getParameter<double>("etaMin"),
     pSet.getParameter<double>("etaMax"),
     pSet.getParameter<double>("ptRecJetMin"),
     pSet.getParameter<double>("ptRecJetMax"),
     0.0, 99999.0,
     pSet.getParameter<double>("ratioMin"),
     pSet.getParameter<double>("ratioMax")
   ),
   etaRanges(pSet.getParameter< vector<double> >("etaRanges")),
   ptRanges(pSet.getParameter< vector<double> >("ptRanges")),
   produceEps(pSet.getParameter< bool >("produceEps")),
   producePs(pSet.getParameter< bool >("producePs")),
   inputFile(pSet.getParameter<std::string>( "inputfile" )),
   update(pSet.getParameter<bool>( "update" )),
   allHisto(pSet.getParameter<bool>( "allHistograms" )),
   finalize(pSet.getParameter< bool >("finalizePlots")),
   finalizeOnly(pSet.getParameter< bool >("finalizeOnly")),
   jetMCSrc(pSet.getParameter<edm::InputTag>("jetMCSrc")),
   slInfoTag(pSet.getParameter<edm::InputTag>("softLeptonInfo")),
   moduleConfig(pSet.getParameter< vector<edm::ParameterSet> >("tagConfig")),
   mcPlots_(pSet.getParameter< bool >("mcPlots")),
   makeDiffPlots_(pSet.getParameter< bool >("differentialPlots")),
   jetCorrector(pSet.getParameter<std::string>("jetCorrection")),
   jetMatcher(pSet.getParameter<edm::ParameterSet>("recJetMatching"))
 {
   double ptRecJetMin = pSet.getParameter<double>("ptRecJetMin");
   jetMatcher.setThreshold(0.25 * ptRecJetMin);
   switch(pSet.getParameter<unsigned int>("leptonPlots")) {
     case 11: electronPlots = true; muonPlots = false; tauPlots = false; break;
     case 13: muonPlots = true; electronPlots = false; tauPlots = false; break;
     case 15: tauPlots = true; electronPlots = false; tauPlots = false; break;
     default: electronPlots = false; muonPlots = false; tauPlots = false;
   }
   bookHistos(pSet);
 }

BTagPerformanceAnalyzerMC::~BTagPerformanceAnalyzerMC ( )

Definition at line 234 of file BTagPerformanceAnalyzerMC.cc.

References binJetTagPlotters, binTagCorrelationPlotters, binTagInfoPlotters, differentialPlots, finalize, makeDiffPlots_, and mcPlots_.

 {
   for (vector<vector<JetTagPlotter*> >::iterator iJetLabel = binJetTagPlotters.begin();
        iJetLabel != binJetTagPlotters.end(); ++iJetLabel) 
     for (vector<JetTagPlotter*>::iterator iPlotter = iJetLabel->begin(); iPlotter != iJetLabel->end(); ++iPlotter) 
       delete *iPlotter;
 
   if (finalize  && mcPlots_ && makeDiffPlots_) {
     for(vector<vector<BTagDifferentialPlot*> >::iterator iJetLabel = differentialPlots.begin();
         iJetLabel != differentialPlots.end(); ++iJetLabel)
       for (vector<BTagDifferentialPlot *>::iterator iPlotter = iJetLabel->begin();
            iPlotter != iJetLabel->end(); ++ iPlotter) 
     delete *iPlotter;
   }
 
   for (vector<vector<TagCorrelationPlotter*> >::iterator iJetLabel = binTagCorrelationPlotters.begin(); 
        iJetLabel != binTagCorrelationPlotters.end(); ++iJetLabel) 
     for (vector<TagCorrelationPlotter* >::iterator iPlotter = iJetLabel->begin(); iPlotter != iJetLabel->end(); ++iPlotter) 
       delete *iPlotter;
     
   
   for (vector<vector<BaseTagInfoPlotter*> >::iterator iJetLabel = binTagInfoPlotters.begin(); 
        iJetLabel != binTagInfoPlotters.end(); ++iJetLabel) 
     for (vector<BaseTagInfoPlotter*>::iterator iPlotter = iJetLabel->begin(); iPlotter != iJetLabel->end(); ++iPlotter) 
       delete *iPlotter;
     
 }

Member Function Documentation

void BTagPerformanceAnalyzerMC::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

virtual

needed for lepton specific plots

Implements edm::EDAnalyzer.

Definition at line 262 of file BTagPerformanceAnalyzerMC.cc.

References abs, edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::begin(), binJetTagPlotters, binTagCorrelationPlotters, binTagInfoPlotters, binTagInfoPlottersToModuleConfig, metsig::electron, electronPlots, edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::end(), eventInitialized, edm::hlt::Exception, finalizeOnly, edm::Event::getByLabel(), getJetWithFlavour(), edm::ProductID::id(), reco::BaseTagInfo::jet(), jetMCSrc, jetSelector, jetTagInputTags, reco_calib_source_client_cfg::labels, EgammaValidation_Wenu_cff::leptons, LogDebug, moduleConfig, metsig::muon, muonPlots, partonKinematics, edm::Handle< T >::product(), edm::AssociationVector< KeyRefProd, CVal, KeyRef, SizeType, KeyReferenceHelper >::size(), findQualityFiles::size, slInfoTag, tagCorrelationInputTags, tagInfoInputTags, BaseTagInfoPlotter::tagInfoRequirements(), metsig::tau, tauPlots, and tiDataFormatType.

 {
   eventInitialized = false;
 
   if (finalizeOnly) return;
 
   edm::Handle<JetFlavourMatchingCollection> jetMC;
   FlavourMap flavours;
   LeptonMap leptons;
 
   iEvent.getByLabel(jetMCSrc, jetMC);
   for (JetFlavourMatchingCollection::const_iterator iter = jetMC->begin();
        iter != jetMC->end(); ++iter) {
     unsigned int fl = std::abs(iter->second.getFlavour());
     flavours.insert(std::make_pair(iter->first, fl));
     const reco::JetFlavour::Leptons &lep = iter->second.getLeptons();
     leptons.insert(std::make_pair(iter->first, lep));
   }
 
   edm::Handle<reco::SoftLeptonTagInfoCollection> infoHandle;
   iEvent.getByLabel(slInfoTag, infoHandle);
 
 // Look first at the jetTags
 
   for (unsigned int iJetLabel = 0; iJetLabel != jetTagInputTags.size(); ++iJetLabel) {
     edm::Handle<reco::JetTagCollection> tagHandle;
     iEvent.getByLabel(jetTagInputTags[iJetLabel], tagHandle);
     const reco::JetTagCollection & tagColl = *(tagHandle.product());
     LogDebug("Info") << "Found " << tagColl.size() << " B candidates in collection " << jetTagInputTags[iJetLabel];
 
     int plotterSize =  binJetTagPlotters[iJetLabel].size();
     for (JetTagCollection::const_iterator tagI = tagColl.begin();
      tagI != tagColl.end(); ++tagI) {
       // Identify parton associated to jet.
 
       if (flavours[tagI->first] == 5 &&
           ((electronPlots && !leptons[tagI->first].electron) ||
            (muonPlots && !leptons[tagI->first].muon) ||
            (tauPlots && !leptons[tagI->first].tau)))
         continue;
 
       JetWithFlavour jetWithFlavour;
       if (!getJetWithFlavour(tagI->first, flavours, jetWithFlavour, iSetup))
         continue;
       if (!jetSelector(jetWithFlavour.first, std::abs(jetWithFlavour.second.getFlavour()), infoHandle))
         continue;
 
       for (int iPlotter = 0; iPlotter != plotterSize; ++iPlotter) {
           bool inBin = false;
           if (partonKinematics)
                 inBin = binJetTagPlotters[iJetLabel][iPlotter]->etaPtBin().inBin(jetWithFlavour.second.getLorentzVector().Eta(),
                                                                                  jetWithFlavour.second.getLorentzVector().Pt());
           else
                 inBin = binJetTagPlotters[iJetLabel][iPlotter]->etaPtBin().inBin(jetWithFlavour.first);
           // Fill histograms if in desired pt/rapidity bin.
           if (inBin)
             binJetTagPlotters[iJetLabel][iPlotter]->analyzeTag(jetWithFlavour.first, tagI->second, std::abs(jetWithFlavour.second.getFlavour()));
       }
     }
   }
 
 // Now look at Tag Correlations
   for (unsigned int iJetLabel = 0; iJetLabel != tagCorrelationInputTags.size(); ++iJetLabel) {
     const std::pair<edm::InputTag, edm::InputTag>& inputTags = tagCorrelationInputTags[iJetLabel];
     edm::Handle<reco::JetTagCollection> tagHandle1;
     iEvent.getByLabel(inputTags.first, tagHandle1);
     const reco::JetTagCollection& tagColl1 = *(tagHandle1.product());
 
     edm::Handle<reco::JetTagCollection> tagHandle2;
     iEvent.getByLabel(inputTags.second, tagHandle2);
     const reco::JetTagCollection& tagColl2 = *(tagHandle2.product());
 
     int plotterSize = binTagCorrelationPlotters[iJetLabel].size();
     for (JetTagCollection::const_iterator tagI = tagColl1.begin(); tagI != tagColl1.end(); ++tagI) {
       
       if (flavours[tagI->first] == 5 &&
           ((electronPlots && !leptons[tagI->first].electron) ||
            (muonPlots && !leptons[tagI->first].muon) ||
            (tauPlots && !leptons[tagI->first].tau)))
         continue;
 
       JetWithFlavour jetWithFlavour;
       if (!getJetWithFlavour(tagI->first, flavours, jetWithFlavour, iSetup))
         continue;
       if (!jetSelector(jetWithFlavour.first, std::abs(jetWithFlavour.second.getFlavour()), infoHandle))
         continue;
 
       for(int iPlotter = 0; iPlotter != plotterSize; ++iPlotter) {
         bool inBin = false;
         if (partonKinematics)
           inBin = binTagCorrelationPlotters[iJetLabel][iPlotter]->etaPtBin().inBin(jetWithFlavour.second.getLorentzVector().Eta(),
                                                                                    jetWithFlavour.second.getLorentzVector().Pt());
 
         else
           inBin = binTagCorrelationPlotters[iJetLabel][iPlotter]->etaPtBin().inBin(jetWithFlavour.first);
 
         if(inBin)
         {
           double discr2 = tagColl2[tagI->first];
           binTagCorrelationPlotters[iJetLabel][iPlotter]->analyzeTags(tagI->second, discr2, std::abs(jetWithFlavour.second.getFlavour()));
         }
       }
     }
   }
 
 // Now look at the TagInfos
 
   for (unsigned int iJetLabel = 0; iJetLabel != tiDataFormatType.size(); ++iJetLabel) {
     int plotterSize = binTagInfoPlotters[iJetLabel].size();
     for (int iPlotter = 0; iPlotter != plotterSize; ++iPlotter)
       binTagInfoPlotters[iJetLabel][iPlotter]->setEventSetup(iSetup);
 
     vector<edm::InputTag> & inputTags = tagInfoInputTags[iJetLabel];
     if (inputTags.empty()) {
       // deferred retrieval of input tags
       BaseTagInfoPlotter *firstPlotter = binTagInfoPlotters[iJetLabel][0];
       int iModule = binTagInfoPlottersToModuleConfig[firstPlotter];
       vector<string> labels = firstPlotter->tagInfoRequirements();
       if (labels.empty())
         labels.push_back("label");
       for (vector<string>::const_iterator iLabels = labels.begin();
            iLabels != labels.end(); ++iLabels) {
         edm::InputTag inputTag =
             moduleConfig[iModule].getParameter<InputTag>(*iLabels);
         inputTags.push_back(inputTag);
       }
     }
 
     unsigned int nInputTags = inputTags.size();
     vector< edm::Handle< View<BaseTagInfo> > > tagInfoHandles(nInputTags);
     edm::ProductID jetProductID;
     unsigned int nTagInfos = 0;
     for (unsigned int iInputTags = 0; iInputTags < inputTags.size(); ++iInputTags) {
       edm::Handle< View<BaseTagInfo> > & tagInfoHandle = tagInfoHandles[iInputTags];
       iEvent.getByLabel(inputTags[iInputTags], tagInfoHandle);
       unsigned int size = tagInfoHandle->size();
       LogDebug("Info") << "Found " << size << " B candidates in collection " << inputTags[iInputTags];
 
       edm::ProductID thisProductID = (size > 0) ? (*tagInfoHandle)[0].jet().id() : edm::ProductID();
       if (iInputTags == 0) {
         jetProductID = thisProductID;
         nTagInfos = size;
       } else if (jetProductID != thisProductID)
         throw cms::Exception("Configuration") << "TagInfos are referencing a different jet collection." << endl;
       else if (nTagInfos != size)
         throw cms::Exception("Configuration") << "TagInfo collections are having a different size." << endl;
     }
 
     for (unsigned int iTagInfos = 0; iTagInfos < nTagInfos; ++iTagInfos) {
       vector<const BaseTagInfo*> baseTagInfos(nInputTags);
       edm::RefToBase<Jet> jetRef;
       for (unsigned int iTagInfo = 0; iTagInfo < nInputTags; iTagInfo++) {
         const BaseTagInfo &baseTagInfo = (*tagInfoHandles[iTagInfo])[iTagInfos];
         if (iTagInfo == 0)
           jetRef = baseTagInfo.jet();
         else if (baseTagInfo.jet() != jetRef)
           throw cms::Exception("Configuration") << "TagInfos pointing to different jets." << endl;
         baseTagInfos[iTagInfo] = &baseTagInfo;
       }
 
       // Identify parton associated to jet.
 
       if (flavours[jetRef] == 5 &&
           ((electronPlots && !leptons[jetRef].electron) ||
            (muonPlots && !leptons[jetRef].muon) ||
            (tauPlots && !leptons[jetRef].tau)))
          continue;
 
       JetWithFlavour jetWithFlavour;
       if (!getJetWithFlavour(jetRef, flavours, jetWithFlavour, iSetup))
         continue;
       if (!jetSelector(jetWithFlavour.first, std::abs(jetWithFlavour.second.getFlavour()), infoHandle))
         continue;
 
       for (int iPlotter = 0; iPlotter != plotterSize; ++iPlotter) {
           bool inBin = false;
           if (partonKinematics)
                inBin = binTagInfoPlotters[iJetLabel][iPlotter]->etaPtBin().inBin(jetWithFlavour.second.getLorentzVector().Eta(),
                                                                                  jetWithFlavour.second.getLorentzVector().Pt());
           else
                inBin = binTagInfoPlotters[iJetLabel][iPlotter]->etaPtBin().inBin(*jetRef);
           // Fill histograms if in desired pt/rapidity bin.
           if (inBin)
             binTagInfoPlotters[iJetLabel][iPlotter]->analyzeTag(baseTagInfos, std::abs(jetWithFlavour.second.getFlavour()));
       }
     }
   }
 }

void BTagPerformanceAnalyzerMC::bookHistos ( const edm::ParameterSet & pSet )

private

Definition at line 60 of file BTagPerformanceAnalyzerMC.cc.

References binJetTagPlotters, binTagCorrelationPlotters, binTagInfoPlotters, binTagInfoPlottersToModuleConfig, TagInfoPlotterFactory::buildPlotter(), BTagDifferentialPlot::constETA, BTagDifferentialPlot::constPT, differentialPlots, etaRanges, finalize, getEtaPtBin(), jetTagInputTags, edm::InputTag::label(), makeDiffPlots_, mcPlots_, moduleConfig, ptRanges, setTDRStyle(), tagCorrelationInputTags, tagInfoInputTags, tiDataFormatType, and update.

Referenced by BTagPerformanceAnalyzerMC().

 {
   //
   // Book all histograms.
   //
 
   //if (update) {
     //
     // append the DQM file ... we should consider this experimental
     //    edm::Service<DQMStore>().operator->()->open(std::string((const char *)(inputFile)),"/");
     // removed; DQM framework will take care
   //}
 
   // parton p
 //   double pPartonMin = 0.0    ;
 //   double pPartonMax = 99999.9 ;
 
 
   // iterate over ranges:
   const int iEtaStart = -1                   ;  // this will be the inactive one
   const int iEtaEnd   = etaRanges.size() - 1 ;
   const int iPtStart  = -1                   ;  // this will be the inactive one
   const int iPtEnd    = ptRanges.size() - 1  ;
   setTDRStyle();
 
   TagInfoPlotterFactory theFactory;
 
   for (vector<edm::ParameterSet>::const_iterator iModule = moduleConfig.begin();
        iModule != moduleConfig.end(); ++iModule) {
 
     const string& dataFormatType = iModule->exists("type") ?
                                    iModule->getParameter<string>("type") :
                                    "JetTag";
     if (dataFormatType == "JetTag") {
       const InputTag& moduleLabel = iModule->getParameter<InputTag>("label");
       const string& folderName    = iModule->getParameter<string>("folder");
 
       jetTagInputTags.push_back(moduleLabel);
       binJetTagPlotters.push_back(vector<JetTagPlotter*>()) ;
       // Contains plots for each bin of rapidity and pt.
     vector<BTagDifferentialPlot*> * differentialPlotsConstantEta = new vector<BTagDifferentialPlot*> () ;
     vector<BTagDifferentialPlot*> * differentialPlotsConstantPt  = new vector<BTagDifferentialPlot*> () ;
       if (finalize && mcPlots_ && makeDiffPlots_){
     differentialPlots.push_back(vector<BTagDifferentialPlot*>());
 
     // the constant b-efficiency for the differential plots versus pt and eta
     const double& effBConst =
                 iModule->getParameter<edm::ParameterSet>("parameters").getParameter<double>("effBConst");
 
     // the objects for the differential plots vs. eta,pt for
     for ( int iEta = iEtaStart ; iEta < iEtaEnd ; iEta++ ) {
       BTagDifferentialPlot * etaConstDifferentialPlot = new BTagDifferentialPlot
         (effBConst, BTagDifferentialPlot::constETA, folderName);
       differentialPlotsConstantEta->push_back ( etaConstDifferentialPlot );
     }
 
     for ( int iPt = iPtStart ; iPt < iPtEnd ; iPt++ ) {
       // differentialPlots for this pt bin
       BTagDifferentialPlot * ptConstDifferentialPlot = new BTagDifferentialPlot
         (effBConst, BTagDifferentialPlot::constPT, folderName);
       differentialPlotsConstantPt->push_back ( ptConstDifferentialPlot );
     }
       }
       // eta loop
       for ( int iEta = iEtaStart ; iEta < iEtaEnd ; iEta++ ) {
     // pt loop
     for ( int iPt = iPtStart ; iPt < iPtEnd ; iPt++ ) {
 
       const EtaPtBin& etaPtBin = getEtaPtBin(iEta, iPt);
 
       // Instantiate the genertic b tag plotter
       JetTagPlotter *jetTagPlotter = new JetTagPlotter(folderName, etaPtBin,
                                iModule->getParameter<edm::ParameterSet>("parameters"),mcPlots_,update,finalize);
       binJetTagPlotters.back().push_back ( jetTagPlotter ) ;
 
       // Add to the corresponding differential plotters
       if (finalize && mcPlots_ && makeDiffPlots_){
         (*differentialPlotsConstantEta)[iEta+1]->addBinPlotter ( jetTagPlotter ) ;
         (*differentialPlotsConstantPt )[iPt+1] ->addBinPlotter ( jetTagPlotter ) ;
       }
     }
       }
       // the objects for the differential plots vs. eta, pt: collect all from constant eta and constant pt
       if (finalize && mcPlots_ && makeDiffPlots_){
     differentialPlots.back().reserve(differentialPlotsConstantEta->size()+differentialPlotsConstantPt->size()) ;
     differentialPlots.back().insert(differentialPlots.back().end(), differentialPlotsConstantEta->begin(), differentialPlotsConstantEta->end());
     differentialPlots.back().insert(differentialPlots.back().end(), differentialPlotsConstantPt->begin(), differentialPlotsConstantPt->end());
 
     edm::LogInfo("Info")
       << "====>>>> ## sizeof differentialPlots = " << differentialPlots.size();
 
     // the intermediate ones are no longer needed
     delete differentialPlotsConstantEta ;
     delete differentialPlotsConstantPt  ;
       }
     } else if(dataFormatType == "TagCorrelation") {
         const InputTag& label1 = iModule->getParameter<InputTag>("label1");
         const InputTag& label2 = iModule->getParameter<InputTag>("label2");
         tagCorrelationInputTags.push_back(std::pair<edm::InputTag, edm::InputTag>(label1, label2));
         binTagCorrelationPlotters.push_back(vector<TagCorrelationPlotter*>());
 
         // eta loop
         for ( int iEta = iEtaStart ; iEta != iEtaEnd ; ++iEta) {
           // pt loop
           for( int iPt = iPtStart ; iPt != iPtEnd ; ++iPt) {
             const EtaPtBin& etaPtBin = getEtaPtBin(iEta, iPt);
             // Instantiate the generic b tag correlation plotter
             TagCorrelationPlotter* tagCorrelationPlotter = new TagCorrelationPlotter(label1.label(), label2.label(), etaPtBin,
                                                                                      iModule->getParameter<edm::ParameterSet>("parameters"),
                                                                                      mcPlots_, update);
             binTagCorrelationPlotters.back().push_back(tagCorrelationPlotter);
           }
         }
     } else {
       // tag info retrievel is deferred (needs availability of EventSetup)
       const InputTag& moduleLabel = iModule->getParameter<InputTag>("label");
       const string& folderName    = iModule->getParameter<string>("folder");
 
       tagInfoInputTags.push_back(vector<edm::InputTag>());
       tiDataFormatType.push_back(dataFormatType);
       binTagInfoPlotters.push_back(vector<BaseTagInfoPlotter*>()) ;
       // eta loop
       for ( int iEta = iEtaStart ; iEta < iEtaEnd ; iEta++ ) {
     // pt loop
     for ( int iPt = iPtStart ; iPt < iPtEnd ; iPt++ ) {
       const EtaPtBin& etaPtBin = getEtaPtBin(iEta, iPt);
 
       // Instantiate the tagInfo plotter
 
       BaseTagInfoPlotter *jetTagPlotter = theFactory.buildPlotter(dataFormatType, moduleLabel.label(), 
                          etaPtBin, iModule->getParameter<edm::ParameterSet>("parameters"), folderName, 
                                      update, mcPlots_,finalize);
       binTagInfoPlotters.back().push_back ( jetTagPlotter ) ;
           binTagInfoPlottersToModuleConfig.insert(make_pair(jetTagPlotter, iModule - moduleConfig.begin()));
     }
       }
 
       edm::LogInfo("Info")
     << "====>>>> ## sizeof differentialPlots = " << differentialPlots.size();
     }
   }
 }

void BTagPerformanceAnalyzerMC::endJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 495 of file BTagPerformanceAnalyzerMC.cc.

References begin, binJetTagPlotters, binTagInfoPlotters, differentialPlots, epsBaseName, finalize, makeDiffPlots_, produceEps, producePs, psBaseName, and setTDRStyle().

 {
   if (!finalize) return;
   setTDRStyle();
   for (unsigned int iJetLabel = 0; iJetLabel != binJetTagPlotters.size(); ++iJetLabel) {
     int plotterSize =  binJetTagPlotters[iJetLabel].size();
     for (int iPlotter = 0; iPlotter != plotterSize; ++iPlotter) {
        binJetTagPlotters[iJetLabel][iPlotter]->finalize();
       //      binJetTagPlotters[iJetLabel][iPlotter]->write(allHisto);
       if (producePs)  (*binJetTagPlotters[iJetLabel][iPlotter]).psPlot(psBaseName);
       if (produceEps) (*binJetTagPlotters[iJetLabel][iPlotter]).epsPlot(epsBaseName);
     }
    
       if(makeDiffPlots_) { 
         for (vector<BTagDifferentialPlot *>::iterator iPlotter = differentialPlots[iJetLabel].begin();
          iPlotter != differentialPlots[iJetLabel].end(); ++ iPlotter) {
       (*iPlotter)->process();
       if (producePs)  (*iPlotter)->psPlot(psBaseName);
       if (produceEps) (*iPlotter)->epsPlot(epsBaseName);
       //      (**iPlotter).write(allHisto);
         }
       }
   }
   for (vector<vector<BaseTagInfoPlotter*> >::iterator iJetLabel = binTagInfoPlotters.begin();
        iJetLabel != binTagInfoPlotters.end(); ++iJetLabel) {
     for (vector<BaseTagInfoPlotter*>::iterator iPlotter = iJetLabel->begin(); iPlotter != iJetLabel->end(); ++iPlotter) {
       (*iPlotter)->finalize();
       //      binTagInfoPlotters[iJetLabel][iPlotter]->write(allHisto);
       if (producePs)  (*iPlotter)->psPlot(psBaseName);
       if (produceEps) (*iPlotter)->epsPlot(epsBaseName);
     }
   }
 }

EtaPtBin BTagPerformanceAnalyzerMC::getEtaPtBin	(	const int &	iEta,
		const int &	iPt
	)

private

Definition at line 203 of file BTagPerformanceAnalyzerMC.cc.

References etaRanges, funct::false, ptRanges, and funct::true.

Referenced by bookHistos().

 {
   // DEFINE BTagBin:
   bool    etaActive_ , ptActive_;
   double  etaMin_, etaMax_, ptMin_, ptMax_ ;
 
   if ( iEta != -1 ) {
     etaActive_ = true ;
     etaMin_    = etaRanges[iEta]   ;
     etaMax_    = etaRanges[iEta+1] ;
   }
   else {
     etaActive_ = false ;
     etaMin_    = etaRanges[0]   ;
     etaMax_    = etaRanges[etaRanges.size() - 1]   ;
   }
 
   if ( iPt != -1 ) {
     ptActive_ = true ;
     ptMin_    = ptRanges[iPt]   ;
     ptMax_    = ptRanges[iPt+1] ;
   }
   else {
     ptActive_ = false ;
     ptMin_    = ptRanges[0] ;
     ptMax_    = ptRanges[ptRanges.size() - 1]   ;
   }
   return EtaPtBin(etaActive_ , etaMin_ , etaMax_ ,
             ptActive_  , ptMin_  , ptMax_ );
 }

bool BTagPerformanceAnalyzerMC::getJetWithFlavour	(	edm::RefToBase< reco::Jet >	caloRef,
		FlavourMap	flavours,
		JetWithFlavour &	jetWithFlavour,
		const edm::EventSetup &	es
	)

private

Definition at line 453 of file BTagPerformanceAnalyzerMC.cc.

References eventInitialized, i, edm::ProductID::id(), edm::RefToBase< T >::id(), edm::RefToBase< T >::isNull(), jetCorrector, jetMatcher, LogTrace, MatchJet::matchCollections(), edm::RefToBaseVector< T >::push_back(), CorrectJet::setEventSetup(), and edm::View< T >::size().

Referenced by analyze().

 {
 
   edm::ProductID recProdId = jetRef.id();
   edm::ProductID refProdId = (flavours.begin() == flavours.end())
     ? recProdId
     : flavours.begin()->first.id();
 
   if (!eventInitialized) {
     jetCorrector.setEventSetup(es);
     if (recProdId != refProdId) {
       edm::RefToBaseVector<Jet> refJets;
       for(FlavourMap::const_iterator iter = flavours.begin();
           iter != flavours.end(); ++iter)
         refJets.push_back(iter->first);
       const edm::RefToBaseProd<Jet> recJetsProd(jetRef);
       edm::RefToBaseVector<Jet> recJets;
       for(unsigned int i = 0; i < recJetsProd->size(); i++)
         recJets.push_back(edm::RefToBase<Jet>(recJetsProd, i));
       jetMatcher.matchCollections(refJets, recJets, es);
     }
     eventInitialized = true;
   }
 
   if (recProdId != refProdId) {
     jetRef = jetMatcher(jetRef);
     if (jetRef.isNull())
       return false;
   }
 
   jetWithFlavour.first = jetCorrector(*jetRef);
 
   jetWithFlavour.second = reco::JetFlavour(jetWithFlavour.first.p4(), math::XYZPoint (0,0,0), flavours[jetRef]);
 
   LogTrace("Info") << "Found jet with flavour "<<jetWithFlavour.second.getFlavour()<<endl;
   LogTrace("Info") << jetWithFlavour.first.p()<<" , "<< jetWithFlavour.first.pt()<<" - "
    << jetWithFlavour.second.getLorentzVector().P()<<" , "<< jetWithFlavour.second.getLorentzVector().Pt()<<endl;
 
   return true;
 }