TauTagValidation Class Reference

#include <TauTagValidation.h>

Inheritance diagram for TauTagValidation:

Public Member Functions
virtual void	analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup)
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
void	dqmBeginRun (const edm::Run &, const edm::EventSetup &)
	TauTagValidation (const edm::ParameterSet &)
	~TauTagValidation ()
Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final
virtual void	beginStream (edm::StreamID id) final
	DQMEDAnalyzer (void)
virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::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 ()

Protected Attributes
PFBenchmarkAlgo *	algo_

Private Member Functions
double	getSumPt (const std::vector< edm::Ptr< reco::PFCandidate > > &candidates)
	sum the transversal momentum of all candidates More...
bool	stripDiscriminatorLabel (const std::string &discriminatorLabel, std::string &newLabel)
	get rid of redundant parts to shorten the label More...

Private Attributes
bool	chainCuts_
std::vector< edm::EDGetTokenT < reco::PFTauDiscriminator > >	currentDiscriminatorToken_
std::string	dataType_
	What's the reference for the Validation Leptons or Jets. More...
std::vector< edm::ParameterSet >	discriminators_
std::map< std::string, MonitorElement * >	etaTauVisibleMap
std::string	extensionName_
std::string	genCuts_
GenericTriggerEventFlag *	genericTriggerEventFlag_
	generic access to dynamic trigger table More...
edm::ParameterSet	histoSettings_
double	matchDeltaR_Jets_
double	matchDeltaR_Leptons_
std::string	moduleLabel_
	label of the current module More...
MonitorElement *	nCaloJet_LeadingTrack_isolationECALhitsEtSum_
MonitorElement *	nCaloJet_LeadingTrack_isolationTracks_
MonitorElement *	nCaloJet_LeadingTrack_signalTracks_
MonitorElement *	nCaloJet_LeadingTrack_signalTracksInvariantMass_
MonitorElement *	nEMIsolated_signalTracks_
MonitorElement *	nEMIsolated_signalTracksInvariantMass_
MonitorElement *	nIsolated_NoChargedHadrons_ChargedHadronsSignal_
MonitorElement *	nIsolated_NoChargedHadrons_GammasIsolAnnulus_
MonitorElement *	nIsolated_NoChargedHadrons_GammasSignal_
MonitorElement *	nIsolated_NoChargedHadrons_NeutralHadronsIsolAnnulus_
MonitorElement *	nIsolated_NoChargedHadrons_NeutralHadronsSignal_
MonitorElement *	nIsolated_NoChargedNoGammas_ChargedHadronsSignal_
MonitorElement *	nIsolated_NoChargedNoGammas_GammasSignal_
MonitorElement *	nIsolated_NoChargedNoGammas_NeutralHadronsIsolAnnulus_
MonitorElement *	nIsolated_NoChargedNoGammas_NeutralHadronsSignal_
MonitorElement *	nPFJet_LeadingChargedHadron_ChargedHadronsIsolAnnulus_
MonitorElement *	nPFJet_LeadingChargedHadron_ChargedHadronsSignal_
MonitorElement *	nPFJet_LeadingChargedHadron_GammasIsolAnnulus_
MonitorElement *	nPFJet_LeadingChargedHadron_GammasSignal_
MonitorElement *	nPFJet_LeadingChargedHadron_NeutralHadronsIsolAnnulus_
MonitorElement *	nPFJet_LeadingChargedHadron_NeutralHadronsSignal_
MonitorElement *	nTrackIsolated_isolationECALhitsEtSum_
MonitorElement *	nTrackIsolated_signalTracks_
MonitorElement *	nTrackIsolated_signalTracksInvariantMass_
int	numEvents_
std::string	outPutFile_
std::map< std::string, MonitorElement * >	phiTauVisibleMap
std::map< std::string, MonitorElement * >	pileupTauVisibleMap
std::map< std::string, MonitorElement * >	plotMap_
edm::InputTag	PrimaryVertexCollection_
edm::EDGetTokenT < reco::VertexCollection >	primaryVertexCollectionToken_
std::map< std::string, MonitorElement * >	ptTauVisibleMap
std::string	recoCuts_
std::string	refCollection_
edm::InputTag	refCollectionInputTag_
edm::EDGetTokenT< edm::View < reco::Candidate > >	refCollectionInputTagToken_
bool	saveoutputhistograms_
std::string	TauProducer_
edm::InputTag	TauProducerInputTag_
edm::EDGetTokenT < reco::PFTauCollection >	tauProducerInputTagToken_
double	TauPtCut_
bool	turnOnTrigger_
std::string	tversion

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T...>	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::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

Description: <one line="" class="" summary>="">

Class used to do the Validation of the TauTag

Implementation: <Notes on="" implementation>="">

Definition at line 72 of file TauTagValidation.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 38 of file TauTagValidation.cc.

