TriggerValidator Class Reference

#include <HLTriggerOffline/SUSYBSM/src/TriggerValidator.cc>

Inheritance diagram for TriggerValidator:

Public Member Functions
	TriggerValidator (const edm::ParameterSet &)
	~TriggerValidator ()
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
virtual	~EDAnalyzer ()
Public Member Functions inherited from edm::EDConsumerBase
	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
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Public Attributes
TFile *	theHistoFile

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
void	beginRun (const edm::Run &run, const edm::EventSetup &c)
virtual void	endJob ()
void	endRun (const edm::Run &run, const edm::EventSetup &c)

Private Attributes
DQMStore *	dbe_
std::string	dirname_
std::vector< double >	effHltAfterMcCuts
std::vector< double >	effHltAfterRecoCuts
std::vector< double >	effHltBeforeCuts
std::vector< double >	effL1AfterMcCuts
std::vector< double >	effL1AfterRecoCuts
std::vector< double >	effL1BeforeCuts
bool	firstEvent
edm::EDGetTokenT < L1GlobalTriggerReadoutRecord >	gtDigis_token_
std::vector< MonitorElement * >	hHltBitsAfterMcCuts
std::vector< MonitorElement * >	hHltBitsAfterRecoCuts
MonitorElement *	hHltBitsBeforeCuts
std::vector< MonitorElement * >	hHltPathsAfterMcCuts
std::vector< MonitorElement * >	hHltPathsAfterRecoCuts
MonitorElement *	hHltPathsBeforeCuts
std::string	HistoFileName
std::vector< MonitorElement * >	hL1BitsAfterMcCuts
std::vector< MonitorElement * >	hL1BitsAfterRecoCuts
MonitorElement *	hL1BitsBeforeCuts
std::vector< MonitorElement * >	hL1PathsAfterMcCuts
std::vector< MonitorElement * >	hL1PathsAfterRecoCuts
MonitorElement *	hL1PathsBeforeCuts
std::vector< std::string >	hlNames_
edm::EDGetTokenT < edm::TriggerResults >	hlt_token_
std::vector< int >	hltbits
HLTConfigProvider	hltConfig_
edm::InputTag	hltLabel
std::vector< std::string >	hltPathsToCheck_
std::vector< int >	l1bits
bool	l1Flag
edm::EDGetTokenT < L1GlobalTriggerObjectMapRecord >	l1Label
std::map< int, std::string >	l1NameMap
std::vector< std::string >	l1Names_
std::vector< edm::ParameterSet >	mc_parametersets
bool	mcFlag
std::string	mcSelBitsDir
edm::InputTag	muonTag_
std::vector< McSelector * >	myMcSelector
MuonAnalyzerSBSM *	myMuonAnalyzer
PlotMakerL1 *	myPlotMakerL1
PlotMakerReco *	myPlotMakerReco
std::vector< RecoSelector * >	myRecoSelector
std::vector< int >	nEvMcSelected
std::vector< int >	nEvRecoSelected
int	nEvTot
unsigned int	nHltPaths
int	nL1Bits
std::vector< std::vector< int > >	numTotHltBitsAfterMcCuts
std::vector< std::vector< int > >	numTotHltBitsAfterRecoCuts
std::vector< int >	numTotHltBitsBeforeCuts
std::vector< std::vector< int > >	numTotL1BitsAfterMcCuts
std::vector< std::vector< int > >	numTotL1BitsAfterRecoCuts
std::vector< int >	numTotL1BitsBeforeCuts
edm::ParameterSet	plotMakerL1Input
edm::ParameterSet	plotMakerRecoInput
std::string	processName_
std::vector< edm::ParameterSet >	reco_parametersets
std::string	recoSelBitsDir
std::string	StatFileName
std::string	triggerBitsDir
edm::InputTag	triggerTag_
edm::ParameterSet	turnOn_params
std::vector< std::vector< int > >	vCorrHlt
std::vector< std::vector< int > >	vCorrL1
std::vector< std::vector < double > >	vCorrNormHlt
std::vector< std::vector < double > >	vCorrNormL1

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
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::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: Class to validate the Trigger Performance of the SUSYBSM group

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

Definition at line 61 of file TriggerValidator.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 75 of file TriggerValidator.cc.