References chainCuts_, edm::EDConsumerBase::consumesCollector(), currentDiscriminatorToken_, discriminators_, edm::ParameterSet::exists(), extensionName_, genericTriggerEventFlag_, edm::ParameterSet::getParameter(), edm::getReleaseVersion(), histoSettings_, HLT_25ns14e33_v1_cff::InputTag, j, edm::InputTag::label(), LogDebug, moduleLabel_, NULL, numEvents_, outPutFile_, PrimaryVertexCollection_, primaryVertexCollectionToken_, refCollection_, refCollectionInputTag_, refCollectionInputTagToken_, saveoutputhistograms_, TauProducer_, TauProducerInputTag_, tauProducerInputTagToken_, turnOnTrigger_, and tversion.

                                                                :
  moduleLabel_(iConfig.getParameter<std::string>("@module_label")),
  // What do we want to use as source Leptons or Jets (the only difference is the matching criteria)
  dataType_( iConfig.getParameter<string>("DataType") ),
  // We need different matching criteria if we talk about leptons or jets
  matchDeltaR_Leptons_( iConfig.getParameter<double>("MatchDeltaR_Leptons")),
  matchDeltaR_Jets_( iConfig.getParameter<double>("MatchDeltaR_Jets")),
  TauPtCut_( iConfig.getParameter<double>("TauPtCut")),
  //flexible cut interface to filter reco and gen collection. use an empty string to select all.
  recoCuts_( iConfig.getParameter<std::string>( "recoCuts" )),
  genCuts_( iConfig.getParameter<std::string>( "genCuts" )),
  // The output histograms can be stored or not
  saveoutputhistograms_( iConfig.getParameter<bool>("SaveOutputHistograms")),
  // Here it can be pretty much anything either a lepton or a jet
  refCollectionInputTag_( iConfig.getParameter<InputTag>("RefCollection")),
  // The extension name has information about the Reference collection used
  extensionName_( iConfig.getParameter<string>("ExtensionName")),
  // Here is the reconstructed product of interest.
  TauProducerInputTag_( iConfig.getParameter<InputTag>("TauProducer")),
  // Get the discriminators and their cuts
  discriminators_( iConfig.getParameter< std::vector<edm::ParameterSet> >( "discriminators" ))
{

  turnOnTrigger_ = iConfig.exists("turnOnTrigger") && iConfig.getParameter<bool>("turnOnTrigger");
  genericTriggerEventFlag_ = (iConfig.exists("GenericTriggerSelection") && turnOnTrigger_) ? new GenericTriggerEventFlag(iConfig.getParameter<edm::ParameterSet>("GenericTriggerSelection"), consumesCollector(), *this) : NULL;
  if(genericTriggerEventFlag_ != NULL)  LogDebug(moduleLabel_) <<"--> GenericTriggerSelection parameters found in "<<moduleLabel_<<"."<<std::endl;//move to LogDebug
  else LogDebug(moduleLabel_) <<"--> GenericTriggerSelection not found in "<<moduleLabel_<<"."<<std::endl;//move to LogDebug to keep track of modules that fail and pass

  //InputTag to strings
  refCollection_ = refCollectionInputTag_.label();
  TauProducer_ = TauProducerInputTag_.label();

  histoSettings_= (iConfig.exists("histoSettings")) ? iConfig.getParameter<edm::ParameterSet>("histoSettings") : edm::ParameterSet();
  edm::InputTag PrimaryVertexCollection_ = (iConfig.exists("PrimaryVertexCollection")) ? iConfig.getParameter<InputTag>("PrimaryVertexCollection") : edm::InputTag("offlinePrimaryVertices"); //TO-DO

  refCollectionInputTagToken_ = consumes<edm::View<reco::Candidate> >(iConfig.getParameter<InputTag>("RefCollection"));
  primaryVertexCollectionToken_ = consumes<VertexCollection>(PrimaryVertexCollection_); //TO-DO
  tauProducerInputTagToken_ = consumes<reco::PFTauCollection>(iConfig.getParameter<InputTag>("TauProducer"));
  int j = 0;
  for ( std::vector<edm::ParameterSet>::iterator it = discriminators_.begin();  it != discriminators_.end(); ++j, ++it ) {
    currentDiscriminatorToken_.push_back( consumes<reco::PFTauDiscriminator>(edm::InputTag(it->getParameter<string>("discriminator"))) );
  }

  tversion = edm::getReleaseVersion();

  if (!saveoutputhistograms_) {
    LogInfo("OutputInfo") << " TauVisible histograms will NOT be saved";
  } else {
    outPutFile_ = TauProducer_;
    outPutFile_.append("_");
    tversion.erase(0,1);
    tversion.erase(tversion.size()-1,1);
    outPutFile_.append(tversion);
    outPutFile_.append("_"+ refCollection_);
    if ( ! extensionName_.empty()){
      outPutFile_.append("_"+ extensionName_);
    }
    outPutFile_.append(".root");

    LogInfo("OutputInfo") << " TauVisiblehistograms will be saved to file:" << outPutFile_;
  }

  //---- book-keeping information ---
  numEvents_ = 0 ;

  // Check if we want to "chain" the discriminator requirements (i.e. all
  // prveious discriminators must pass)
  chainCuts_ = iConfig.exists("chainCuts") ?
  iConfig.getParameter<bool>("chainCuts") : true;

}

TauTagValidation::~TauTagValidation

(

)

Definition at line 110 of file TauTagValidation.cc.

References genericTriggerEventFlag_.

                                    {
  if (genericTriggerEventFlag_) delete genericTriggerEventFlag_;
}

Member Function Documentation

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

virtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 297 of file TauTagValidation.cc.