References edm::ParameterSet::addParameter(), edm::EDConsumerBase::consumesCollector(), dbe_, dirname_, edm::ParameterSet::getUntrackedParameter(), i, l1Flag, LogDebug, mc_parametersets, mcFlag, mcSelBitsDir, muonTag_, myMcSelector, myMuonAnalyzer, myPlotMakerL1, myPlotMakerReco, myRecoSelector, nEvMcSelected, nEvRecoSelected, nEvTot, nHltPaths, nL1Bits, cppFunctionSkipper::operator, plotMakerL1Input, plotMakerRecoInput, reco_parametersets, recoSelBitsDir, DQMStore::setCurrentFolder(), DQMStore::setVerbose(), AlCaHLTBitMon_QueryRunRegistry::string, theHistoFile, triggerBitsDir, and triggerTag_.

                                                                :
  dirname_(iConfig.getUntrackedParameter("dirname",
                          std::string("HLT/SusyExo"))),
  HistoFileName(iConfig.getUntrackedParameter("histoFileName",
                          std::string("SusyBsmTriggerValidation.root"))),
  StatFileName(iConfig.getUntrackedParameter("statFileName",
                          std::string("SusyBsmTriggerValidation.stat"))),
  l1Label(consumes<L1GlobalTriggerObjectMapRecord>(iConfig.getParameter<edm::InputTag>("L1Label"))),
  hltLabel(iConfig.getParameter<edm::InputTag>("HltLabel")),
  hlt_token_(consumes<TriggerResults>(iConfig.getParameter<edm::InputTag>("HltLabel"))),
  mcFlag(iConfig.getUntrackedParameter<bool>("mc_flag",false)),
  l1Flag(iConfig.getUntrackedParameter<bool>("l1_flag",false)),
  reco_parametersets(iConfig.getParameter<VParameterSet>("reco_parametersets")),
  mc_parametersets(iConfig.getParameter<VParameterSet>("mc_parametersets")),
  turnOn_params(iConfig.getParameter<ParameterSet>("TurnOnParams")),
  plotMakerL1Input(iConfig.getParameter<ParameterSet>("PlotMakerL1Input")),
  plotMakerRecoInput(iConfig.getParameter<ParameterSet>("PlotMakerRecoInput")),
  muonTag_(iConfig.getParameter<edm::InputTag>("muonTag")),
  triggerTag_(iConfig.getParameter<edm::InputTag>("triggerTag")),
  processName_(iConfig.getParameter<std::string>("hltConfigName")),
  hltPathsToCheck_(iConfig.getParameter<vector<string>>("hltPathsToCheck")),
  gtDigis_token_(consumes<L1GlobalTriggerReadoutRecord>(iConfig.getUntrackedParameter<edm::InputTag>("gtDigis",edm::InputTag("gtDigis"))))
{
  //now do what ever initialization is needed
  theHistoFile = 0;
  nEvTot = 0;
  for(unsigned int i=0; i<reco_parametersets.size(); ++i) nEvRecoSelected.push_back(0);
  for(unsigned int i=0; i<mc_parametersets.size(); ++i) nEvMcSelected.push_back(0);

  nHltPaths = 0;
  nL1Bits = 0;

  // --- set the names in the dbe folders ---
  triggerBitsDir = "/TriggerBits";
  recoSelBitsDir = "/RecoSelection"; 
  mcSelBitsDir = "/McSelection";      


  LogDebug("TriggerValidator") << "constructor...." ;

  dbe_ = Service < DQMStore > ().operator->();
  if ( ! dbe_ ) {
    LogInfo("TriggerValidator") << "unabel to get DQMStore service?";
  }
  if (iConfig.getUntrackedParameter < bool > ("DQMStore", false)) {
    dbe_->setVerbose(0);
  }
  
  if (dbe_ != 0 ) {
    dbe_->setCurrentFolder(dirname_);
  }


   plotMakerL1Input.addParameter<std::string>("dirname",dirname_);
   plotMakerRecoInput.addParameter<std::string>("dirname",dirname_);

  //pass consumes list to the helper classes
  for(unsigned int i=0; i<reco_parametersets.size(); ++i) myRecoSelector.push_back(new RecoSelector(reco_parametersets[i], consumesCollector()));
  if(mcFlag) for(unsigned int i=0; i<mc_parametersets.size(); ++i) myMcSelector.push_back(new McSelector(mc_parametersets[i], consumesCollector()));
  if(l1Flag) myPlotMakerL1     = new PlotMakerL1(plotMakerL1Input, consumesCollector());
  myPlotMakerReco   = new PlotMakerReco(plotMakerRecoInput, consumesCollector());
  myMuonAnalyzer = new MuonAnalyzerSBSM(triggerTag_, muonTag_, consumesCollector());
}

TriggerValidator::~TriggerValidator

(

)

Definition at line 140 of file TriggerValidator.cc.

{
 
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)

}

Member Function Documentation

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

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 155 of file TriggerValidator.cc.

References PlotMakerL1::bookHistos(), PlotMakerReco::bookHistos(), dbe_, edm::InputTag::encode(), MonitorElement::Fill(), MuonAnalyzerSBSM::FillPlots(), PlotMakerL1::fillPlots(), PlotMakerReco::fillPlots(), firstEvent, edm::Event::getByToken(), gtDigis_token_, hHltBitsAfterMcCuts, hHltBitsAfterRecoCuts, hHltBitsBeforeCuts, hHltPathsAfterMcCuts, hHltPathsAfterRecoCuts, hHltPathsBeforeCuts, hL1BitsAfterMcCuts, hL1BitsAfterRecoCuts, hL1BitsBeforeCuts, hL1PathsAfterMcCuts, hL1PathsAfterRecoCuts, hL1PathsBeforeCuts, hlNames_, hlt_token_, hltbits, hltConfig_, hltLabel, i, j, l1bits, l1Flag, l1Label, l1NameMap, l1Names_, LogDebug, mc_parametersets, mcFlag, myMcSelector, myMuonAnalyzer, myPlotMakerL1, myPlotMakerReco, myRecoSelector, nEvMcSelected, nEvRecoSelected, nEvTot, numTotHltBitsAfterMcCuts, numTotHltBitsAfterRecoCuts, numTotHltBitsBeforeCuts, numTotL1BitsAfterMcCuts, numTotL1BitsAfterRecoCuts, numTotL1BitsBeforeCuts, reco_parametersets, MonitorElement::setBinLabel(), HLTConfigProvider::size(), AlCaHLTBitMon_QueryRunRegistry::string, HLTConfigProvider::triggerIndex(), vCorrHlt, vCorrL1, vCorrNormHlt, and vCorrNormL1.

{

  using namespace edm;
  
  nEvTot++;
  
  vector<bool> eventRecoSelected, eventMcSelected;
  eventRecoSelected.resize(reco_parametersets.size());
  eventMcSelected.resize(mc_parametersets.size());
  for(unsigned int i=0; i<eventRecoSelected.size(); ++i) eventRecoSelected[i] =  myRecoSelector[i]->isSelected(iEvent);
  for(unsigned int i=0; i<eventMcSelected.size(); ++i) eventMcSelected[i] = mcFlag ? myMcSelector[i]->isSelected(iEvent) : false;

  for(unsigned int i=0; i<nEvRecoSelected.size(); ++i) if(eventRecoSelected[i]) nEvRecoSelected[i]++;
  for(unsigned int i=0; i<nEvMcSelected.size(); ++i) if(eventMcSelected[i]) nEvMcSelected[i]++;
  
  
  // ******************************************************** 
  // Get the L1 Info
  // ********************************************************    
  Handle<L1GlobalTriggerReadoutRecord> L1GTRR;
  iEvent.getByToken(gtDigis_token_,L1GTRR);
  if (!L1GTRR.isValid()) {edm::LogWarning("Readout Error|L1") << "L1ParticleMapCollection Not Valid!";}
  int nL1size = L1GTRR->decisionWord().size();
  if(firstEvent) {

    //this piece of code concerns efficiencies
    //it must be moved to the client

//     //resize the eff and overlap vectors ccording to the number of L1 paths
//     effL1BeforeCuts.resize(L1GTRR->decisionWord().size()+1);
//     effL1AfterRecoCuts.resize(L1GTRR->decisionWord().size()+1);
//     effL1AfterMcCuts.resize(L1GTRR->decisionWord().size()+1);
     vCorrL1.resize(L1GTRR->decisionWord().size());
    for(unsigned int i=0; i<L1GTRR->decisionWord().size(); i++) {vCorrL1[i].resize(L1GTRR->decisionWord().size());}
    vCorrNormL1.resize(L1GTRR->decisionWord().size());
    for(unsigned int i=0; i<L1GTRR->decisionWord().size(); i++) {vCorrNormL1[i].resize(L1GTRR->decisionWord().size());}


    //Get the names of the L1 paths
    //for the moment the names are not included in L1GlobalTriggerReadoutRecord
    //we need to use L1GlobalTriggerObjectMapRecord
    edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
    iEvent.getByToken(l1Label, gtObjectMapRecord);
     const std::vector<L1GlobalTriggerObjectMap>& objMapVec =
      gtObjectMapRecord->gtObjectMap();
     for (std::vector<L1GlobalTriggerObjectMap>::const_iterator itMap = objMapVec.begin();
     itMap != objMapVec.end(); ++itMap) {
      int algoBit = (*itMap).algoBitNumber();
       std::string algoNameStr = (*itMap).algoName();
       l1NameMap[algoBit] = algoNameStr;
    }
    //resize the name vector and get the names
    l1Names_.resize(L1GTRR->decisionWord().size()+1);
    for (unsigned int i=0; i!=L1GTRR->decisionWord().size(); i++) {    
      l1Names_[i]=l1NameMap[i];
    }
    l1Names_[L1GTRR->decisionWord().size()] = "Total";
    
    //set the names of the bins for the "path" histos
    for(unsigned int i=0; i<l1Names_.size(); ++i) {
      hL1PathsBeforeCuts->setBinLabel(i+1,l1Names_[i].c_str(),1);
      for(unsigned int j=0; j<hL1PathsAfterRecoCuts.size(); ++j) hL1PathsAfterRecoCuts[j]->setBinLabel(i+1,l1Names_[i].c_str(),1);
      for(unsigned int j=0; j<hL1PathsAfterMcCuts.size(); ++j) hL1PathsAfterMcCuts[j]->setBinLabel(i+1,l1Names_[i].c_str(),1);
    }
  }
  
 //fill the eff vectors and histos for L1
  for (int i=0; i<nL1size; ++i) {
    l1bits.push_back(L1GTRR->decisionWord()[i]);
    if(L1GTRR->decisionWord()[i]) {
      numTotL1BitsBeforeCuts[i]++;
      hL1BitsBeforeCuts->Fill(i);
      hL1PathsBeforeCuts->Fill(i);
      for(unsigned int j=0; j<eventRecoSelected.size(); ++j)
    if(eventRecoSelected[j]) {
      numTotL1BitsAfterRecoCuts[j][i]++;
      hL1BitsAfterRecoCuts[j]->Fill(i);
      hL1PathsAfterRecoCuts[j]->Fill(i);
    }
      for(unsigned int j=0; j<eventMcSelected.size(); ++j)
    if(eventMcSelected[j]) {
      numTotL1BitsAfterMcCuts[j][i]++;
      hL1BitsAfterMcCuts[j]->Fill(i);
      hL1PathsAfterMcCuts[j]->Fill(i);
    }
    }      
  }

  //Calculate the overlap among l1 bits
  for(int i=0; i<nL1size; ++i) {
    for(int j=0; j<nL1size; ++j) {
      if(l1bits[i]*l1bits[j]) vCorrL1[i][j]++;
    }
  }

  //fill the last bin with the total of events
  numTotL1BitsBeforeCuts[nL1size]++;
  hL1BitsBeforeCuts->Fill(nL1size);
  hL1PathsBeforeCuts->Fill(nL1size);
  for(unsigned int i=0; i<eventRecoSelected.size(); ++i)
    if(eventRecoSelected[i]) {
      numTotL1BitsAfterRecoCuts[i][nL1size]++;
      hL1BitsAfterRecoCuts[i]->Fill(nL1size);
      hL1PathsAfterRecoCuts[i]->Fill(nL1size);
    }
  for(unsigned int i=0; i<eventMcSelected.size(); ++i)
    if(eventMcSelected[i]) {
      numTotL1BitsAfterMcCuts[i][nL1size]++;
      hL1BitsAfterMcCuts[i]->Fill(nL1size);
      hL1PathsAfterMcCuts[i]->Fill(nL1size);
    }


  // ******************************************************** 
  // Get the HLT Info
  // ******************************************************** 
  edm::Handle<TriggerResults> trhv;
  iEvent.getByToken(hlt_token_,trhv);
  if( ! trhv.isValid() ) {
    LogDebug("SUSYBSM") << "HL TriggerResults with label ["+hltLabel.encode()+"] not found!";
    return;
  }  

  if(firstEvent) {

    vCorrHlt.resize(hlNames_.size());
    for(unsigned int i=0; i<hlNames_.size(); i++) {vCorrHlt[i].resize(hlNames_.size());}
    vCorrNormHlt.resize(hlNames_.size());
    for(unsigned int i=0; i<hlNames_.size(); i++) {vCorrNormHlt[i].resize(hlNames_.size());}

    //set the bin names for the "path" histos
    for(unsigned int i=0; i < hlNames_.size(); i++) {
      hHltPathsBeforeCuts->setBinLabel(i+1,hlNames_[i].c_str(),1);
      for(unsigned int j=0; j<hHltPathsAfterRecoCuts.size(); ++j) hHltPathsAfterRecoCuts[j]->setBinLabel(i+1,hlNames_[i].c_str(),1);
      for(unsigned int j=0; j<hHltPathsAfterMcCuts.size(); ++j) hHltPathsAfterMcCuts[j]->setBinLabel(i+1,hlNames_[i].c_str(),1);
    }
  }

  //fill the eff vectors and histos for HLT
  for(unsigned int i=0; i < hlNames_.size(); i++) {
    const unsigned int path_index(hltConfig_.triggerIndex(hlNames_[i]));
    if ( path_index < hltConfig_.size() ){
      hltbits.push_back(trhv->at(path_index).accept());
      if( trhv->at(path_index).accept() ) {
        numTotHltBitsBeforeCuts[i]++;
        hHltBitsBeforeCuts->Fill(i);
        hHltPathsBeforeCuts->Fill(i);
        for(unsigned int j=0; j<eventRecoSelected.size(); ++j)
          if(eventRecoSelected[j]) {
            numTotHltBitsAfterRecoCuts[j][i]++;
            hHltBitsAfterRecoCuts[j]->Fill(i);
            hHltPathsAfterRecoCuts[j]->Fill(i);
          }
        for(unsigned int j=0; j<eventMcSelected.size(); ++j)
      if(eventMcSelected[j]) {
        numTotHltBitsAfterMcCuts[j][i]++;
        hHltBitsAfterMcCuts[j]->Fill(i);
        hHltPathsAfterMcCuts[j]->Fill(i);
      }
      }      
    }
  }

  //Calculate the overlap among HLT paths
  for(unsigned int i=0; i< hltbits.size(); i++) {
    for(unsigned int j=0; j< hltbits.size(); j++) {
      if(hltbits[i]*hltbits[j]) vCorrHlt[i][j]++;
    }
  }

  //fill the last bin with the total of events
  numTotHltBitsBeforeCuts[hlNames_.size()]++;
  hHltBitsBeforeCuts->Fill(hlNames_.size());
  hHltPathsBeforeCuts->Fill(hlNames_.size());
  for(unsigned int i=0; i<eventRecoSelected.size(); ++i)
    if(eventRecoSelected[i]) {
      numTotHltBitsAfterRecoCuts[i][hlNames_.size()]++;
      hHltBitsAfterRecoCuts[i]->Fill(hlNames_.size());
      hHltPathsAfterRecoCuts[i]->Fill(hlNames_.size());
    }
  for(unsigned int i=0; i<eventMcSelected.size(); ++i)
    if(eventMcSelected[i]) {
      numTotHltBitsAfterMcCuts[i][hlNames_.size()]++;
      hHltBitsAfterMcCuts[i]->Fill(hlNames_.size());
      hHltPathsAfterMcCuts[i]->Fill(hlNames_.size());
    }



  if(firstEvent) {
    if(l1Flag) myPlotMakerL1->bookHistos(dbe_,&l1bits,&hltbits,&l1Names_,&hlNames_);
    myPlotMakerReco->bookHistos(dbe_,&l1bits,&hltbits,&l1Names_,&hlNames_);
    //    myTurnOnMaker->bookHistos();
  }
  if(l1Flag) myPlotMakerL1->fillPlots(iEvent);
  myPlotMakerReco->fillPlots(iEvent);
  //  myTurnOnMaker->fillPlots(iEvent);

  firstEvent = false;

  myMuonAnalyzer->FillPlots(iEvent, iSetup);
  l1bits.clear();
  hltbits.clear();
}