References algo_, ecal_dqm_sourceclient-live_cfg::cerr, chainCuts_, gather_cfg::cout, currentDiscriminatorToken_, dataType_, delta, deltaR(), PFBenchmarkAlgo::deltaR(), discriminators_, etaTauVisibleMap, MonitorElement::Fill(), genCuts_, genericTriggerEventFlag_, JetMCTagUtils::genTauDecayMode(), edm::Event::getByToken(), getSumPt(), j, matchDeltaR_Jets_, matchDeltaR_Leptons_, nIsolated_NoChargedNoGammas_ChargedHadronsSignal_, nIsolated_NoChargedNoGammas_GammasSignal_, nIsolated_NoChargedNoGammas_NeutralHadronsIsolAnnulus_, nIsolated_NoChargedNoGammas_NeutralHadronsSignal_, nPFJet_LeadingChargedHadron_ChargedHadronsIsolAnnulus_, nPFJet_LeadingChargedHadron_ChargedHadronsSignal_, nPFJet_LeadingChargedHadron_GammasIsolAnnulus_, nPFJet_LeadingChargedHadron_GammasSignal_, nPFJet_LeadingChargedHadron_NeutralHadronsIsolAnnulus_, nPFJet_LeadingChargedHadron_NeutralHadronsSignal_, numEvents_, GenericTriggerEventFlag::on(), phiTauVisibleMap, Pi, pileupTauVisibleMap, plotMap_, primaryVertexCollectionToken_, edm::Handle< T >::product(), reco::Candidate::pt(), ptTauVisibleMap, recoCuts_, refCollection_, refCollectionInputTagToken_, AlCaHLTBitMon_QueryRunRegistry::string, TauProducer_, tauProducerInputTagToken_, and TauPtCut_.

                                                                                  {
  if (genericTriggerEventFlag_) {
    if (!genericTriggerEventFlag_->on()) std::cout<<"TauTagValidation::analyze: No working genericTriggerEventFlag. Did you specify a valid globaltag?"<<std::endl;//move to LogDebug?
  }

  numEvents_++;
  double matching_criteria = -1.0;

  typedef edm::View<reco::Candidate> genCandidateCollection;

  // ----------------------- Reference product -----------------------------------------------------------------------

  Handle<genCandidateCollection> ReferenceCollection;
  bool isGen = iEvent.getByToken( refCollectionInputTagToken_, ReferenceCollection );

  Handle<VertexCollection> pvHandle;
  iEvent.getByToken( primaryVertexCollectionToken_, pvHandle ); //TO-DO

  if (!isGen) {
    std::cerr << " Reference collection: " << refCollection_ << " not found while running TauTagValidation.cc " << std::endl;
    return;
  }

  if(dataType_ == "Leptons"){
    matching_criteria = matchDeltaR_Leptons_;
  }
  else
  {
    matching_criteria = matchDeltaR_Jets_;
  }

  // ------------------------------ PFTauCollection Matched and other discriminators ---------------------------------------------------------

  if ( TauProducer_.find("PFTau") != string::npos || TauProducer_.find("hpsTancTaus") != string::npos )
  {
    Handle<PFTauCollection> thePFTauHandle;
    iEvent.getByToken( tauProducerInputTagToken_, thePFTauHandle );

    const PFTauCollection  *pfTauProduct;
    pfTauProduct = thePFTauHandle.product();

    PFTauCollection::size_type thePFTauClosest;

    std::map<std::string,  MonitorElement *>::const_iterator element = plotMap_.end();

    for (genCandidateCollection::const_iterator RefJet= ReferenceCollection->begin() ; RefJet != ReferenceCollection->end(); RefJet++ ){

      ptTauVisibleMap.find(refCollection_)->second->Fill(RefJet->pt());
      etaTauVisibleMap.find(refCollection_)->second->Fill(RefJet->eta());
      phiTauVisibleMap.find(refCollection_)->second->Fill(RefJet->phi()*180.0/TMath::Pi());
      pileupTauVisibleMap.find(refCollection_)->second->Fill(pvHandle->size());

      const reco::Candidate *gen_particle = &(*RefJet);

      double delta=TMath::Pi();

      thePFTauClosest = pfTauProduct->size();

      for (PFTauCollection::size_type iPFTau=0 ; iPFTau <  pfTauProduct->size() ; iPFTau++)
      {
        if (algo_->deltaR(gen_particle, & pfTauProduct->at(iPFTau)) < delta){
          delta = algo_->deltaR(gen_particle, & pfTauProduct->at(iPFTau));
          thePFTauClosest = iPFTau;
        }
      }

      // Skip if there is no reconstructed Tau matching the Reference
      if (thePFTauClosest == pfTauProduct->size()) continue;

      double deltaR = algo_->deltaR(gen_particle, & pfTauProduct->at(thePFTauClosest));

      // Skip if the delta R difference is larger than the required criteria
      if (deltaR > matching_criteria && matching_criteria != -1.0) continue;

      ptTauVisibleMap.find( TauProducer_+"Matched")->second->Fill(RefJet->pt());
      etaTauVisibleMap.find( TauProducer_+"Matched" )->second->Fill(RefJet->eta());
      phiTauVisibleMap.find( TauProducer_+"Matched" )->second->Fill(RefJet->phi()*180.0/TMath::Pi());
      pileupTauVisibleMap.find(  TauProducer_+"Matched")->second->Fill(pvHandle->size());

      PFTauRef thePFTau(thePFTauHandle, thePFTauClosest);

      Handle<PFTauDiscriminator> currentDiscriminator;

      //filter the candidates
      if(thePFTau->pt() < TauPtCut_ ) continue;//almost deprecated, since recoCuts_ provides more flexibility
                                               //reco
      StringCutObjectSelector<PFTauRef> selectReco(recoCuts_);
      bool pass = selectReco( thePFTau );
      if( !pass ) continue;
      //gen
      StringCutObjectSelector<reco::Candidate> selectGen(genCuts_);
      pass = selectGen( *gen_particle );
      if( !pass ) continue;

      int j = 0;
      for ( std::vector< edm::ParameterSet >::iterator it = discriminators_.begin(); it!= discriminators_.end();  it++, j++)
      {
        string currentDiscriminatorLabel = it->getParameter<string>("discriminator");
        iEvent.getByToken( currentDiscriminatorToken_[j], currentDiscriminator );

        if ((*currentDiscriminator)[thePFTau] >= it->getParameter<double>("selectionCut")){
          ptTauVisibleMap.find(  currentDiscriminatorLabel )->second->Fill(RefJet->pt());
          etaTauVisibleMap.find(  currentDiscriminatorLabel )->second->Fill(RefJet->eta());
          phiTauVisibleMap.find(  currentDiscriminatorLabel )->second->Fill(RefJet->phi()*180.0/TMath::Pi());
          pileupTauVisibleMap.find(  currentDiscriminatorLabel )->second->Fill(pvHandle->size());

          //fill the momentum resolution plots
          double tauPtRes = thePFTau->pt()/gen_particle->pt();//WARNING: use only the visible parts!
          plotMap_.find( currentDiscriminatorLabel + "_pTRatio_allHadronic" )->second->Fill(tauPtRes);

          //is there a better way than casting the candidate?
          const reco::GenJet *tauGenJet = dynamic_cast<const reco::GenJet*>(gen_particle);
          if(tauGenJet!=0){
            std::string genTauDecayMode =  JetMCTagUtils::genTauDecayMode(*tauGenJet); // gen_particle is the tauGenJet matched to the reconstructed tau
            element = plotMap_.find( currentDiscriminatorLabel + "_pTRatio_" + genTauDecayMode );
            if( element != plotMap_.end() ) element->second->Fill(tauPtRes);
          }else{
            LogInfo("TauTagValidation") << " Failed to cast the MC candidate.";
          }

          //fill: size and sumPt within tau isolation
          std::string plotType = "_Size_";
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "signalPFCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->signalPFCands().size() );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "signalPFChargedHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->signalPFChargedHadrCands().size() );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "signalPFNeutrHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->signalPFNeutrHadrCands().size() );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->isolationPFCands().size() );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFChargedHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->isolationPFChargedHadrCands().size() );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFNeutrHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->isolationPFNeutrHadrCands().size() );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFGammaCands" );
          if( element != plotMap_.end() ) element->second->Fill( thePFTau->isolationPFGammaCands().size() );

          plotType = "_SumPt_";
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "signalPFCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->signalPFCands() ) );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "signalPFChargedHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->signalPFChargedHadrCands() ) );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "signalPFNeutrHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->signalPFNeutrHadrCands() ) );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->isolationPFCands() ) );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFChargedHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->isolationPFChargedHadrCands() ) );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFNeutrHadrCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->isolationPFNeutrHadrCands() ) );
          element = plotMap_.find( currentDiscriminatorLabel + plotType + "isolationPFGammaCands" );
          if( element != plotMap_.end() ) element->second->Fill( getSumPt( thePFTau->isolationPFGammaCands() ) );

          //deprecated

          if( TauProducer_.find("PFTau") != string::npos ){
            if ( currentDiscriminatorLabel.find("LeadingTrackPtCut") != string::npos){
              nPFJet_LeadingChargedHadron_ChargedHadronsSignal_->Fill((*thePFTau).signalPFChargedHadrCands().size());
              nPFJet_LeadingChargedHadron_ChargedHadronsIsolAnnulus_->Fill((*thePFTau).isolationPFChargedHadrCands().size());
              nPFJet_LeadingChargedHadron_GammasSignal_->Fill((*thePFTau).signalPFGammaCands().size());
              nPFJet_LeadingChargedHadron_GammasIsolAnnulus_->Fill((*thePFTau).isolationPFGammaCands().size());
              nPFJet_LeadingChargedHadron_NeutralHadronsSignal_->Fill((*thePFTau).signalPFNeutrHadrCands().size());
              nPFJet_LeadingChargedHadron_NeutralHadronsIsolAnnulus_->Fill((*thePFTau).isolationPFNeutrHadrCands().size());
            }
            else if ( currentDiscriminatorLabel.find("ByIsolation") != string::npos ){
              nIsolated_NoChargedNoGammas_ChargedHadronsSignal_->Fill((*thePFTau).signalPFChargedHadrCands().size());
              nIsolated_NoChargedNoGammas_GammasSignal_->Fill((*thePFTau).signalPFGammaCands().size());
              nIsolated_NoChargedNoGammas_NeutralHadronsSignal_->Fill((*thePFTau).signalPFNeutrHadrCands().size());
              nIsolated_NoChargedNoGammas_NeutralHadronsIsolAnnulus_->Fill((*thePFTau).isolationPFNeutrHadrCands().size());
            }
          }
        }
        else {
          if (chainCuts_)
            break;
        }
      }
    }
  }
}

void TauTagValidation::bookHistograms ( DQMStore::IBooker &  ibooker, edm::Run const &  iRun, edm::EventSetup const &    )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 114 of file TauTagValidation.cc.

References DQMStore::IBooker::book1D(), discriminators_, etaTauVisibleMap, edm::ParameterSet::exists(), extensionName_, edm::ParameterSet::getParameter(), histoSettings_, hinfo::max, hinfo::min, hinfo::nbins, nIsolated_NoChargedHadrons_ChargedHadronsSignal_, nIsolated_NoChargedHadrons_GammasIsolAnnulus_, nIsolated_NoChargedHadrons_GammasSignal_, nIsolated_NoChargedHadrons_NeutralHadronsIsolAnnulus_, nIsolated_NoChargedHadrons_NeutralHadronsSignal_, nIsolated_NoChargedNoGammas_ChargedHadronsSignal_, nIsolated_NoChargedNoGammas_GammasSignal_, nIsolated_NoChargedNoGammas_NeutralHadronsIsolAnnulus_, nIsolated_NoChargedNoGammas_NeutralHadronsSignal_, nPFJet_LeadingChargedHadron_ChargedHadronsIsolAnnulus_, nPFJet_LeadingChargedHadron_ChargedHadronsSignal_, nPFJet_LeadingChargedHadron_GammasIsolAnnulus_, nPFJet_LeadingChargedHadron_GammasSignal_, nPFJet_LeadingChargedHadron_NeutralHadronsIsolAnnulus_, nPFJet_LeadingChargedHadron_NeutralHadronsSignal_, phiTauVisibleMap, pileupTauVisibleMap, plotMap_, ptTauVisibleMap, refCollection_, DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, stripDiscriminatorLabel(), and TauProducer_.