void TriggerValidator::beginJob ( void  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 362 of file TriggerValidator.cc.

                               {
}

void TriggerValidator::beginRun ( const edm::Run &  run, const edm::EventSetup &  c  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 368 of file TriggerValidator.cc.

References DQMStore::book1D(), dbe_, dirname_, firstEvent, getTH1F(), MonitorElement::getTH1F(), hHltBitsAfterMcCuts, hHltBitsAfterRecoCuts, hHltBitsBeforeCuts, hHltPathsAfterMcCuts, hHltPathsAfterRecoCuts, hHltPathsBeforeCuts, hL1BitsAfterMcCuts, hL1BitsAfterRecoCuts, hL1BitsBeforeCuts, hL1PathsAfterMcCuts, hL1PathsAfterRecoCuts, hL1PathsBeforeCuts, hlNames_, hltConfig_, hltPathsToCheck_, i, HLTConfigProvider::init(), MuonAnalyzerSBSM::InitializePlots(), j, mc_parametersets, mcSelBitsDir, myMcSelector, myMuonAnalyzer, myRecoSelector, nHltPaths, nL1Bits, numTotHltBitsAfterMcCuts, numTotHltBitsAfterRecoCuts, numTotHltBitsBeforeCuts, numTotL1BitsAfterMcCuts, numTotL1BitsAfterRecoCuts, numTotL1BitsBeforeCuts, cppFunctionSkipper::operator, create_public_lumi_plots::path_name, listBenchmarks::pattern, processName_, reco_parametersets, recoSelBitsDir, DQMStore::rmdir(), DQMStore::setCurrentFolder(), triggerBitsDir, and HLTConfigProvider::triggerNames().

{


  DQMStore *dbe_ = 0;
  dbe_ = Service<DQMStore>().operator->();
  
  if (dbe_) {
    dbe_->setCurrentFolder(dirname_);
    dbe_->rmdir(dirname_);
  }
  
  if (dbe_) {
    dbe_->setCurrentFolder(dirname_);
  }  
  
 // Initialize hltConfig
  bool changed;
  if (!hltConfig_.init(run,c,processName_,changed)) {
    LogError("SUSYBSM") << "Initialization of HLTConfigProvider failed!!";
    return;
  }


  // Get the set of trigger paths we want to make plots for
  for (size_t i = 0; i < hltPathsToCheck_.size(); i++) {
    TPRegexp pattern(hltPathsToCheck_[i]);
    for (size_t j = 0; j < hltConfig_.triggerNames().size(); j++)
      if (TString(hltConfig_.triggerNames()[j]).Contains(pattern))
        hlNames_.push_back(hltConfig_.triggerNames()[j]);
  }
  hlNames_.push_back("Total");
  nHltPaths = hlNames_.size();  

  nL1Bits = 128; 

  firstEvent = true;

  //resize the vectors according to the number of L1 paths
  numTotL1BitsBeforeCuts.resize(nL1Bits+1);
  numTotL1BitsAfterRecoCuts.resize(reco_parametersets.size());
  for(unsigned int i=0; i<numTotL1BitsAfterRecoCuts.size(); ++i) numTotL1BitsAfterRecoCuts[i].resize(nL1Bits+1);
  numTotL1BitsAfterMcCuts.resize(mc_parametersets.size());
  for(unsigned int i=0; i<numTotL1BitsAfterMcCuts.size(); ++i) numTotL1BitsAfterMcCuts[i].resize(nL1Bits+1);

  //resize the vectors according to the number of HLT paths
  numTotHltBitsBeforeCuts.resize(nHltPaths+1);
  numTotHltBitsAfterRecoCuts.resize(reco_parametersets.size());
  for(unsigned int i=0; i<numTotHltBitsAfterRecoCuts.size(); ++i) numTotHltBitsAfterRecoCuts[i].resize(nHltPaths+1);
  numTotHltBitsAfterMcCuts.resize(mc_parametersets.size());
  for(unsigned int i=0; i<numTotHltBitsAfterMcCuts.size(); ++i) numTotHltBitsAfterMcCuts[i].resize(nHltPaths+1);
  
  if (dbe_) {
    dbe_->setCurrentFolder(dirname_);
    dbe_->rmdir(dirname_);
  }
  
  
  if (dbe_) {
    dbe_->setCurrentFolder(dirname_);
    }
  
  dbe_->setCurrentFolder(dirname_+triggerBitsDir);
  //add 1 bin for the Total
  hL1BitsBeforeCuts  = dbe_->book1D("L1Bits", "L1 Trigger Bits",nL1Bits+1, 0, nL1Bits+1);    
  hHltBitsBeforeCuts = dbe_->book1D("HltBits","HL Trigger Bits",nHltPaths+1, 0, nHltPaths+1);

  for(unsigned int i=0; i<myRecoSelector.size(); ++i)
    {
      string path_name = myRecoSelector[i]->GetName();
      char histo_name[256], histo_title[256];
      //sprintf(histo_name, "L1Bits");
      sprintf(histo_name, "L1Bits_%s", path_name.c_str());
      sprintf(histo_title, "L1 Trigger Bits for %s Selection", path_name.c_str());
      dbe_->setCurrentFolder(dirname_+recoSelBitsDir+"/"+path_name);   
      hL1BitsAfterRecoCuts.push_back(dbe_->book1D(histo_name, histo_title, nL1Bits+1, 0, nL1Bits+1));   
      //sprintf(histo_name, "HltBits");
      sprintf(histo_name, "HltBits_%s", path_name.c_str());
      sprintf(histo_title, "HL Trigger Bits for %s Selection", path_name.c_str()); 
      hHltBitsAfterRecoCuts.push_back(dbe_->book1D(histo_name, histo_title, nHltPaths+1, 0, nHltPaths+1));
    }
  for(unsigned int i=0; i<myMcSelector.size(); ++i)
    {
      string path_name = myMcSelector[i]->GetName();
      char histo_name[256], histo_title[256];
      //sprintf(histo_name, "L1Bits");
      sprintf(histo_name, "L1Bits_%s", path_name.c_str());
      sprintf(histo_title, "L1 Trigger Bits for %s Selection", path_name.c_str());
      dbe_->setCurrentFolder(dirname_+mcSelBitsDir+"/"+path_name);   
      hL1BitsAfterMcCuts.push_back(dbe_->book1D(histo_name, histo_title, nL1Bits+1, 0, nL1Bits+1));
      //sprintf(histo_name, "HltBits");
      sprintf(histo_name, "HltBits_%s", path_name.c_str());
      sprintf(histo_title, "HL Trigger Bits for %s Selection", path_name.c_str()); 
      hHltBitsAfterMcCuts.push_back(dbe_->book1D(histo_name, histo_title, nHltPaths+1, 0, nHltPaths+1));
    }

  //create the histos with paths
  //identical to the ones with "bits"
  //but with the names in the x axis
  //instead of the numbers

  dbe_->setCurrentFolder(dirname_+triggerBitsDir);
  TH1F* hTemp = (TH1F*) (hL1BitsBeforeCuts->getTH1F())->Clone("L1Paths");
  hL1PathsBeforeCuts  = dbe_->book1D("L1Paths", hTemp);
  hTemp = (TH1F*) (hHltBitsBeforeCuts->getTH1F())->Clone("HltPaths");
  hHltPathsBeforeCuts = dbe_->book1D("HltPaths", hTemp);

  for(unsigned int i=0; i<myRecoSelector.size(); ++i)
    {
      string path_name = myRecoSelector[i]->GetName();
      char histo_name[256];
      sprintf(histo_name, "L1Paths_%s", path_name.c_str());
      dbe_->setCurrentFolder(dirname_+recoSelBitsDir+"/"+path_name);
      hTemp = (TH1F*) (hL1BitsAfterRecoCuts[i]->getTH1F())->Clone(histo_name);
      hL1PathsAfterRecoCuts.push_back(dbe_->book1D(histo_name, hTemp));
      sprintf(histo_name, "HltPaths_%s", path_name.c_str());
      hTemp = (TH1F*) (hHltBitsAfterRecoCuts[i]->getTH1F())->Clone(histo_name);
      hHltPathsAfterRecoCuts.push_back(dbe_->book1D(histo_name, hTemp));
    }

  for(unsigned int i=0; i<myMcSelector.size(); ++i)
    {
      string path_name = myMcSelector[i]->GetName();
      char histo_name[256];
      sprintf(histo_name, "L1Paths_%s", path_name.c_str());
      dbe_->setCurrentFolder(dirname_+mcSelBitsDir+"/"+path_name);
      hTemp = (TH1F*) (hL1BitsAfterMcCuts[i]->getTH1F())->Clone(histo_name);
      hL1PathsAfterMcCuts.push_back(dbe_->book1D(histo_name, hTemp));
      sprintf(histo_name, "HltPaths_%s", path_name.c_str());
      hTemp = (TH1F*) (hHltBitsAfterMcCuts[i]->getTH1F())->Clone(histo_name);
      hHltPathsAfterMcCuts.push_back(dbe_->book1D(histo_name, hTemp));
    }

  myMuonAnalyzer->InitializePlots(dbe_, dirname_);
}

void TriggerValidator::endJob ( void  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 780 of file TriggerValidator.cc.

{
  LogInfo("TriggerValidator") << "endJob";
   return;
}

void TriggerValidator::endRun ( const edm::Run &  run, const edm::EventSetup &  c  )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 509 of file TriggerValidator.cc.

References hlNames_, i, l1Flag, l1Names_, mcFlag, myMcSelector, myPlotMakerL1, myPlotMakerReco, myRecoSelector, and n.

{

  //  myTurnOnMaker->finalOperations();

  //This piece of code concerns efficiencies
  //it must be moved to the client
  


//   //calculate the final efficiencies and the normalizations
//   for(unsigned int i=0; i<numTotL1BitsBeforeCuts.size()-1; i++) {
//     effL1BeforeCuts[i] = (double)numTotL1BitsBeforeCuts[i]/(double)nEvTot;
//     for(unsigned int j=0; j<numTotL1BitsBeforeCuts.size()-1; j++) {
//       vCorrNormL1[i][j] = (double)vCorrL1[i][j]/(double)nEvTot;
//     }
//   }

//   for(unsigned int i=0; i<numTotHltBitsBeforeCuts.size()-1; i++) {
//     effHltBeforeCuts[i] = (double)numTotHltBitsBeforeCuts[i]/(double)nEvTot;
//     for(unsigned int j=0; j<numTotHltBitsBeforeCuts.size()-1; j++) {
//       vCorrNormHlt[i][j] = (double)vCorrHlt[i][j]/(double)nEvTot;
//     }
//   }

//   //after the reco cuts

//   if(nEvRecoSelected) {
//     for(unsigned int i=0; i<numTotL1BitsAfterRecoCuts.size()-1; i++) {
//       effL1AfterRecoCuts[i] = (double)numTotL1BitsAfterRecoCuts[i]/(double)nEvRecoSelected;
//     }
    
//     for(unsigned int i=0; i<numTotHltBitsAfterRecoCuts.size()-1; i++) {
//       effHltAfterRecoCuts[i] = (double)numTotHltBitsAfterRecoCuts[i]/(double)nEvRecoSelected;
//     }
//   } else {
    
//     for(unsigned int i=0; i<numTotL1BitsAfterRecoCuts.size()-1; i++) {
//       effL1AfterRecoCuts[i] = -1;
//     }
    
//     for(unsigned int i=0; i<numTotHltBitsAfterRecoCuts.size()-1; i++) {
//       effHltAfterRecoCuts[i] = -1;
//     }
//   }


//   //after the mc cuts
//   if(nEvMcSelected) {
//     for(unsigned int i=0; i<numTotL1BitsAfterMcCuts.size()-1; i++) {
//       effL1AfterMcCuts[i] = (double)numTotL1BitsAfterMcCuts[i]/(double)nEvMcSelected;
//     }
    
//     for(unsigned int i=0; i<numTotHltBitsAfterMcCuts.size()-1; i++) {
//       effHltAfterMcCuts[i] = (double)numTotHltBitsAfterMcCuts[i]/(double)nEvMcSelected;
//     }
//   } else {
//     for(unsigned int i=0; i<numTotL1BitsAfterMcCuts.size()-1; i++) {
//       effL1AfterMcCuts[i] = -1;
//     }
    
//     for(unsigned int i=0; i<numTotHltBitsAfterMcCuts.size()-1; i++) {
//       effHltAfterMcCuts[i] = -1;
//     }
//   }    








//   myPlotMaker->writeHistos();
//   myTurnOnMaker->writeHistos();


  //  using namespace std;

  unsigned int n(l1Names_.size());

  n = l1Names_.size();
  edm::LogInfo("L1TableSummary") << endl;
  edm::LogVerbatim("L1TableSummary") << "L1T-Table "
       << right << setw(10) << "L1T  Bit#" << " "
       << "Name" << "\n";
  for (unsigned int i=0; i!=n; i++) {
    edm::LogVerbatim("L1TableSummary") << right << setw(20) << i << " "
     << l1Names_[i] << "\n";
  }
  
  
  n = hlNames_.size();
  edm::LogInfo("HltTableSummary") << endl;
  edm::LogVerbatim("HltTableSummary") << "HLT-Table "
       << right << setw(10) << "HLT  Bit#" << " "
       << "Name" << "\n";
  
  for (unsigned int i=0; i!=n; i++) {
     edm::LogVerbatim("HltTableSummary") << right << setw(20) << i << " "
     << hlNames_[i] << "\n";
  }
  
  edm::LogVerbatim("HltTableSummary") << endl;
  edm::LogVerbatim("HltTableSummary") << "HLT-Table end!" << endl;
  edm::LogVerbatim("HltTableSummary") << endl;
  

 
  //the stat file with the efficiecies has to be moved to the client



//  //Print in a stat file the efficiencies and the overlaps
 
 
//   ofstream statFile(StatFileName.c_str(),ios::out);


//   statFile << "*********************************************************************************" << endl;
//   statFile << "*********************************************************************************" << endl;
//   statFile << "                                   L1 Efficiencies                               " << endl;
//   statFile << "*********************************************************************************" << endl;
//   statFile << "*********************************************************************************" << endl;
//   statFile << endl;
//   statFile << "---------------------------------------------------------------------------------" << endl;
//   statFile << "---------------------------------------------------------------------------------" << endl;
//   statFile << "|           L1 Path             |   eff (Tot)    | eff (Reco Sel)|  eff (Mc Sel) |" << endl;
//   statFile << "---------------------------------------------------------------------------------" << endl;
//   statFile << "---------------------------------------------------------------------------------" << endl;
//   for(unsigned int i=0; i<numTotL1BitsBeforeCuts.size()-1; i++) {
//     statFile << "|  " << left << setw(29) << l1Names_[i] << "|" << setprecision(3) << showpoint << right << setw(13) << effL1BeforeCuts[i]    << "  |" <<
//                                                                                                             setw(13) << effL1AfterRecoCuts[i] << "  |" <<
//                                                                                                             setw(13) << effL1AfterMcCuts[i]   << "  |" << endl;
//   }
//   statFile << "---------------------------------------------------------------------------------" << endl;
//   statFile << "---------------------------------------------------------------------------------" << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;



//   statFile << "**********************************************************************************" << endl;
//   statFile << "**********************************************************************************" << endl;
//   statFile << "                                  Hlt Efficiencies                                " << endl;
//   statFile << "**********************************************************************************" << endl;
//   statFile << "**********************************************************************************" << endl;
//   statFile << endl;
//   statFile << "----------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------" << endl;
//   statFile << "|           Hlt Path             |   eff (Tot)    | eff (Reco Sel)|  eff (Mc Sel) |" << endl;
//   statFile << "----------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------" << endl;
//   for(unsigned int i=0; i<numTotHltBitsBeforeCuts.size()-1; i++) {
//     statFile << "|  " << left << setw(29) << hlNames_[i] << "|" << setprecision(3) << showpoint << right << setw(13) << effHltBeforeCuts[i]    << "  |" << 
//                                                                                                             setw(13) << effHltAfterRecoCuts[i] << "  |" << 
//                                                                                                             setw(13) << effHltAfterMcCuts[i]   << "  |" <<endl;
//   }
//   statFile << "----------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------" << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;





//   statFile << "****************************************************************************************************************************************************" << endl; 
//   statFile << "****************************************************************************************************************************************************" << endl; 
//   statFile << "                                                      L1 Correlations   (only overlaps >5% are shown, and only without any selection)                                               " << endl;
//   statFile << "****************************************************************************************************************************************************" << endl; 
//   statFile << "****************************************************************************************************************************************************" << endl;
//   statFile << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "|           L1 Path 1           |           L1 Path 2           |  Overlap Norm to Total  |  Overlap Norm to Path  |         Path of Norm          |" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << endl;
//   for(unsigned int i=0; i<numTotL1BitsBeforeCuts.size()-1; i++) {
//     for(unsigned int j=0; j<numTotL1BitsBeforeCuts.size()-1; j++) {
//       if(vCorrNormL1[i][j]>0.05) {
//  int iNorm = 0;
//  if(effL1BeforeCuts[i] > effL1BeforeCuts[j]) {iNorm  = i;}
//  else {iNorm = j;}
//  double effNorm  =  vCorrNormL1[i][j] / effL1BeforeCuts[iNorm];
//  statFile << "|  " << left << setw(29) << l1Names_[i] << "|  " << setw(29) <<  left << l1Names_[j] << "|"
//       << setprecision(3) << showpoint << right  << setw(22) << vCorrNormL1[i][j] << "   |"
//       << setprecision(3) << showpoint << right  << setw(21) << effNorm           << "   |  "
//       << left << setw(29) << l1Names_[iNorm] << "|" << endl;
//       }
//     }
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   }
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;


//   statFile << "****************************************************************************************************************************************************" << endl; 
//   statFile << "****************************************************************************************************************************************************" << endl; 
//   statFile << "                                                     Hlt Correlations   (only overlaps >5% are shown, and only without any selection)                                               " << endl;
//   statFile << "****************************************************************************************************************************************************" << endl; 
//   statFile << "****************************************************************************************************************************************************" << endl;
//   statFile << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "|           Hlt Path 1          |           Hlt Path 2          |  Overlap Norm to Total  |  Overlap Norm to Path  |         Path of Norm          |" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << endl;
//   for(unsigned int i=0; i<numTotHltBitsBeforeCuts.size()-1; i++) {
//     for(unsigned int j=0; j<numTotHltBitsBeforeCuts.size()-1; j++) {
//       if(vCorrNormHlt[i][j]>0.05) {
//  int iNorm = 0;
//  if(effHltBeforeCuts[i] > effHltBeforeCuts[j]) {iNorm  = i;}
//  else {iNorm = j;}
//  double effNorm  = vCorrNormHlt[i][j]/effHltBeforeCuts[iNorm];
//  statFile << "|  " << left << setw(29) << hlNames_[i] << "|  " << setw(29) <<  left << hlNames_[j] << "|"
//       << setprecision(3) << showpoint << right  << setw(22) << vCorrNormHlt[i][j] << "   |"
//       << setprecision(3) << showpoint << right  << setw(21) << effNorm            << "   |  "
//       << left << setw(29) << hlNames_[iNorm] << "|" << endl;
//       }
//     }
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   }
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << "----------------------------------------------------------------------------------------------------------------------------------------------------" << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;
//   statFile << endl;




//   statFile.close();


  for(unsigned int i=0; i<myRecoSelector.size(); ++i) delete myRecoSelector[i];
  myRecoSelector.clear();
  if(mcFlag) 
    {
      for(unsigned int i=0; i<myMcSelector.size(); ++i) delete myMcSelector[i];
      myMcSelector.clear();
    }
     
  if(l1Flag) delete myPlotMakerL1;
  delete myPlotMakerReco;
//   delete myTurnOnMaker;
  return;
}

Member Data Documentation

DQMStore* TriggerValidator::dbe_

private

Definition at line 80 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), and TriggerValidator().