{
  MonitorElement * ptTemp,* etaTemp,* phiTemp, *pileupTemp, *tmpME;

  ibooker.setCurrentFolder("RecoTauV/" + TauProducer_ + extensionName_ + "_ReferenceCollection" );

  //Histograms settings
  hinfo ptHinfo = (histoSettings_.exists("pt")) ? hinfo(histoSettings_.getParameter<edm::ParameterSet>("pt")) : hinfo(500, 0., 1000.);
  hinfo etaHinfo = (histoSettings_.exists("eta")) ? hinfo(histoSettings_.getParameter<edm::ParameterSet>("eta")) : hinfo(60, -3.0, 3.0);
  hinfo phiHinfo = (histoSettings_.exists("phi")) ? hinfo(histoSettings_.getParameter<edm::ParameterSet>("phi")) : hinfo(40, -200., 200.);
  hinfo pileupHinfo = (histoSettings_.exists("pileup")) ? hinfo(histoSettings_.getParameter<edm::ParameterSet>("pileup")) : hinfo(100, 0., 100.);
  //hinfo dRHinfo = (histoSettings_.exists("deltaR")) ? hinfo(histoSettings_.getParameter<edm::ParameterSet>("deltaR")) : hinfo(10, 0., 0.5);

  // What kind of Taus do we originally have!

  ptTemp    =  ibooker.book1D("nRef_Taus_vs_ptTauVisible", "nRef_Taus_vs_ptTauVisible", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
  etaTemp   =  ibooker.book1D("nRef_Taus_vs_etaTauVisible", "nRef_Taus_vs_etaTauVisible", etaHinfo.nbins, etaHinfo.min, etaHinfo.max );
  phiTemp   =  ibooker.book1D("nRef_Taus_vs_phiTauVisible", "nRef_Taus_vs_phiTauVisible", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
  pileupTemp =  ibooker.book1D("nRef_Taus_vs_pileupTauVisible", "nRef_Taus_vs_pileupTauVisible", pileupHinfo.nbins, pileupHinfo.min, pileupHinfo.max);

  ptTauVisibleMap.insert( std::make_pair( refCollection_,ptTemp));
  etaTauVisibleMap.insert( std::make_pair(refCollection_,etaTemp));
  phiTauVisibleMap.insert( std::make_pair(refCollection_,phiTemp));
  pileupTauVisibleMap.insert( std::make_pair(refCollection_,pileupTemp));

  // Number of Tau Candidates matched to MC Taus

  ibooker.setCurrentFolder("RecoTauV/"+ TauProducer_ + extensionName_ + "_Matched");

  ptTemp    =  ibooker.book1D(TauProducer_ +"Matched_vs_ptTauVisible", TauProducer_ +"Matched_vs_ptTauVisible", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
  etaTemp   =  ibooker.book1D(TauProducer_ +"Matched_vs_etaTauVisible", TauProducer_ +"Matched_vs_etaTauVisible", etaHinfo.nbins, etaHinfo.min, etaHinfo.max );
  phiTemp   =  ibooker.book1D(TauProducer_ +"Matched_vs_phiTauVisible", TauProducer_ +"Matched_vs_phiTauVisible", phiHinfo.nbins, phiHinfo.min, phiHinfo.max );
  pileupTemp =  ibooker.book1D(TauProducer_ +"Matched_vs_pileupTauVisible", TauProducer_ +"Matched_vs_pileupTauVisible", pileupHinfo.nbins, pileupHinfo.min, pileupHinfo.max);

  ptTauVisibleMap.insert( std::make_pair( TauProducer_+"Matched" ,ptTemp));
  etaTauVisibleMap.insert( std::make_pair(TauProducer_+"Matched" ,etaTemp));
  phiTauVisibleMap.insert( std::make_pair(TauProducer_+"Matched" ,phiTemp));
  pileupTauVisibleMap.insert( std::make_pair(TauProducer_+"Matched" ,pileupTemp));

  for ( std::vector< edm::ParameterSet >::iterator it = discriminators_.begin(); it!= discriminators_.end();  it++)
  {
    string DiscriminatorLabel = it->getParameter<string>("discriminator");
    std::string histogramName;
    stripDiscriminatorLabel(DiscriminatorLabel, histogramName);

    ibooker.setCurrentFolder("RecoTauV/" +  TauProducer_ + extensionName_ + "_" +  DiscriminatorLabel );

    ptTemp    =  ibooker.book1D(DiscriminatorLabel + "_vs_ptTauVisible", histogramName +"_vs_ptTauVisible", ptHinfo.nbins, ptHinfo.min, ptHinfo.max);
    etaTemp   =  ibooker.book1D(DiscriminatorLabel + "_vs_etaTauVisible", histogramName + "_vs_etaTauVisible", etaHinfo.nbins, etaHinfo.min, etaHinfo.max );
    phiTemp   =  ibooker.book1D(DiscriminatorLabel + "_vs_phiTauVisible", histogramName + "_vs_phiTauVisible", phiHinfo.nbins, phiHinfo.min, phiHinfo.max);
    pileupTemp =  ibooker.book1D(DiscriminatorLabel + "_vs_pileupTauVisible", histogramName + "_vs_pileupTauVisible", pileupHinfo.nbins, pileupHinfo.min, pileupHinfo.max);

    ptTauVisibleMap.insert( std::make_pair(DiscriminatorLabel,ptTemp));
    etaTauVisibleMap.insert( std::make_pair(DiscriminatorLabel,etaTemp));
    phiTauVisibleMap.insert( std::make_pair(DiscriminatorLabel,phiTemp));
    pileupTauVisibleMap.insert( std::make_pair(DiscriminatorLabel,pileupTemp));

    // momentum resolution for several decay modes

    std::string plotType = "_pTRatio_";//use underscores (this allows to parse plot type in later stages)
    std::string xaxisLabel = ";p_{T}^{reco}/p_{T}^{gen}";
    std::string yaxislabel = ";Frequency";
    std::string plotName = plotType + "allHadronic";
    int bins = 40;
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 2.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "oneProng0Pi0";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 2.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "oneProng1Pi0";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 2.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "oneProng2Pi0";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 2.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "threeProng0Pi0";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 2.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "threeProng1Pi0";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 2.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );

    //size and sumPt within tau isolation

    plotType = "_Size_";
    xaxisLabel = ";size";
    yaxislabel = ";Frequency";
    bins = 20;
    plotName = plotType + "signalPFCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "signalPFChargedHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "signalPFNeutrHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );

    plotName = plotType + "isolationPFCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFChargedHadrCands";
    bins = 10;
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFNeutrHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFGammaCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, -0.5, bins-0.5);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );

    plotType = "_SumPt_";
    xaxisLabel = ";p_{T}^{sum}/ GeV";
    yaxislabel = ";Frequency";
    bins = 20;
    plotName = plotType + "signalPFCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 50.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "signalPFChargedHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 50.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "signalPFNeutrHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 50.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 50.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFChargedHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 10.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFNeutrHadrCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 30.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );
    plotName = plotType + "isolationPFGammaCands";
    tmpME = ibooker.book1D(DiscriminatorLabel + plotName, histogramName + plotName + xaxisLabel + yaxislabel, bins, 0., 20.);
    plotMap_.insert( std::make_pair( DiscriminatorLabel + plotName, tmpME ) );

    //deprecated!

    if ( DiscriminatorLabel.find("LeadingTrackPtCut") != string::npos){
      if ( TauProducer_.find("PFTau") != string::npos)
      {
        nPFJet_LeadingChargedHadron_ChargedHadronsSignal_           =ibooker.book1D(DiscriminatorLabel + "_ChargedHadronsSignal",DiscriminatorLabel + "_ChargedHadronsSignal", 21, -0.5, 20.5);
        nPFJet_LeadingChargedHadron_ChargedHadronsIsolAnnulus_    =ibooker.book1D(DiscriminatorLabel + "_ChargedHadronsIsolAnnulus",DiscriminatorLabel + "_ChargedHadronsIsolAnnulus", 21, -0.5, 20.5);
        nPFJet_LeadingChargedHadron_GammasSignal_               =ibooker.book1D(DiscriminatorLabel + "_GammasSignal",DiscriminatorLabel + "_GammasSignal",21, -0.5, 20.5);
        nPFJet_LeadingChargedHadron_GammasIsolAnnulus_          =ibooker.book1D(DiscriminatorLabel + "_GammasIsolAnnulus",DiscriminatorLabel + "_GammasIsolAnnulus",21, -0.5, 20.5);
        nPFJet_LeadingChargedHadron_NeutralHadronsSignal_           =ibooker.book1D(DiscriminatorLabel + "_NeutralHadronsSignal",DiscriminatorLabel + "_NeutralHadronsSignal",21, -0.5, 20.5);
        nPFJet_LeadingChargedHadron_NeutralHadronsIsolAnnulus_  =ibooker.book1D(DiscriminatorLabel + "_NeutralHadronsIsolAnnulus",DiscriminatorLabel + "_NeutralHadronsIsolAnnulus",21, -0.5, 20.5);
      }
    }

    if ( DiscriminatorLabel.find("ByIsolationLater") != string::npos ){
      if ( TauProducer_.find("PFTau") != string::npos)
      {
        nIsolated_NoChargedHadrons_ChargedHadronsSignal_          =ibooker.book1D(DiscriminatorLabel + "_ChargedHadronsSignal",DiscriminatorLabel + "_ChargedHadronsSignal", 21, -0.5, 20.5);
        nIsolated_NoChargedHadrons_GammasSignal_              =ibooker.book1D(DiscriminatorLabel + "_GammasSignal",DiscriminatorLabel + "_GammasSignal",21, -0.5, 20.5);
        nIsolated_NoChargedHadrons_GammasIsolAnnulus_           =ibooker.book1D(DiscriminatorLabel + "_GammasIsolAnnulus",DiscriminatorLabel + "_GammasIsolAnnulus",21, -0.5, 20.5);
        nIsolated_NoChargedHadrons_NeutralHadronsSignal_          =ibooker.book1D(DiscriminatorLabel + "_NeutralHadronsSignal",DiscriminatorLabel + "_NeutralHadronsSignal",21, -0.5, 20.5);
        nIsolated_NoChargedHadrons_NeutralHadronsIsolAnnulus_   =ibooker.book1D(DiscriminatorLabel + "_NeutralHadronsIsolAnnulus",DiscriminatorLabel + "_NeutralHadronsIsolAnnulus",21, -0.5, 20.5);
      }
    }

    if ( DiscriminatorLabel.find("ByIsolation") != string::npos ){
      if ( TauProducer_.find("PFTau") != string::npos)
      {
        nIsolated_NoChargedNoGammas_ChargedHadronsSignal_        =ibooker.book1D(DiscriminatorLabel + "_ChargedHadronsSignal",DiscriminatorLabel + "_ChargedHadronsSignal", 21, -0.5, 20.5);
        nIsolated_NoChargedNoGammas_GammasSignal_                =ibooker.book1D(DiscriminatorLabel + "_GammasSignal",DiscriminatorLabel + "_GammasSignal",21, -0.5, 20.5);
        nIsolated_NoChargedNoGammas_NeutralHadronsSignal_          =ibooker.book1D(DiscriminatorLabel + "_NeutralHadronsSignal",DiscriminatorLabel + "_NeutralHadronsSignal",21, -0.5, 20.5);
        nIsolated_NoChargedNoGammas_NeutralHadronsIsolAnnulus_   =ibooker.book1D(DiscriminatorLabel + "_NeutralHadronsIsolAnnulus",DiscriminatorLabel + "_NeutralHadronsIsolAnnulus",21, -0.5, 20.5);
      }
    }
  }
}

void TauTagValidation::dqmBeginRun ( const edm::Run &  iRun, const edm::EventSetup &  iSetup  )

virtual

Reimplemented from DQMEDAnalyzer.

Definition at line 289 of file TauTagValidation.cc.

References genericTriggerEventFlag_, GenericTriggerEventFlag::initRun(), and GenericTriggerEventFlag::on().

                                                                                  {
  if (genericTriggerEventFlag_) {
    if (genericTriggerEventFlag_->on()) {
      genericTriggerEventFlag_->initRun(iRun, iSetup);
    }
  }
}

double TauTagValidation::getSumPt ( const std::vector< edm::Ptr< reco::PFCandidate > > &  candidates )

private

sum the transversal momentum of all candidates

Definition at line 478 of file TauTagValidation.cc.

References objects.IsoTrackAnalyzer::candidates.

Referenced by analyze().

                                                                                        {
  double sumPt = 0.;
  for (std::vector<edm::Ptr<reco::PFCandidate> >::const_iterator candidate = candidates.begin(); candidate!=candidates.end(); ++candidate) {
    sumPt += (*candidate)->pt();
  }
  return sumPt;
}

bool TauTagValidation::stripDiscriminatorLabel ( const std::string &  discriminatorLabel, std::string &  newLabel  )