std::string TriggerValidator::dirname_

private

Definition at line 81 of file TriggerValidator.h.

Referenced by beginRun(), and TriggerValidator().

std::vector<double> TriggerValidator::effHltAfterMcCuts

private

Definition at line 146 of file TriggerValidator.h.

std::vector<double> TriggerValidator::effHltAfterRecoCuts

private

Definition at line 144 of file TriggerValidator.h.

std::vector<double> TriggerValidator::effHltBeforeCuts

private

Definition at line 142 of file TriggerValidator.h.

std::vector<double> TriggerValidator::effL1AfterMcCuts

private

Definition at line 145 of file TriggerValidator.h.

std::vector<double> TriggerValidator::effL1AfterRecoCuts

private

Definition at line 143 of file TriggerValidator.h.

std::vector<double> TriggerValidator::effL1BeforeCuts

private

Definition at line 141 of file TriggerValidator.h.

bool TriggerValidator::firstEvent

private

Definition at line 187 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

edm::EDGetTokenT<L1GlobalTriggerReadoutRecord> TriggerValidator::gtDigis_token_

private

Definition at line 125 of file TriggerValidator.h.

Referenced by analyze().

std::vector<MonitorElement*> TriggerValidator::hHltBitsAfterMcCuts

private

Definition at line 168 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<MonitorElement*> TriggerValidator::hHltBitsAfterRecoCuts