private

get rid of redundant parts to shorten the label

Definition at line 486 of file TauTagValidation.cc.

References prof2calltree::prefix, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by bookHistograms().

                                                                                                        {
  std::string separatorString = "DiscriminationBy";
  std::string::size_type separator = discriminatorLabel.find(separatorString);
  if(separator==std::string::npos){
    separatorString = "Discrimination";//DiscriminationAgainst, keep the 'against' here
    separator = discriminatorLabel.find(separatorString);
    if(separator==std::string::npos){
      return false;
    }
  }
  std::string prefix = discriminatorLabel.substr(0,separator);
  std::string postfix = discriminatorLabel.substr(separator+separatorString.size());
  newLabel = prefix+postfix;
  return true;
}

Member Data Documentation

PFBenchmarkAlgo* TauTagValidation::algo_

protected

Definition at line 190 of file TauTagValidation.h.

Referenced by analyze().

bool TauTagValidation::chainCuts_

private

Definition at line 193 of file TauTagValidation.h.

Referenced by analyze(), and TauTagValidation().

std::vector<edm::EDGetTokenT<reco::PFTauDiscriminator> > TauTagValidation::currentDiscriminatorToken_

private

Definition at line 113 of file TauTagValidation.h.

Referenced by analyze(), and TauTagValidation().

std::string TauTagValidation::dataType_

private

What's the reference for the Validation Leptons or Jets.

Definition at line 95 of file TauTagValidation.h.

Referenced by analyze().

std::vector< edm::ParameterSet > TauTagValidation::discriminators_

private

Definition at line 126 of file TauTagValidation.h.

Referenced by analyze(), bookHistograms(), and TauTagValidation().

std::map<std::string, MonitorElement *> TauTagValidation::etaTauVisibleMap

private

Definition at line 134 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

std::string TauTagValidation::extensionName_

private

Definition at line 117 of file TauTagValidation.h.

Referenced by bookHistograms(), and TauTagValidation().

std::string TauTagValidation::genCuts_

private

Definition at line 103 of file TauTagValidation.h.

Referenced by analyze().

GenericTriggerEventFlag* TauTagValidation::genericTriggerEventFlag_

private

generic access to dynamic trigger table

Definition at line 92 of file TauTagValidation.h.

Referenced by analyze(), dqmBeginRun(), TauTagValidation(), and ~TauTagValidation().

edm::ParameterSet TauTagValidation::histoSettings_

private

Definition at line 90 of file TauTagValidation.h.

Referenced by bookHistograms(), and TauTagValidation().

double TauTagValidation::matchDeltaR_Jets_

private

Definition at line 99 of file TauTagValidation.h.

Referenced by analyze().

double TauTagValidation::matchDeltaR_Leptons_

private

Definition at line 98 of file TauTagValidation.h.

Referenced by analyze().

std::string TauTagValidation::moduleLabel_

private

label of the current module

Definition at line 84 of file TauTagValidation.h.