private

Definition at line 166 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

MonitorElement* TriggerValidator::hHltBitsBeforeCuts

private

Definition at line 164 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<MonitorElement*> TriggerValidator::hHltPathsAfterMcCuts

private

Definition at line 175 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<MonitorElement*> TriggerValidator::hHltPathsAfterRecoCuts

private

Definition at line 173 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

MonitorElement* TriggerValidator::hHltPathsBeforeCuts

private

Definition at line 171 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::string TriggerValidator::HistoFileName

private

Definition at line 104 of file TriggerValidator.h.

std::vector<MonitorElement*> TriggerValidator::hL1BitsAfterMcCuts

private

Definition at line 167 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<MonitorElement*> TriggerValidator::hL1BitsAfterRecoCuts

private

Definition at line 165 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

MonitorElement* TriggerValidator::hL1BitsBeforeCuts

private

Definition at line 163 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<MonitorElement*> TriggerValidator::hL1PathsAfterMcCuts

private

Definition at line 174 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<MonitorElement*> TriggerValidator::hL1PathsAfterRecoCuts

private

Definition at line 172 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

MonitorElement* TriggerValidator::hL1PathsBeforeCuts

private

Definition at line 170 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<std::string> TriggerValidator::hlNames_

private

Definition at line 130 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), and endRun().

edm::EDGetTokenT<edm::TriggerResults> TriggerValidator::hlt_token_

private

Definition at line 108 of file TriggerValidator.h.

Referenced by analyze().

std::vector<int> TriggerValidator::hltbits

private

Definition at line 185 of file TriggerValidator.h.

Referenced by analyze().

HLTConfigProvider TriggerValidator::hltConfig_

private

Definition at line 82 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

edm::InputTag TriggerValidator::hltLabel

private

Definition at line 107 of file TriggerValidator.h.

Referenced by analyze().

std::vector<std::string> TriggerValidator::hltPathsToCheck_

private

Definition at line 124 of file TriggerValidator.h.

Referenced by beginRun().

std::vector<int> TriggerValidator::l1bits

private

Definition at line 184 of file TriggerValidator.h.

Referenced by analyze().

bool TriggerValidator::l1Flag

private

Definition at line 112 of file TriggerValidator.h.

Referenced by analyze(), endRun(), and TriggerValidator().

edm::EDGetTokenT<L1GlobalTriggerObjectMapRecord> TriggerValidator::l1Label

private

Definition at line 106 of file TriggerValidator.h.

Referenced by analyze().

std::map<int,std::string> TriggerValidator::l1NameMap

private

Definition at line 78 of file TriggerValidator.h.