Referenced by Mixins._TypedParameterizable::insertInto(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), and TauTagValidation().

MonitorElement* TauTagValidation::nCaloJet_LeadingTrack_isolationECALhitsEtSum_

private

Definition at line 172 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nCaloJet_LeadingTrack_isolationTracks_

private

Definition at line 171 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nCaloJet_LeadingTrack_signalTracks_

private

Definition at line 170 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nCaloJet_LeadingTrack_signalTracksInvariantMass_

private

Definition at line 169 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nEMIsolated_signalTracks_

private

Definition at line 183 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nEMIsolated_signalTracksInvariantMass_

private

Definition at line 182 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nIsolated_NoChargedHadrons_ChargedHadronsSignal_

private

Definition at line 152 of file TauTagValidation.h.

Referenced by bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedHadrons_GammasIsolAnnulus_

private

Definition at line 154 of file TauTagValidation.h.

Referenced by bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedHadrons_GammasSignal_

private

Definition at line 153 of file TauTagValidation.h.

Referenced by bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedHadrons_NeutralHadronsIsolAnnulus_

private

Definition at line 156 of file TauTagValidation.h.

Referenced by bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedHadrons_NeutralHadronsSignal_

private

Definition at line 155 of file TauTagValidation.h.

Referenced by bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedNoGammas_ChargedHadronsSignal_

private

Definition at line 160 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedNoGammas_GammasSignal_

private

Definition at line 161 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedNoGammas_NeutralHadronsIsolAnnulus_

private

Definition at line 163 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nIsolated_NoChargedNoGammas_NeutralHadronsSignal_

private

Definition at line 162 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nPFJet_LeadingChargedHadron_ChargedHadronsIsolAnnulus_

private

Definition at line 144 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nPFJet_LeadingChargedHadron_ChargedHadronsSignal_

private

Definition at line 143 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nPFJet_LeadingChargedHadron_GammasIsolAnnulus_

private

Definition at line 146 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nPFJet_LeadingChargedHadron_GammasSignal_

private

Definition at line 145 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nPFJet_LeadingChargedHadron_NeutralHadronsIsolAnnulus_

private

Definition at line 148 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nPFJet_LeadingChargedHadron_NeutralHadronsSignal_

private

Definition at line 147 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

MonitorElement* TauTagValidation::nTrackIsolated_isolationECALhitsEtSum_

private

Definition at line 176 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nTrackIsolated_signalTracks_

private

Definition at line 178 of file TauTagValidation.h.

MonitorElement* TauTagValidation::nTrackIsolated_signalTracksInvariantMass_

private

Definition at line 177 of file TauTagValidation.h.

int TauTagValidation::numEvents_

private

Definition at line 186 of file TauTagValidation.h.

Referenced by analyze(), and TauTagValidation().

std::string TauTagValidation::outPutFile_

private

Definition at line 131 of file TauTagValidation.h.

Referenced by TauTagValidation().

std::map<std::string, MonitorElement *> TauTagValidation::phiTauVisibleMap

private

Definition at line 135 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

std::map<std::string, MonitorElement *> TauTagValidation::pileupTauVisibleMap

private

Definition at line 136 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

std::map<std::string, MonitorElement *> TauTagValidation::plotMap_

private

Definition at line 137 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

edm::InputTag TauTagValidation::PrimaryVertexCollection_

private

Definition at line 120 of file TauTagValidation.h.

Referenced by TauTagValidation().

edm::EDGetTokenT<reco::VertexCollection> TauTagValidation::primaryVertexCollectionToken_

private

Definition at line 112 of file TauTagValidation.h.

Referenced by analyze(), and TauTagValidation().

std::map<std::string, MonitorElement *> TauTagValidation::ptTauVisibleMap

private

Definition at line 133 of file TauTagValidation.h.

Referenced by analyze(), and bookHistograms().

std::string TauTagValidation::recoCuts_

private

Definition at line 103 of file TauTagValidation.h.

Referenced by analyze().

std::string TauTagValidation::refCollection_

private

Definition at line 114 of file TauTagValidation.h.

Referenced by analyze(), bookHistograms(), and TauTagValidation().

edm::InputTag TauTagValidation::refCollectionInputTag_

private

Definition at line 109 of file TauTagValidation.h.

Referenced by TauTagValidation().

edm::EDGetTokenT<edm::View<reco::Candidate> > TauTagValidation::refCollectionInputTagToken_

private

Definition at line 110 of file TauTagValidation.h.

Referenced by analyze(), and TauTagValidation().

bool TauTagValidation::saveoutputhistograms_

private

Definition at line 106 of file TauTagValidation.h.

Referenced by TauTagValidation().

std::string TauTagValidation::TauProducer_

private

Definition at line 121 of file TauTagValidation.h.

Referenced by analyze(), bookHistograms(), and TauTagValidation().

edm::InputTag TauTagValidation::TauProducerInputTag_

private

Definition at line 120 of file TauTagValidation.h.

Referenced by TauTagValidation().

edm::EDGetTokenT<reco::PFTauCollection> TauTagValidation::tauProducerInputTagToken_

private

Definition at line 111 of file TauTagValidation.h.

Referenced by analyze(), and TauTagValidation().

double TauTagValidation::TauPtCut_

private

Definition at line 100 of file TauTagValidation.h.

Referenced by analyze().

bool TauTagValidation::turnOnTrigger_

private

Definition at line 106 of file TauTagValidation.h.

Referenced by TauTagValidation().

std::string TauTagValidation::tversion

private

Definition at line 130 of file TauTagValidation.h.

Referenced by TauTagValidation().