Referenced by analyze().

std::vector<std::string> TriggerValidator::l1Names_

private

Definition at line 128 of file TriggerValidator.h.

Referenced by analyze(), and endRun().

std::vector<edm::ParameterSet> TriggerValidator::mc_parametersets

private

Definition at line 116 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), and TriggerValidator().

bool TriggerValidator::mcFlag

private

Definition at line 111 of file TriggerValidator.h.

Referenced by analyze(), endRun(), and TriggerValidator().

std::string TriggerValidator::mcSelBitsDir

private

Definition at line 86 of file TriggerValidator.h.

Referenced by beginRun(), and TriggerValidator().

edm::InputTag TriggerValidator::muonTag_

private

Definition at line 121 of file TriggerValidator.h.

Referenced by TriggerValidator().

std::vector<McSelector*> TriggerValidator::myMcSelector

private

Definition at line 96 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), endRun(), and TriggerValidator().

MuonAnalyzerSBSM* TriggerValidator::myMuonAnalyzer

private

Definition at line 189 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), and TriggerValidator().

PlotMakerL1* TriggerValidator::myPlotMakerL1

private

Definition at line 99 of file TriggerValidator.h.

Referenced by analyze(), endRun(), and TriggerValidator().

PlotMakerReco* TriggerValidator::myPlotMakerReco

private

Definition at line 100 of file TriggerValidator.h.

Referenced by analyze(), endRun(), and TriggerValidator().

std::vector<RecoSelector*> TriggerValidator::myRecoSelector

private

Definition at line 95 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), endRun(), and TriggerValidator().

std::vector<int> TriggerValidator::nEvMcSelected

private

Definition at line 157 of file TriggerValidator.h.

Referenced by analyze(), and TriggerValidator().

std::vector<int> TriggerValidator::nEvRecoSelected

private

Definition at line 156 of file TriggerValidator.h.

Referenced by analyze(), and TriggerValidator().

int TriggerValidator::nEvTot

private

Definition at line 155 of file TriggerValidator.h.

Referenced by analyze(), and TriggerValidator().

unsigned int TriggerValidator::nHltPaths

private

Definition at line 90 of file TriggerValidator.h.

Referenced by beginRun(), and TriggerValidator().

int TriggerValidator::nL1Bits

private

Definition at line 91 of file TriggerValidator.h.

Referenced by beginRun(), and TriggerValidator().

std::vector< std::vector<int> > TriggerValidator::numTotHltBitsAfterMcCuts

private

Definition at line 139 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector< std::vector<int> > TriggerValidator::numTotHltBitsAfterRecoCuts

private

Definition at line 137 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<int> TriggerValidator::numTotHltBitsBeforeCuts

private

Definition at line 135 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector< std::vector<int> > TriggerValidator::numTotL1BitsAfterMcCuts

private

Definition at line 138 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector< std::vector<int> > TriggerValidator::numTotL1BitsAfterRecoCuts

private

Definition at line 136 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

std::vector<int> TriggerValidator::numTotL1BitsBeforeCuts

private

Definition at line 134 of file TriggerValidator.h.

Referenced by analyze(), and beginRun().

edm::ParameterSet TriggerValidator::plotMakerL1Input

private

Definition at line 118 of file TriggerValidator.h.

Referenced by TriggerValidator().

edm::ParameterSet TriggerValidator::plotMakerRecoInput

private

Definition at line 119 of file TriggerValidator.h.

Referenced by TriggerValidator().

std::string TriggerValidator::processName_

private

Definition at line 123 of file TriggerValidator.h.

Referenced by beginRun().

std::vector<edm::ParameterSet> TriggerValidator::reco_parametersets

private

Definition at line 115 of file TriggerValidator.h.

Referenced by analyze(), beginRun(), and TriggerValidator().

std::string TriggerValidator::recoSelBitsDir

private

Definition at line 85 of file TriggerValidator.h.

Referenced by beginRun(), and TriggerValidator().

std::string TriggerValidator::StatFileName

private

Definition at line 105 of file TriggerValidator.h.

TFile* TriggerValidator::theHistoFile

Definition at line 66 of file TriggerValidator.h.

Referenced by TriggerValidator().

std::string TriggerValidator::triggerBitsDir

private

Definition at line 84 of file TriggerValidator.h.

Referenced by beginRun(), and TriggerValidator().

edm::InputTag TriggerValidator::triggerTag_

private

Definition at line 122 of file TriggerValidator.h.

Referenced by TriggerValidator().

edm::ParameterSet TriggerValidator::turnOn_params

private

Definition at line 117 of file TriggerValidator.h.

std::vector< std::vector<int> > TriggerValidator::vCorrHlt

private

Definition at line 151 of file TriggerValidator.h.

Referenced by analyze().

std::vector< std::vector<int> > TriggerValidator::vCorrL1

private

Definition at line 150 of file TriggerValidator.h.

Referenced by analyze().

std::vector< std::vector<double> > TriggerValidator::vCorrNormHlt

private

Definition at line 153 of file TriggerValidator.h.

Referenced by analyze().

std::vector< std::vector<double> > TriggerValidator::vCorrNormL1

private

Definition at line 152 of file TriggerValidator.h.

Referenced by analyze().