CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
Functions
egHLT::MonElemFuncs Namespace Reference

Functions

template<class T , typename varType >
void addStdHist (std::vector< MonElemManagerBase< T > * > &histVec, const std::string &name, const std::string &title, const BinData::Data1D &binData, varType(T::*varFunc)() const)
 
void addTightLooseTrigHist (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
 
void addTightLooseTrigHist (std::vector< MonElemContainer< OffPho > * > &phoMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffPho > *phoCut, const std::string &histId, const BinData &bins)
 
template<class T >
void addTightLooseTrigHist (std::vector< MonElemContainer< T > * > &monElems, const std::string &tightTrig, const std::string &looseTrig, const std::string &histId, const BinData &bins)
 
void initStdEffHists (std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, int nrBins, double xMin, double xMax, float(OffEle::*vsVarFunc)() const, const CutMasks &masks)
 
void initStdEffHists (std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData::Data1D &bins, float(OffEle::*vsVarFunc)() const, const CutMasks &masks)
 
void initStdEffHists (std::vector< MonElemWithCutBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, int nrBins, double xMin, double xMax, float(OffPho::*vsVarFunc)() const, const CutMasks &masks)
 
void initStdEffHists (std::vector< MonElemWithCutBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData::Data1D &bins, float(OffPho::*vsVarFunc)() const, const CutMasks &masks)
 
void initStdEleCutHists (std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffEle > *cut=NULL)
 
void initStdEleHists (std::vector< MonElemManagerBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins)
 
void initStdPhoCutHists (std::vector< MonElemWithCutBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffPho > *cut=NULL)
 
void initStdPhoHists (std::vector< MonElemManagerBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins)
 
void initTightLooseDiObjTrigHistsTrigCuts (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins)
 
void initTightLooseDiObjTrigHistsTrigCuts (std::vector< MonElemContainer< OffPho > * > &phoMonElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins)
 
void initTightLooseTrigHists (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins, EgHLTDQMCut< OffEle > *eleCut)
 
void initTightLooseTrigHists (std::vector< MonElemContainer< OffPho > * > &phoMonElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins, EgHLTDQMCut< OffPho > *phoCut)
 
template<class T >
void initTightLooseTrigHists (std::vector< MonElemContainer< T > * > &monElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins, const std::string &objName)
 
void initTightLooseTrigHistsTrigCuts (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins)
 
void initTightLooseTrigHistsTrigCuts (std::vector< MonElemContainer< OffPho > * > &phoMonElems, const std::vector< std::string > &tightLooseTrigs, const BinData &bins)
 
void initTrigTagProbeHist (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string filterName, int cutMask, const BinData &bins)
 
void initTrigTagProbeHist (std::vector< MonElemContainer< OffPho > * > &phoMonElems, const std::string filterName, int cutMask, const BinData &bins)
 
void initTrigTagProbeHist_2Leg (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string filterName, int cutMask, const BinData &bins)
 
void initTrigTagProbeHists (std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::vector< std::string > filterNames, int cutMask, const BinData &bins)
 
void initTrigTagProbeHists (std::vector< MonElemContainer< OffPho > * > &phoMonElems, const std::vector< std::string > filterNames, int cutMask, const BinData &bins)
 

Function Documentation

template<class T , typename varType >
void egHLT::MonElemFuncs::addStdHist ( std::vector< MonElemManagerBase< T > * > &  histVec,
const std::string &  name,
const std::string &  title,
const BinData::Data1D &  binData,
varType(T::*)() const  varFunc 
)

Definition at line 73 of file EgHLTMonElemFuncs.h.

References egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, and egHLT::BinData::Data1D::nr.

74  {
75  histVec.push_back(new MonElemMgrEBEE<T,varType>(name,title,binData.nr,binData.min,binData.max,varFunc));
76  }
void egHLT::MonElemFuncs::addTightLooseTrigHist ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::string &  tightTrig,
const std::string &  looseTrig,
EgHLTDQMCut< OffEle > *  eleCut,
const std::string &  histId,
const BinData &  bins 
)

Definition at line 282 of file EgHLTMonElemFuncs.cc.

References egHLT::EgHLTDQMCut< T >::clone(), egHLT::TrigCodes::getCode(), initStdEleHists(), egHLT::MonElemContainer< T >::monElems(), egHLT::MonElemContainer< T >::name(), and NULL.

Referenced by addTightLooseTrigHist(), initTightLooseDiObjTrigHistsTrigCuts(), initTightLooseTrigHists(), and initTightLooseTrigHistsTrigCuts().

286 {
287  MonElemContainer<OffEle>* passMonElem = NULL;
288  passMonElem = new MonElemContainer<OffEle>(tightTrig+"_"+looseTrig+"_"+histId+"_passTrig","",
289  &(*(new EgMultiCut<OffEle>) <<
290  new EgObjTrigCut<OffEle>(TrigCodes::getCode(tightTrig+":"+looseTrig),EgObjTrigCut<OffEle>::AND) <<
291  eleCut->clone()));
292 
293 
294  MonElemContainer<OffEle>* failMonElem = NULL;
295  failMonElem = new MonElemContainer<OffEle>(tightTrig+"_"+looseTrig+"_"+histId+"_failTrig","",
296  &(*(new EgMultiCut<OffEle>) <<
297  new EgObjTrigCut<OffEle>(TrigCodes::getCode(looseTrig),EgObjTrigCut<OffEle>::AND,TrigCodes::getCode(tightTrig)) <<
298  eleCut));
299 
300  MonElemFuncs::initStdEleHists(passMonElem->monElems(),tightTrig+"_"+looseTrig,passMonElem->name(),bins);
301  MonElemFuncs::initStdEleHists(failMonElem->monElems(),tightTrig+"_"+looseTrig,failMonElem->name(),bins);
302  eleMonElems.push_back(passMonElem);
303  eleMonElems.push_back(failMonElem);
304 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
NULL
#define NULL
Definition: scimark2.h:8
egHLT::MonElemFuncs::initStdEleHists
void initStdEleHists(std::vector< MonElemManagerBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:11
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
egHLT::MonElemContainer::monElems
std::vector< MonElemManagerBase< T > * > & monElems()
Definition: EgHLTMonElemContainer.h:56
void egHLT::MonElemFuncs::addTightLooseTrigHist ( std::vector< MonElemContainer< OffPho > * > &  phoMonElems,
const std::string &  tightTrig,
const std::string &  looseTrig,
EgHLTDQMCut< OffPho > *  phoCut,
const std::string &  histId,
const BinData &  bins 
)

Definition at line 308 of file EgHLTMonElemFuncs.cc.

References egHLT::EgHLTDQMCut< T >::clone(), egHLT::TrigCodes::getCode(), initStdPhoHists(), egHLT::MonElemContainer< T >::monElems(), egHLT::MonElemContainer< T >::name(), and NULL.

312 {
313  MonElemContainer<OffPho>* passMonElem = NULL;
314  passMonElem = new MonElemContainer<OffPho>(tightTrig+"_"+looseTrig+"_"+histId+"_passTrig","",
315  &(*(new EgMultiCut<OffPho>) <<
316  new EgObjTrigCut<OffPho>(TrigCodes::getCode(tightTrig+":"+looseTrig),EgObjTrigCut<OffPho>::AND) <<
317  phoCut->clone()));
318 
319 
320  MonElemContainer<OffPho>* failMonElem = NULL;
321  failMonElem = new MonElemContainer<OffPho>(tightTrig+"_"+looseTrig+"_"+histId+"_failTrig","",
322  &(*(new EgMultiCut<OffPho>) <<
323  new EgObjTrigCut<OffPho>(TrigCodes::getCode(looseTrig),EgObjTrigCut<OffPho>::AND,TrigCodes::getCode(tightTrig)) <<
324  phoCut));
325 
326  MonElemFuncs::initStdPhoHists(passMonElem->monElems(),tightTrig+"_"+looseTrig,passMonElem->name(),bins);
327  MonElemFuncs::initStdPhoHists(failMonElem->monElems(),tightTrig+"_"+looseTrig,failMonElem->name(),bins);
328  phoMonElems.push_back(passMonElem);
329  phoMonElems.push_back(failMonElem);
330 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
NULL
#define NULL
Definition: scimark2.h:8
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
egHLT::MonElemContainer::monElems
std::vector< MonElemManagerBase< T > * > & monElems()
Definition: EgHLTMonElemContainer.h:56
egHLT::MonElemFuncs::initStdPhoHists
void initStdPhoHists(std::vector< MonElemManagerBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:49
template<class T >
void egHLT::MonElemFuncs::addTightLooseTrigHist ( std::vector< MonElemContainer< T > * > &  monElems,
const std::string &  tightTrig,
const std::string &  looseTrig,
const std::string &  histId,
const BinData &  bins 
)

Definition at line 81 of file EgHLTMonElemFuncs.h.

References addTightLooseTrigHist(), egHLT::BinData::et, egHLT::TrigCodes::getCode(), egHLT::trigTools::getEtThresFromName(), egHLT::MonElemContainer< T >::monElems(), and egHLT::MonElemContainer< T >::name().

84  {
85 
86  float etCutValue = trigTools::getEtThresFromName(tightTrig);
87 
88  EgHLTDQMCut<T>* etCut = new EgGreaterCut<T,float>(etCutValue,&T::etSC); //note the cut in trigger is on SC Et
89  addTightLooseTrigHist(monElems,tightTrig,looseTrig,etCut,histId,bins);
90 
91  //now make the new mon elems without the et cut (have to be placed in containers even though each container just has one monelem)
92  MonElemContainer<T>* passEtMonElem;
93  passEtMonElem = new MonElemContainer<T>(tightTrig+"_"+looseTrig+"_"+histId+"_passTrig","",
94  new EgObjTrigCut<T>(TrigCodes::getCode(tightTrig+":"+looseTrig),EgObjTrigCut<T>::AND));
95  addStdHist<T,float>(passEtMonElem->monElems(),passEtMonElem->name()+"_etUnCut",passEtMonElem->name()+" E_{T} (Uncut);E_{T} (GeV)",bins.et,&T::et);
96 
97  MonElemContainer<T>* failEtMonElem;
98  failEtMonElem = new MonElemContainer<T>(tightTrig+"_"+looseTrig+"_"+histId+"_failTrig","",
99  new EgObjTrigCut<T>(TrigCodes::getCode(looseTrig),EgObjTrigCut<T>::AND,TrigCodes::getCode(tightTrig)));
100  addStdHist<T,float>(failEtMonElem->monElems(),failEtMonElem->name()+"_etUnCut",failEtMonElem->name()+" E_{T} (Uncut);E_{T} (GeV)",bins.et,&T::et);
101 
102  monElems.push_back(passEtMonElem);
103  monElems.push_back(failEtMonElem);
104  }
reco::tau::qcuts::AND
bool AND(const PFCandidate &cand, const RecoTauQualityCuts::QCutFuncCollection &cuts)
Definition: RecoTauQualityCuts.cc:66
egHLT::trigTools::getEtThresFromName
float getEtThresFromName(const std::string &trigName)
Definition: EgHLTTrigTools.cc:283
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
void egHLT::MonElemFuncs::initStdEffHists ( std::vector< MonElemWithCutBase< OffEle > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
int  nrBins,
double  xMin,
double  xMax,
float(OffEle::*)() const  vsVarFunc,
const CutMasks &  masks 
)

Definition at line 90 of file EgHLTMonElemFuncs.cc.

References egHLT::OffEle::cutCode(), egHLT::EgCutCodes::DETAIN, egHLT::EgCutCodes::DPHIIN, egHLT::EgCutCodes::HADEM, egHLT::EgCutCodes::HLTISOLEM, egHLT::EgCutCodes::HLTISOLHAD, egHLT::EgCutCodes::HLTISOLTRKSELE, egHLT::EgCutCodes::SIGMAIETAIETA, and egHLT::CutMasks::stdEle.

Referenced by egHLT::EleHLTFilterMon::EleHLTFilterMon(), initStdEffHists(), and egHLT::PhoHLTFilterMon::PhoHLTFilterMon().

91 {
92  //some convience typedefs, I hate typedefs but atleast here where they are defined is obvious
93  typedef EgHLTDQMVarCut<OffEle> VarCut;
94  typedef MonElemWithCutEBEE<OffEle,float> MonElemFloat;
95  int stdCutCode = masks.stdEle;
96 
97  //first do the zero and all cuts histograms
98  histVec.push_back(new MonElemFloat(baseName+"_noCuts",baseName+" NoCuts",nrBins,xMin,xMax,vsVarFunc));
99  histVec.push_back(new MonElemFloat(baseName+"_allCuts",baseName+" All Cuts",nrBins,xMin,xMax,vsVarFunc,
100  new VarCut(stdCutCode,&OffEle::cutCode)));
101 
102  //now for the n-1
103  histVec.push_back(new MonElemFloat(baseName+"_n1_dEtaIn",baseName+" N1 #Delta#eta_{in}",nrBins,xMin,xMax,vsVarFunc,
104  new VarCut(~EgCutCodes::DETAIN&stdCutCode,&OffEle::cutCode)));
105  histVec.push_back(new MonElemFloat(baseName+"_n1_dPhiIn",baseName+" N1 #Delta#phi_{in}",nrBins,xMin,xMax,vsVarFunc,
106  new VarCut(~EgCutCodes::DPHIIN&stdCutCode,&OffEle::cutCode)));
107  histVec.push_back(new MonElemFloat(baseName+"_n1_sigmaIEtaIEta",baseName+" N1 #sigma_{i#etai#eta}",nrBins,xMin,xMax,vsVarFunc,
108  new VarCut(~EgCutCodes::SIGMAIETAIETA&stdCutCode,&OffEle::cutCode)));
109  histVec.push_back(new MonElemFloat(baseName+"_n1_hOverE",baseName+" N1 H/E",nrBins,xMin,xMax,vsVarFunc,
110  new VarCut(~EgCutCodes::HADEM&stdCutCode,&OffEle::cutCode)));
111  /* histVec.push_back(new MonElemFloat(baseName+"_n1_isolEm",baseName+" N1 Isol Em",nrBins,xMin,xMax,vsVarFunc,
112  new VarCut(~EgCutCodes::ISOLEM&stdCutCode,&OffEle::cutCode)));
113  histVec.push_back(new MonElemFloat(baseName+"_n1_isolHad",baseName+" N1 Isol Had",nrBins,xMin,xMax,vsVarFunc,
114  new VarCut(~EgCutCodes::ISOLHAD&stdCutCode,&OffEle::cutCode)));
115  histVec.push_back(new MonElemFloat(baseName+"_n1_isolPtTrks",baseName+" N1 Isol Tracks",nrBins,xMin,xMax,vsVarFunc,
116  new VarCut(~EgCutCodes::ISOLPTTRKS&stdCutCode,&OffEle::cutCode)));*/
117  histVec.push_back(new MonElemFloat(baseName+"_n1_hltIsolEm",baseName+" N1 HLT Isol Em",nrBins,xMin,xMax,vsVarFunc,
118  new VarCut(~EgCutCodes::HLTISOLEM&stdCutCode,&OffEle::cutCode)));
119  histVec.push_back(new MonElemFloat(baseName+"_n1_hltIsolHad",baseName+" N1 HLT Isol Had",nrBins,xMin,xMax,vsVarFunc,
120  new VarCut(~EgCutCodes::HLTISOLHAD&stdCutCode,&OffEle::cutCode)));
121  histVec.push_back(new MonElemFloat(baseName+"_n1_hltIsolTrksEle",baseName+" N1 HLT Isol Tracks Ele ",nrBins,xMin,xMax,vsVarFunc,
122  new VarCut(~EgCutCodes::HLTISOLTRKSELE&stdCutCode,&OffEle::cutCode)));
123  histVec.push_back(new MonElemFloat(baseName+"_single_dEtaIn",baseName+" Single #Delta#eta_{in}",nrBins,xMin,xMax,vsVarFunc,
124  new VarCut(EgCutCodes::DETAIN,&OffEle::cutCode)));
125  histVec.push_back(new MonElemFloat(baseName+"_single_dPhiIn",baseName+" Single #Delta#phi_{in}",nrBins,xMin,xMax,vsVarFunc,
126  new VarCut(EgCutCodes::DPHIIN,&OffEle::cutCode)));
127  histVec.push_back(new MonElemFloat(baseName+"_single_sigmaIEtaIEta",baseName+" Single #sigma_{i#etai#eta}",nrBins,xMin,xMax,vsVarFunc,
128  new VarCut(EgCutCodes::SIGMAIETAIETA,&OffEle::cutCode)));
129  histVec.push_back(new MonElemFloat(baseName+"_single_hOverE",baseName+" Single H/E",nrBins,xMin,xMax,vsVarFunc,
130  new VarCut(EgCutCodes::HADEM,&OffEle::cutCode)));
131  /* histVec.push_back(new MonElemFloat(baseName+"_single_isolEm",baseName+" Single Isol Em",nrBins,xMin,xMax,vsVarFunc,
132  new VarCut(EgCutCodes::ISOLEM,&OffEle::cutCode)));
133  histVec.push_back(new MonElemFloat(baseName+"_single_isolHad",baseName+" Single Isol Had",nrBins,xMin,xMax,vsVarFunc,
134  new VarCut(EgCutCodes::ISOLHAD,&OffEle::cutCode)));
135  histVec.push_back(new MonElemFloat(baseName+"_single_isolPtTrks",baseName+" Single Isol Tracks",nrBins,xMin,xMax,vsVarFunc,
136  new VarCut(EgCutCodes::ISOLPTTRKS,&OffEle::cutCode)));*/
137  histVec.push_back(new MonElemFloat(baseName+"_single_hltIsolEm",baseName+" Single HLT Isol Em",nrBins,xMin,xMax,vsVarFunc,
138  new VarCut(EgCutCodes::HLTISOLEM,&OffEle::cutCode)));
139  histVec.push_back(new MonElemFloat(baseName+"_single_hltIsolHad",baseName+" Single HLT Isol Had",nrBins,xMin,xMax,vsVarFunc,
140  new VarCut(EgCutCodes::HLTISOLHAD,&OffEle::cutCode)));
141  histVec.push_back(new MonElemFloat(baseName+"_single_hltIsolTrksEle",baseName+" Single HLT Isol Tracks Ele ",nrBins,xMin,xMax,vsVarFunc,
142  new VarCut(EgCutCodes::HLTISOLTRKSELE,&OffEle::cutCode)));
143  /*histVec.push_back(new MonElemFloat(baseName+"_single_hltIsolTrksPho",baseName+" Single HLT Isol Tracks Pho ",nrBins,xMin,xMax,vsVarFunc,
144  new VarCut(EgCutCodes::HLTISOLTRKSPHO,&OffEle::cutCode)));*/
145 
146 }
void egHLT::MonElemFuncs::initStdEffHists ( std::vector< MonElemWithCutBase< OffEle > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
const BinData::Data1D &  bins,
float(OffEle::*)() const  vsVarFunc,
const CutMasks &  masks 
)

Definition at line 80 of file EgHLTMonElemFuncs.cc.

References initStdEffHists(), egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, and egHLT::BinData::Data1D::nr.

81 {
82  initStdEffHists(histVec,filterName,baseName,bins.nr,bins.min,bins.max,vsVarFunc,masks);
83 }
reco_skim_cfg_mod.filterName
tuple filterName
Definition: reco_skim_cfg_mod.py:159
egHLT::MonElemFuncs::initStdEffHists
void initStdEffHists(std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, int nrBins, double xMin, double xMax, float(OffEle::*vsVarFunc)() const, const CutMasks &masks)
Definition: EgHLTMonElemFuncs.cc:90
void egHLT::MonElemFuncs::initStdEffHists ( std::vector< MonElemWithCutBase< OffPho > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
int  nrBins,
double  xMin,
double  xMax,
float(OffPho::*)() const  vsVarFunc,
const CutMasks &  masks 
)

Definition at line 148 of file EgHLTMonElemFuncs.cc.

References egHLT::OffPho::cutCode(), egHLT::EgCutCodes::HADEM, egHLT::EgCutCodes::ISOLEM, egHLT::EgCutCodes::ISOLHAD, egHLT::EgCutCodes::ISOLNRTRKS, egHLT::EgCutCodes::ISOLPTTRKS, egHLT::EgCutCodes::SIGMAIETAIETA, and egHLT::CutMasks::stdPho.

149 {
150  //some convenience typedefs, I hate typedefs but atleast here where they are defined is obvious
151  typedef EgHLTDQMVarCut<OffPho> VarCut;
152  typedef MonElemWithCutEBEE<OffPho,float> MonElemFloat;
153  int stdCutCode = masks.stdPho;
154 
155  histVec.push_back(new MonElemFloat(baseName+"_noCuts",baseName+" NoCuts",nrBins,xMin,xMax,vsVarFunc));
156  histVec.push_back(new MonElemFloat(baseName+"_allCuts",baseName+" All Cuts",nrBins,xMin,xMax,vsVarFunc,
157  new VarCut(stdCutCode,&OffPho::cutCode)));
158 
159 
160  histVec.push_back(new MonElemFloat(baseName+"_n1_sigmaIEtaIEta",baseName+" N1 #sigma_{i#etai#eta}",nrBins,xMin,xMax,vsVarFunc,
161  new VarCut(~EgCutCodes::SIGMAIETAIETA&stdCutCode,&OffPho::cutCode)));
162  //-----Morse------
163  histVec.push_back(new MonElemFloat(baseName+"_n1_hOverE",baseName+" N1 H/E",nrBins,xMin,xMax,vsVarFunc,
164  new VarCut(~EgCutCodes::HADEM&stdCutCode,&OffPho::cutCode)));//---BUG FIX!!--
165  /*histVec.push_back(new MonElemFloat(baseName+"_n1_minr9",baseName+" N1 MINR9",nrBins,xMin,xMax,vsVarFunc,
166  new VarCut(~EgCutCodes::MINR9&stdCutCode,&OffPho::cutCode)));
167  histVec.push_back(new MonElemFloat(baseName+"_n1_maxr9",baseName+" N1 MAXR9",nrBins,xMin,xMax,vsVarFunc,
168  new VarCut(~EgCutCodes::MAXR9&stdCutCode,&OffPho::cutCode)));*/
169  //----------------
170  histVec.push_back(new MonElemFloat(baseName+"_n1_isolEm",baseName+" N1 Isol Em",nrBins,xMin,xMax,vsVarFunc,
171  new VarCut(~EgCutCodes::ISOLEM&stdCutCode,&OffPho::cutCode)));
172  histVec.push_back(new MonElemFloat(baseName+"_n1_isolHad",baseName+" N1 Isol Had",nrBins,xMin,xMax,vsVarFunc,
173  new VarCut(~EgCutCodes::ISOLHAD&stdCutCode,&OffPho::cutCode)));
174  histVec.push_back(new MonElemFloat(baseName+"_n1_isolPtTrks",baseName+" N1 Pt Isol Tracks",nrBins,xMin,xMax,vsVarFunc,
175  new VarCut(~EgCutCodes::ISOLPTTRKS&stdCutCode,&OffPho::cutCode)));
176  histVec.push_back(new MonElemFloat(baseName+"_n1_isolNrTrks",baseName+" N1 Nr Isol Tracks",nrBins,xMin,xMax,vsVarFunc,
177  new VarCut(~EgCutCodes::ISOLNRTRKS&stdCutCode,&OffPho::cutCode)));
178 
179  histVec.push_back(new MonElemFloat(baseName+"_single_hOverE",baseName+" Single H/E",nrBins,xMin,xMax,vsVarFunc,
180  new VarCut(EgCutCodes::HADEM,&OffPho::cutCode)));
181  histVec.push_back(new MonElemFloat(baseName+"_single_sigmaIEtaIEta",baseName+" Single #sigma_{i#etai#eta}",nrBins,xMin,xMax,vsVarFunc,
182  new VarCut(EgCutCodes::SIGMAIETAIETA,&OffPho::cutCode)));
183  histVec.push_back(new MonElemFloat(baseName+"_single_isolEm",baseName+" Single Isol Em",nrBins,xMin,xMax,vsVarFunc,
184  new VarCut(~EgCutCodes::ISOLEM,&OffPho::cutCode)));
185  histVec.push_back(new MonElemFloat(baseName+"_single_isolHad",baseName+" Single Isol Had",nrBins,xMin,xMax,vsVarFunc,
186  new VarCut(~EgCutCodes::ISOLHAD,&OffPho::cutCode)));
187  histVec.push_back(new MonElemFloat(baseName+"_single_isolPtTrks",baseName+" Single Pt Isol Tracks",nrBins,xMin,xMax,vsVarFunc,
188  new VarCut(~EgCutCodes::ISOLPTTRKS,&OffPho::cutCode)));
189  /*histVec.push_back(new MonElemFloat(baseName+"_single_hltIsolHad",baseName+" Single HLT Isol Had",nrBins,xMin,xMax,vsVarFunc,
190  new VarCut(EgCutCodes::HLTISOLHAD,&OffPho::cutCode)));
191  histVec.push_back(new MonElemFloat(baseName+"_single_hltIsolTrksPho",baseName+" Single HLT Isol Tracks Pho ",nrBins,xMin,xMax,vsVarFunc,
192  new VarCut(EgCutCodes::HLTISOLTRKSPHO,&OffPho::cutCode)));*/
193 
194 
195 }
void egHLT::MonElemFuncs::initStdEffHists ( std::vector< MonElemWithCutBase< OffPho > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
const BinData::Data1D &  bins,
float(OffPho::*)() const  vsVarFunc,
const CutMasks &  masks 
)

Definition at line 85 of file EgHLTMonElemFuncs.cc.

References initStdEffHists(), egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, and egHLT::BinData::Data1D::nr.

86 {
87  initStdEffHists(histVec,filterName,baseName,bins.nr,bins.min,bins.max,vsVarFunc,masks);
88 }
reco_skim_cfg_mod.filterName
tuple filterName
Definition: reco_skim_cfg_mod.py:159
egHLT::MonElemFuncs::initStdEffHists
void initStdEffHists(std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, int nrBins, double xMin, double xMax, float(OffEle::*vsVarFunc)() const, const CutMasks &masks)
Definition: EgHLTMonElemFuncs.cc:90
void egHLT::MonElemFuncs::initStdEleCutHists ( std::vector< MonElemWithCutBase< OffEle > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
const BinData &  bins,
EgHLTDQMCut< OffEle > *  cut = NULL 
)

Definition at line 200 of file EgHLTMonElemFuncs.cc.

References egHLT::EgHLTDQMCut< T >::clone(), egHLT::OffEle::detEta(), egHLT::BinData::et, egHLT::OffEle::et(), egHLT::BinData::eta, egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, egHLT::BinData::Data1D::nr, NULL, egHLT::BinData::nVertex, egHLT::OffEle::NVertex(), egHLT::BinData::phi, and egHLT::OffEle::phi().

Referenced by initTrigTagProbeHist(), initTrigTagProbeHist_2Leg(), and initTrigTagProbeHists().

201 {
202  histVec.push_back(new MonElemWithCutEBEE<OffEle,float>(baseName+"_et",
203  baseName+" E_{T};E_{T} (GeV)",
204  bins.et.nr,bins.et.min,bins.et.max,&OffEle::et,cut));
205  histVec.push_back(new MonElemWithCutEBEE<OffEle,float>(baseName+"_eta",
206  baseName+" #eta;#eta",
207  bins.eta.nr,bins.eta.min,bins.eta.max,
208  &OffEle::detEta,cut ? cut->clone(): NULL));
209  histVec.push_back(new MonElemWithCutEBEE<OffEle,float>(baseName+"_phi",
210  baseName+" #phi;#phi (rad)",
211  bins.phi.nr,bins.phi.min,bins.phi.max,
212  &OffEle::phi,cut ? cut->clone():NULL));
213  histVec.push_back(new MonElemWithCutEBEE<OffEle,int>(baseName+"_nVertex",
214  baseName+" nVertex;nVertex",
215  bins.nVertex.nr,bins.nVertex.min,bins.nVertex.max,
216  &OffEle::NVertex,cut ? cut->clone():NULL));
217  /* histVec.push_back(new MonElemWithCutEBEE<OffEle,int>(baseName+"_charge",
218  baseName+" Charge; charge",
219  bins.charge.nr,bins.charge.min,bins.charge.max,
220  &OffEle::charge,cut ? cut->clone():NULL)); */
221 }
NULL
#define NULL
Definition: scimark2.h:8
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
phi
Definition: DDAxes.h:10
void egHLT::MonElemFuncs::initStdEleHists ( std::vector< MonElemManagerBase< OffEle > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
const BinData &  bins 
)

Definition at line 11 of file EgHLTMonElemFuncs.cc.

References egHLT::BinData::dEtaIn, egHLT::OffEle::dEtaIn(), egHLT::OffEle::detEta(), egHLT::BinData::dPhiIn, egHLT::OffEle::dPhiIn(), egHLT::BinData::e1x5, egHLT::OffEle::e1x5Over5x5(), egHLT::BinData::e2x5, egHLT::OffEle::e2x5MaxOver5x5(), egHLT::BinData::eOverP, egHLT::OffEle::epIn(), egHLT::OffEle::epOut(), egHLT::BinData::et, egHLT::OffEle::et(), egHLT::BinData::eta, egHLT::BinData::etaVsPhi, egHLT::BinData::etHigh, egHLT::OffEle::etSC(), egHLT::OffEle::hltIsolEm(), egHLT::OffEle::hltIsolHad(), egHLT::OffEle::hltIsolTrksEle(), egHLT::BinData::hOverE, egHLT::OffEle::hOverE(), egHLT::BinData::invEInvP, egHLT::OffEle::invEInvP(), egHLT::BinData::isolEm, egHLT::BinData::isolHad, egHLT::BinData::isolPtTrks, egHLT::BinData::maxr9, egHLT::BinData::Data2D::nrX, egHLT::BinData::Data2D::nrY, egHLT::BinData::phi, egHLT::OffEle::phi(), egHLT::OffEle::r9(), egHLT::BinData::sigEtaEta, egHLT::OffEle::sigmaIEtaIEta(), egHLT::BinData::Data2D::xMax, egHLT::BinData::Data2D::xMin, egHLT::BinData::Data2D::yMax, and egHLT::BinData::Data2D::yMin.

Referenced by addTightLooseTrigHist(), and egHLT::EleHLTFilterMon::EleHLTFilterMon().

12 {
13  addStdHist<OffEle,float>(histVec,baseName+"_et",baseName+" E_{T};E_{T} (GeV)",bins.et,&OffEle::et);
14  addStdHist<OffEle,float>(histVec,baseName+"_etHigh",baseName+" E_{T};E_{T} (GeV)",bins.etHigh,&OffEle::et);
15  addStdHist<OffEle,float>(histVec,baseName+"_etSC",baseName+" E^{SC}_{T};E^{SC}_{T} (GeV)",bins.et,&OffEle::etSC);
16  addStdHist<OffEle,float>(histVec,baseName+"_eta",baseName+" #eta;#eta",bins.eta,&OffEle::detEta);
17  addStdHist<OffEle,float>(histVec,baseName+"_phi",baseName+" #phi;#phi (rad)",bins.phi,&OffEle::phi);
18  // addStdHist<OffEle,int>(histVec,baseName+"_charge",baseName+" Charge; charge",bins.charge,&OffEle::charge);
19 
20  addStdHist<OffEle,float>(histVec,baseName+"_hOverE",baseName+" H/E; H/E",bins.hOverE,&OffEle::hOverE);
21  //----Morse
22  addStdHist<OffEle,float>(histVec,baseName+"_maxr9",baseName+" MAXR9 ; MAXR9",bins.maxr9,&OffEle::r9);
23  //-------
24  addStdHist<OffEle,float>(histVec,baseName+"_dPhiIn",baseName+" #Delta #phi_{in}; #Delta #phi_{in}",bins.dPhiIn,&OffEle::dPhiIn);
25  addStdHist<OffEle,float>(histVec,baseName+"_dEtaIn",baseName+" #Delta #eta_{in}; #Delta #eta_{in}",bins.dEtaIn,&OffEle::dEtaIn);
26  addStdHist<OffEle,float>(histVec,baseName+"_sigmaIEtaIEta",baseName+"#sigma_{i#etai#eta}; #sigma_{i#etai#eta}",bins.sigEtaEta,&OffEle::sigmaIEtaIEta);
27  addStdHist<OffEle,float>(histVec,baseName+"_epIn",baseName+"E/p_{in}; E/p_{in}",bins.eOverP,&OffEle::epIn);
28  addStdHist<OffEle,float>(histVec,baseName+"_epOut",baseName+"E/p_{out}; E/p_{out}",bins.eOverP,&OffEle::epOut);
29  addStdHist<OffEle,float>(histVec,baseName+"_invEInvP",baseName+"1/E -1/p; 1/E - 1/p",bins.invEInvP,&OffEle::invEInvP);
30 
31  addStdHist<OffEle,float>(histVec,baseName+"_e2x5Over5x5",baseName+"E^{2x5}/E^{5x5}; E^{2x5}/E^{5x5}",bins.e2x5,&OffEle::e2x5MaxOver5x5);
32  addStdHist<OffEle,float>(histVec,baseName+"_e1x5Over5x5",baseName+"E^{1x5}/E^{5x5}; E^{1x5}/E^{5x5}",bins.e1x5,&OffEle::e1x5Over5x5);
33  // addStdHist<OffEle,float>(histVec,baseName+"_isolEM",baseName+"Isol EM; Isol EM (GeV)",bins.isolEm,&OffEle::isolEm);
34  //addStdHist<OffEle,float>(histVec,baseName+"_isolHad",baseName+"Isol Had; Isol Had (GeV)",bins.isolHad,&OffEle::isolHad);
35  //addStdHist<OffEle,float>(histVec,baseName+"_isolPtTrks",baseName+"Isol Pt Trks; Isol Pt Tracks (GeV/c)",bins.isolPtTrks,&OffEle::isolPtTrks);
36  addStdHist<OffEle,float>(histVec,baseName+"_hltIsolTrksEle",baseName+"HLT Ele Isol Trks; HLT Ele Iso Tracks (GeV/c)",bins.isolPtTrks,&OffEle::hltIsolTrksEle);
37  //addStdHist<OffEle,float>(histVec,baseName+"_hltIsolTrksPho",baseName+"HLT Pho Isol Trks; HLT Pho Iso Tracks (GeV/c)",bins.isolPtTrks,&OffEle::hltIsolTrksPho);
38  addStdHist<OffEle,float>(histVec,baseName+"_hltIsolHad",baseName+"HLT Isol Had; HLT Isol Had (GeV)",bins.isolHad,&OffEle::hltIsolHad);
39  addStdHist<OffEle,float>(histVec,baseName+"_hltIsolEm",baseName+"HLT Isol Em; HLT Isol Em (GeV)",bins.isolEm,&OffEle::hltIsolEm);
40 
41  histVec.push_back(new MonElemManager2D<OffEle,float,float>(baseName+"_etaVsPhi",
42  baseName+" #eta vs #phi;#eta;#phi (rad)",
43  bins.etaVsPhi.nrX,bins.etaVsPhi.xMin,bins.etaVsPhi.xMax,
44  bins.etaVsPhi.nrY,bins.etaVsPhi.yMin,bins.etaVsPhi.yMax,
45  &OffEle::detEta,&OffEle::phi));
46 
47 }
egHLT::BinData::isolPtTrks
Data1D isolPtTrks
Definition: EgHLTBinData.h:54
egHLT::BinData::sigEtaEta
Data1D sigEtaEta
Definition: EgHLTBinData.h:43
phi
Definition: DDAxes.h:10
void egHLT::MonElemFuncs::initStdPhoCutHists ( std::vector< MonElemWithCutBase< OffPho > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
const BinData &  bins,
EgHLTDQMCut< OffPho > *  cut = NULL 
)

Definition at line 224 of file EgHLTMonElemFuncs.cc.

References egHLT::EgHLTDQMCut< T >::clone(), egHLT::OffPho::detEta(), egHLT::BinData::et, egHLT::OffPho::et(), egHLT::BinData::eta, egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, egHLT::BinData::Data1D::nr, NULL, egHLT::BinData::phi, and egHLT::OffPho::phi().

Referenced by initTrigTagProbeHist(), and initTrigTagProbeHists().

225 {
226  histVec.push_back(new MonElemWithCutEBEE<OffPho,float>(baseName+"_et",
227  baseName+" E_{T};E_{T} (GeV)",
228  bins.et.nr,bins.et.min,bins.et.max,&OffPho::et,cut));
229  histVec.push_back(new MonElemWithCutEBEE<OffPho,float>(baseName+"_eta",
230  baseName+" #eta;#eta",
231  bins.eta.nr,bins.eta.min,bins.eta.max,
232  &OffPho::detEta,cut ? cut->clone(): NULL));
233  histVec.push_back(new MonElemWithCutEBEE<OffPho,float>(baseName+"_phi",
234  baseName+" #phi;#phi (rad)",
235  bins.phi.nr,bins.phi.min,bins.phi.max,
236  &OffPho::phi,cut ? cut->clone():NULL));
237  /* histVec.push_back(new MonElemWithCutEBEE<OffPho,int>(baseName+"_charge",
238  baseName+" Charge; charge",
239  bins.charge.nr,bins.charge.min,bins.charge.max,
240  &OffPho::charge,cut ? cut->clone():NULL)); */
241 }
NULL
#define NULL
Definition: scimark2.h:8
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
phi
Definition: DDAxes.h:10
void egHLT::MonElemFuncs::initStdPhoHists ( std::vector< MonElemManagerBase< OffPho > * > &  histVec,
const std::string &  filterName,
const std::string &  baseName,
const BinData &  bins 
)

Definition at line 49 of file EgHLTMonElemFuncs.cc.

References egHLT::OffPho::detEta(), egHLT::BinData::e1x5, egHLT::OffPho::e1x5Over5x5(), egHLT::BinData::e2x5, egHLT::OffPho::e2x5MaxOver5x5(), egHLT::BinData::et, egHLT::OffPho::et(), egHLT::BinData::eta, egHLT::BinData::etaVsPhi, egHLT::BinData::etHigh, egHLT::OffPho::etSC(), egHLT::BinData::hOverE, egHLT::OffPho::hOverE(), egHLT::BinData::isolEm, egHLT::OffPho::isolEm(), egHLT::BinData::isolHad, egHLT::OffPho::isolHad(), egHLT::BinData::isolNrTrks, egHLT::OffPho::isolNrTrks(), egHLT::BinData::isolPtTrks, egHLT::OffPho::isolPtTrks(), egHLT::BinData::maxr9, egHLT::BinData::Data2D::nrX, egHLT::BinData::Data2D::nrY, egHLT::BinData::phi, egHLT::OffPho::phi(), egHLT::OffPho::r9(), egHLT::BinData::sigEtaEta, egHLT::OffPho::sigmaIEtaIEta(), egHLT::BinData::Data2D::xMax, egHLT::BinData::Data2D::xMin, egHLT::BinData::Data2D::yMax, and egHLT::BinData::Data2D::yMin.

Referenced by addTightLooseTrigHist(), and egHLT::PhoHLTFilterMon::PhoHLTFilterMon().

50 {
51  addStdHist<OffPho,float>(histVec,baseName+"_et",baseName+" E_{T};E_{T} (GeV)",bins.et,&OffPho::et);
52  addStdHist<OffPho,float>(histVec,baseName+"_etHigh",baseName+" E_{T};E_{T} (GeV)",bins.etHigh,&OffPho::et);
53  addStdHist<OffPho,float>(histVec,baseName+"_etSC",baseName+" E^{SC}_{T};E^{SC}_{T} (GeV)",bins.et,&OffPho::etSC);
54  addStdHist<OffPho,float>(histVec,baseName+"_eta",baseName+" #eta;#eta",bins.eta,&OffPho::detEta);
55  addStdHist<OffPho,float>(histVec,baseName+"_phi",baseName+" #phi;#phi (rad)",bins.phi,&OffPho::phi);
56 
57  addStdHist<OffPho,float>(histVec,baseName+"_hOverE",baseName+" H/E; H/E",bins.hOverE,&OffPho::hOverE);
58  //----Morse
59  //addStdHist<OffPho,float>(histVec,baseName+"_r9",baseName+" R9 ; R9",bins.r9,&OffPho::r9);
60  //addStdHist<OffPho,float>(histVec,baseName+"_minr9",baseName+" MINR9 ; MINR9",bins.minr9,&OffPho::r9);
61  addStdHist<OffPho,float>(histVec,baseName+"_maxr9",baseName+" MAXR9 ; MAXR9",bins.maxr9,&OffPho::r9);
62  //-------
63  addStdHist<OffPho,float>(histVec,baseName+"_sigmaIEtaIEta",baseName+"#sigma_{i#etai#eta}; #sigma_{i#etai#eta}",bins.sigEtaEta,&OffPho::sigmaIEtaIEta);
64  addStdHist<OffPho,float>(histVec,baseName+"_e2x5Over5x5",baseName+"E^{2x5}/E^{5x5}; E^{2x5}/E^{5x5}",bins.e2x5,&OffPho::e2x5MaxOver5x5);
65  addStdHist<OffPho,float>(histVec,baseName+"_e1x5Over5x5",baseName+"E^{1x5}/E^{5x5}; E^{1x5}/E^{5x5}",bins.e1x5,&OffPho::e1x5Over5x5);
66  addStdHist<OffPho,float>(histVec,baseName+"_isolEM",baseName+"Isol EM; Isol EM (GeV)",bins.isolEm,&OffPho::isolEm);
67  addStdHist<OffPho,float>(histVec,baseName+"_isolHad",baseName+"Isol Had; Isol Had (GeV)",bins.isolHad,&OffPho::isolHad);
68  addStdHist<OffPho,float>(histVec,baseName+"_isolPtTrks",baseName+"Isol Pt Trks; Isol Pt Tracks (GeV/c)",bins.isolPtTrks,&OffPho::isolPtTrks);
69  addStdHist<OffPho,int>(histVec,baseName+"_isolNrTrks",baseName+"Isol Nr Trks; Isol Nr Tracks",bins.isolNrTrks,&OffPho::isolNrTrks);
70  // addStdHist<OffPho,float>(histVec,baseName+"_hltIsolTrks",baseName+"HLT Isol Trks; HLT Iso Tracks (GeV/c)",bins.isolPtTrks,&OffPho::hltIsolTrks);
71  //addStdHist<OffPho,float>(histVec,baseName+"_hltIsolHad",baseName+"HLT Isol Had; HLT Isol Had (GeV)",bins.isolPtTrks,&OffPho::hltIsolHad);
72 
73  histVec.push_back(new MonElemManager2D<OffPho,float,float>(baseName+"_etaVsPhi",
74  baseName+" #eta vs #phi;#eta;#phi (rad)",
75  bins.etaVsPhi.nrX,bins.etaVsPhi.xMin,bins.etaVsPhi.xMax,
76  bins.etaVsPhi.nrY,bins.etaVsPhi.yMin,bins.etaVsPhi.yMax,
77  &OffPho::detEta,&OffPho::phi));
78 }
egHLT::BinData::isolNrTrks
Data1D isolNrTrks
Definition: EgHLTBinData.h:55
egHLT::BinData::isolPtTrks
Data1D isolPtTrks
Definition: EgHLTBinData.h:54
egHLT::BinData::sigEtaEta
Data1D sigEtaEta
Definition: EgHLTBinData.h:43
phi
Definition: DDAxes.h:10
void egHLT::MonElemFuncs::initTightLooseDiObjTrigHistsTrigCuts ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins 
)

Definition at line 364 of file EgHLTMonElemFuncs.cc.

References addTightLooseTrigHist(), egHLT::TrigCodes::getCode(), split, splitString(), and egHLT::OffEle::trigCutsCutCode().

Referenced by EgHLTOfflineSource::beginRun().

365 {
366  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
367  std::vector<std::string> splitString;
368  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
369  if(splitString.size()!=2) continue; //format incorrect
370  const std::string& tightTrig = splitString[0];
371  const std::string& looseTrig = splitString[1];
372  EgHLTDQMCut<OffEle>* eleCut = new EgDiEleUserCut<TrigCodes::TrigBitSet>(&OffEle::trigCutsCutCode,TrigCodes::getCode(tightTrig));
373  addTightLooseTrigHist(eleMonElems,tightTrig,looseTrig,eleCut,"gsfEle_trigCuts",bins);
374  }
375 }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
void egHLT::MonElemFuncs::initTightLooseDiObjTrigHistsTrigCuts ( std::vector< MonElemContainer< OffPho > * > &  phoMonElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins 
)

Definition at line 379 of file EgHLTMonElemFuncs.cc.

References addTightLooseTrigHist(), egHLT::TrigCodes::getCode(), split, splitString(), and egHLT::OffPho::trigCutsCutCode().

380 {
381  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
382  std::vector<std::string> splitString;
383  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
384  if(splitString.size()!=2) continue; //format incorrect
385  const std::string& tightTrig = splitString[0];
386  const std::string& looseTrig = splitString[1];
387  EgHLTDQMCut<OffPho>* phoCut = new EgDiPhoUserCut<TrigCodes::TrigBitSet>(&OffPho::trigCutsCutCode,TrigCodes::getCode(tightTrig));
388  addTightLooseTrigHist(phoMonElems,tightTrig,looseTrig,phoCut,"pho_trigCuts",bins);
389  }
390 }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
void egHLT::MonElemFuncs::initTightLooseTrigHists ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins,
EgHLTDQMCut< OffEle > *  eleCut 
)

Definition at line 244 of file EgHLTMonElemFuncs.cc.

References addTightLooseTrigHist(), egHLT::EgHLTDQMCut< T >::clone(), split, and splitString().

Referenced by EgHLTOfflineSource::beginRun().

245 {
246  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
247  std::vector<std::string> splitString;
248  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
249  if(splitString.size()!=2) continue; //format incorrect
250  const std::string& tightTrig = splitString[0];
251  const std::string& looseTrig = splitString[1];
252  //this step is necessary as we want to transfer ownership of eleCut to the addTrigLooseTrigHist func on the last iteration
253  //but clone it before that
254  //perhaps my object ownership rules need to be re-evalulated
255  if(trigNr!=tightLooseTrigs.size()-2) addTightLooseTrigHist(eleMonElems,tightTrig,looseTrig,eleCut->clone(),"gsfEle",bins);
256  else addTightLooseTrigHist(eleMonElems,tightTrig,looseTrig,eleCut,"gsfEle",bins);
257  }
258 }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
void egHLT::MonElemFuncs::initTightLooseTrigHists ( std::vector< MonElemContainer< OffPho > * > &  phoMonElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins,
EgHLTDQMCut< OffPho > *  phoCut 
)

Definition at line 261 of file EgHLTMonElemFuncs.cc.

References addTightLooseTrigHist(), egHLT::EgHLTDQMCut< T >::clone(), split, and splitString().

262 {
263  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
264  std::vector<std::string> splitString;
265  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
266  if(splitString.size()!=2) continue; //format incorrect
267  const std::string& tightTrig = splitString[0];
268  const std::string& looseTrig = splitString[1];
269 
270  //this step is necessary as we want to transfer ownership of phoCut to the addTrigLooseTrigHist func on the last iteration
271  //but clone it before that
272  //perhaps my object ownership rules need to be re-evalulated
273  if(trigNr!=tightLooseTrigs.size()-2) addTightLooseTrigHist(phoMonElems,tightTrig,looseTrig,phoCut->clone(),"pho",bins);
274  else addTightLooseTrigHist(phoMonElems,tightTrig,looseTrig,phoCut,"pho",bins);
275  }
276 }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::EgHLTDQMCut::clone
virtual EgHLTDQMCut< T > * clone() const =0
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
template<class T >
void egHLT::MonElemFuncs::initTightLooseTrigHists ( std::vector< MonElemContainer< T > * > &  monElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins,
const std::string &  objName 
)

Definition at line 108 of file EgHLTMonElemFuncs.h.

References addTightLooseTrigHist(), split, and splitString().

109  {
110  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
111  //dbe_->SetCurrentFolder(dirName_+"/"+tightLooseTrigs[trigNr]);
112  std::vector<std::string> splitString;
113  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
114  if(splitString.size()!=2) continue; //format incorrect
115  const std::string& tightTrig = splitString[0];
116  const std::string& looseTrig = splitString[1];
117  //this step is necessary as we want to transfer ownership of eleCut to the addTrigLooseTrigHist func on the last iteration
118  //but clone it before that
119  //perhaps my object ownership rules need to be re-evalulated
120  if(trigNr!=tightLooseTrigs.size()-2) addTightLooseTrigHist(monElems,tightTrig,looseTrig,objName,bins);
121  else addTightLooseTrigHist(monElems,tightTrig,looseTrig,objName,bins);
122  }
123  //dbe_->SetCurrentFolder(dirName_);
124  }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
void egHLT::MonElemFuncs::initTightLooseTrigHistsTrigCuts ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins 
)

Definition at line 335 of file EgHLTMonElemFuncs.cc.

References addTightLooseTrigHist(), egHLT::TrigCodes::getCode(), split, splitString(), and egHLT::OffEle::trigCutsCutCode().

336 {
337  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
338  std::vector<std::string> splitString;
339  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
340  if(splitString.size()!=2) continue; //format incorrect
341  const std::string& tightTrig = splitString[0];
342  const std::string& looseTrig = splitString[1];
343  EgHLTDQMCut<OffEle>* eleCut = new EgHLTDQMUserVarCut<OffEle,TrigCodes::TrigBitSet>(&OffEle::trigCutsCutCode,TrigCodes::getCode(tightTrig));
344  addTightLooseTrigHist(eleMonElems,tightTrig,looseTrig,eleCut,"gsfEle_trigCuts",bins);
345  }
346 }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
void egHLT::MonElemFuncs::initTightLooseTrigHistsTrigCuts ( std::vector< MonElemContainer< OffPho > * > &  phoMonElems,
const std::vector< std::string > &  tightLooseTrigs,
const BinData &  bins 
)

Definition at line 349 of file EgHLTMonElemFuncs.cc.

References addTightLooseTrigHist(), egHLT::TrigCodes::getCode(), split, splitString(), and egHLT::OffPho::trigCutsCutCode().

350 {
351  for(size_t trigNr=0;trigNr<tightLooseTrigs.size();trigNr++){
352  std::vector<std::string> splitString;
353  boost::split(splitString,tightLooseTrigs[trigNr],boost::is_any_of(std::string(":")));
354  if(splitString.size()!=2) continue; //format incorrect
355  const std::string& tightTrig = splitString[0];
356  const std::string& looseTrig = splitString[1];
357  EgHLTDQMCut<OffPho>* phoCut = new EgHLTDQMUserVarCut<OffPho,TrigCodes::TrigBitSet>(&OffPho::trigCutsCutCode,TrigCodes::getCode(tightTrig));
358  addTightLooseTrigHist(phoMonElems,tightTrig,looseTrig,phoCut,"pho_trigCuts",bins);
359  }
360 }
splitString
std::vector< std::string > splitString(const std::string &fLine)
Definition: HcalDbASCIIIO.cc:55
egHLT::MonElemFuncs::addTightLooseTrigHist
void addTightLooseTrigHist(std::vector< MonElemContainer< OffEle > * > &eleMonElems, const std::string &tightTrig, const std::string &looseTrig, EgHLTDQMCut< OffEle > *eleCut, const std::string &histId, const BinData &bins)
Definition: EgHLTMonElemFuncs.cc:282
split
double split
Definition: MVATrainer.cc:139
void egHLT::MonElemFuncs::initTrigTagProbeHist ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::string  filterName,
int  cutMask,
const BinData &  bins 
)

Definition at line 427 of file EgHLTMonElemFuncs.cc.

References egHLT::OffEle::cutCode(), egHLT::MonElemContainer< T >::cutMonElems(), egHLT::OffEle::etSC(), egHLT::TrigCodes::getCode(), initStdEleCutHists(), and egHLT::MonElemContainer< T >::name().

Referenced by EgHLTOfflineSource::beginRun().

428 {
429  std::string trigName(filterName);
430  //float etCutValue = 1.1*trigTools::getSecondEtThresFromName(filterName);
431  float etCutValue = 0.;
432  //std::cout<<"TrigName= "<<trigName<<" etCutValue= "<<etCutValue<<std::endl;
433  MonElemContainer<OffEle>* monElemCont = new MonElemContainer<OffEle>("trigTagProbe","Trigger Tag and Probe",new EgTrigTagProbeCut_New(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),cutMask,&OffEle::cutCode));
434  //this is all that pass trigtagprobecut
435  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_all",bins,new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC));
436  //this is all that pass trigtagprobecut and the probe passes the test trigger
437  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_pass",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND)));
438  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is NOT a tag
439  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_passNotTag",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND,TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffEle>::AND)));
440  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is also a tag
441  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_passTagTag",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND) << new EgObjTrigCut<OffEle>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffEle>::AND) ));
442  //this is all that pass trigtagprobecut and the probe fails the test trigger
443  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_fail",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),EgObjTrigCut<OffEle>::AND,TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND)));
444  /*
445  monElemCont->monElems().push_back(new MonElemMgrEBEE<OffEle,float>(trigName+"_"+monElemCont->name()+"_gsfEle_all_etUnCut",monElemCont->name()+"_gsfEle_all E_{T} (Uncut);E_{T} (GeV)",
446  bins.et.nr,bins.et.min,bins.et.max,&OffEle::et));
447  monElemCont->cutMonElems().push_back(new MonElemWithCutEBEE<OffEle,float>(trigName+"_"+monElemCont->name()+"_gsfEle_pass_etUnCut",monElemCont->name()+"_gsfEle_pass E_{T} (Uncut);E_{T} (GeV)",
448  bins.et.nr,bins.et.min,bins.et.max,&OffEle::et,new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND)));*/
449  eleMonElems.push_back(monElemCont);
450 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
reco_skim_cfg_mod.filterName
tuple filterName
Definition: reco_skim_cfg_mod.py:159
egHLT::MonElemFuncs::initStdEleCutHists
void initStdEleCutHists(std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffEle > *cut=NULL)
Definition: EgHLTMonElemFuncs.cc:200
egHLT::EgTrigTagProbeCut_New
Definition: EgHLTDQMCut.h:468
egHLT::MonElemContainer::cutMonElems
std::vector< MonElemWithCutBase< T > * > & cutMonElems()
Definition: EgHLTMonElemContainer.h:54
void egHLT::MonElemFuncs::initTrigTagProbeHist ( std::vector< MonElemContainer< OffPho > * > &  phoMonElems,
const std::string  filterName,
int  cutMask,
const BinData &  bins 
)

Definition at line 501 of file EgHLTMonElemFuncs.cc.

References egHLT::OffPho::cutCode(), egHLT::MonElemContainer< T >::cutMonElems(), egHLT::OffPho::etSC(), egHLT::TrigCodes::getCode(), initStdPhoCutHists(), and egHLT::MonElemContainer< T >::name().

502 {
503  std::string trigName(filterName);
504  //float etCutValue = 1.1*trigTools::getSecondEtThresFromName(trigName);
505  float etCutValue = 0.;
506  //std::cout<<"TrigName= "<<trigName<<" etCutValue= "<<etCutValue<<std::endl;
507  MonElemContainer<OffPho>* monElemCont = new MonElemContainer<OffPho>("trigTagProbe","Trigger Tag and Probe",new EgTrigTagProbeCut_NewPho(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),cutMask,&OffPho::cutCode));
508  //this is all that pass trigtagprobecut
509  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_all",bins,new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC));
510  //this is all that pass trigtagprobecut and the probe passes the test trigger
511  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_pass",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND)));
512  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is NOT a tag
513  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_passNotTag",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND,TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffPho>::AND)));
514  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is also a tag
515  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_passTagTag",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND) << new EgObjTrigCut<OffPho>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffPho>::AND) ));
516  //this is all that pass trigtagprobecut and the probe fails the test trigger
517  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_fail",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),EgObjTrigCut<OffPho>::AND,TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND)));
518  /*
519  monElemCont->monElems().push_back(new MonElemMgrEBEE<OffPho,float>(trigName+"_"+monElemCont->name()+"_pho_all_etUnCut",monElemCont->name()+"_gsfEle_all E_{T} (Uncut);E_{T} (GeV)",
520  bins.et.nr,bins.et.min,bins.et.max,&OffPho::et));
521  monElemCont->cutMonElems().push_back(new MonElemWithCutEBEE<OffPho,float>(trigName+"_"+monElemCont->name()+"_pho_pass_etUnCut",monElemCont->name()+"_gsfEle_pass E_{T} (Uncut);E_{T} (GeV)",
522  bins.et.nr,bins.et.min,bins.et.max,&OffPho::et,new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND)));*/
523  phoMonElems.push_back(monElemCont);
524 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
reco_skim_cfg_mod.filterName
tuple filterName
Definition: reco_skim_cfg_mod.py:159
egHLT::EgTrigTagProbeCut_NewPho
Definition: EgHLTDQMCut.h:485
egHLT::MonElemFuncs::initStdPhoCutHists
void initStdPhoCutHists(std::vector< MonElemWithCutBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffPho > *cut=NULL)
Definition: EgHLTMonElemFuncs.cc:224
egHLT::MonElemContainer::cutMonElems
std::vector< MonElemWithCutBase< T > * > & cutMonElems()
Definition: EgHLTMonElemContainer.h:54
void egHLT::MonElemFuncs::initTrigTagProbeHist_2Leg ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::string  filterName,
int  cutMask,
const BinData &  bins 
)

Definition at line 453 of file EgHLTMonElemFuncs.cc.

References egHLT::OffEle::cutCode(), egHLT::MonElemContainer< T >::cutMonElems(), egHLT::OffEle::etSC(), egHLT::TrigCodes::getCode(), initStdEleCutHists(), and egHLT::MonElemContainer< T >::name().

Referenced by EgHLTOfflineSource::beginRun().

454 {
455 
456  std::string trigNameLeg1 = filterName.substr(0,filterName.find("::"));
457  std::string trigNameLeg2 = filterName.substr(filterName.find("::")+2);
458 
459  float etCutValue = 0.;
460  MonElemContainer<OffEle>* monElemCont = new MonElemContainer<OffEle>("trigTagProbe","Trigger Tag and Probe",new EgTrigTagProbeCut_New(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),cutMask,&OffEle::cutCode));
461  //this is all that pass trigtagprobecut
462  //MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigNameLeg2,trigNameLeg2+"_"+monElemCont->name()+"_gsfEle_allEt20",bins,new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC));
463  //this is all that pass trigtagprobecut and the probe passes the first trigger
464  //MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigNameLeg2,trigNameLeg2+"_"+monElemCont->name()+"_gsfEle_passEt20",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigNameLeg1),EgObjTrigCut<OffEle>::AND)));
465  //this is all that pass trigtagprobecut and the probe passes the second trigger and fails the first trigger
466  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigNameLeg2,trigNameLeg2+"_"+monElemCont->name()+"_gsfEle_passLeg2failLeg1",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigNameLeg2),EgObjTrigCut<OffEle>::AND,TrigCodes::getCode(trigNameLeg1),EgObjTrigCut<OffEle>::AND)));
467 
468 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
reco_skim_cfg_mod.filterName
tuple filterName
Definition: reco_skim_cfg_mod.py:159
egHLT::MonElemFuncs::initStdEleCutHists
void initStdEleCutHists(std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffEle > *cut=NULL)
Definition: EgHLTMonElemFuncs.cc:200
egHLT::EgTrigTagProbeCut_New
Definition: EgHLTDQMCut.h:468
egHLT::MonElemContainer::cutMonElems
std::vector< MonElemWithCutBase< T > * > & cutMonElems()
Definition: EgHLTMonElemContainer.h:54
void egHLT::MonElemFuncs::initTrigTagProbeHists ( std::vector< MonElemContainer< OffEle > * > &  eleMonElems,
const std::vector< std::string >  filterNames,
int  cutMask,
const BinData &  bins 
)

Definition at line 397 of file EgHLTMonElemFuncs.cc.

References egHLT::OffEle::cutCode(), egHLT::MonElemContainer< T >::cutMonElems(), egHLT::OffEle::etSC(), egHLT::TrigCodes::getCode(), initStdEleCutHists(), and egHLT::MonElemContainer< T >::name().

398 {
399  for(size_t filterNr=0;filterNr<filterNames.size();filterNr++){
400 
401  std::string trigName(filterNames[filterNr]);
402  // float etCutValue = trigTools::getSecondEtThresFromName(trigName);
403  float etCutValue = 0.;
404  //std::cout<<"TrigName= "<<trigName<<" etCutValue= "<<etCutValue<<std::endl;
405  MonElemContainer<OffEle>* monElemCont = new MonElemContainer<OffEle>("trigTagProbe","Trigger Tag and Probe",new EgTrigTagProbeCut_New(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFiltesr"),cutMask,&OffEle::cutCode));
406  //this is all that pass trigtagprobecut
407  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_all",bins,new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC));
408  //this is all that pass trigtagprobecut and the probe passes the test trigger
409  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_pass",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND)));
410  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is NOT a tag
411  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_passNotTag",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND,TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffEle>::AND)));
412  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is also a tag
413  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_passTagTag",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND) << new EgObjTrigCut<OffEle>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffEle>::AND) ));
414  //this is all that pass trigtagprobecut and the probe fails the test trigger
415  MonElemFuncs::initStdEleCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_gsfEle_fail",bins,&(*(new EgMultiCut<OffEle>) << new EgGreaterCut<OffEle,float>(etCutValue,&OffEle::etSC) << new EgObjTrigCut<OffEle>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),EgObjTrigCut<OffEle>::AND,TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND)));
416  /*
417  monElemCont->monElems().push_back(new MonElemMgrEBEE<OffEle,float>(trigName+"_"+monElemCont->name()+"_gsfEle_all_etUnCut",monElemCont->name()+"_gsfEle_all E_{T} (Uncut);E_{T} (GeV)",
418  bins.et.nr,bins.et.min,bins.et.max,&OffEle::et));
419  monElemCont->cutMonElems().push_back(new MonElemWithCutEBEE<OffEle,float>(trigName+"_"+monElemCont->name()+"_gsfEle_pass_etUnCut",monElemCont->name()+"_gsfEle_pass E_{T} (Uncut);E_{T} (GeV)",
420  bins.et.nr,bins.et.min,bins.et.max,&OffEle::et,new EgObjTrigCut<OffEle>(TrigCodes::getCode(trigName),EgObjTrigCut<OffEle>::AND)));*/
421  eleMonElems.push_back(monElemCont);
422  } //end filter names loop
423 
424 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
egHLT::MonElemFuncs::initStdEleCutHists
void initStdEleCutHists(std::vector< MonElemWithCutBase< OffEle > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffEle > *cut=NULL)
Definition: EgHLTMonElemFuncs.cc:200
egHLT::EgTrigTagProbeCut_New
Definition: EgHLTDQMCut.h:468
egHLT::MonElemContainer::cutMonElems
std::vector< MonElemWithCutBase< T > * > & cutMonElems()
Definition: EgHLTMonElemContainer.h:54
void egHLT::MonElemFuncs::initTrigTagProbeHists ( std::vector< MonElemContainer< OffPho > * > &  phoMonElems,
const std::vector< std::string >  filterNames,
int  cutMask,
const BinData &  bins 
)

Definition at line 472 of file EgHLTMonElemFuncs.cc.

References egHLT::OffPho::cutCode(), egHLT::MonElemContainer< T >::cutMonElems(), egHLT::OffPho::etSC(), egHLT::TrigCodes::getCode(), initStdPhoCutHists(), and egHLT::MonElemContainer< T >::name().

473 {
474  for(size_t filterNr=0;filterNr<filterNames.size();filterNr++){
475 
476  std::string trigName(filterNames[filterNr]);
477  //float etCutValue = trigTools::getSecondEtThresFromName(trigName);
478  float etCutValue = 0.;
479  //std::cout<<"TrigName= "<<trigName<<" etCutValue= "<<etCutValue<<std::endl;
480  MonElemContainer<OffPho>* monElemCont = new MonElemContainer<OffPho>("trigTagProbe","Trigger Tag and Probe",new EgTrigTagProbeCut_NewPho(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),cutMask,&OffPho::cutCode));
481  //this is all that pass trigtagprobecut
482  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_all",bins,new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC));
483  //this is all that pass trigtagprobecut and the probe passes the test trigger
484  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_pass",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND)));
485  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is NOT a tag
486  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_passNotTag",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND,TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffPho>::AND)));
487  //this is all that pass trigtagprobecut and the probe passes the test trigger and the probe is also a tag
488  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_passTagTag",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND) << new EgObjTrigCut<OffPho>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17TrackIsolFilter"),EgObjTrigCut<OffPho>::AND) ));
489  //this is all that pass trigtagprobecut and the probe fails the test trigger
490  MonElemFuncs::initStdPhoCutHists(monElemCont->cutMonElems(),trigName,trigName+"_"+monElemCont->name()+"_pho_fail",bins,&(*(new EgMultiCut<OffPho>) << new EgGreaterCut<OffPho,float>(etCutValue,&OffPho::etSC) << new EgObjTrigCut<OffPho>(TrigCodes::getCode("hltEle32CaloIdTCaloIsoTTrkIdTTrkIsoTSC17HEDoubleFilter"),EgObjTrigCut<OffPho>::AND,TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND)));
491  /*
492  monElemCont->monElems().push_back(new MonElemMgrEBEE<OffPho,float>(trigName+"_"+monElemCont->name()+"_pho_all_etUnCut",monElemCont->name()+"_gsfEle_all E_{T} (Uncut);E_{T} (GeV)",
493  bins.et.nr,bins.et.min,bins.et.max,&OffPho::et));
494  monElemCont->cutMonElems().push_back(new MonElemWithCutEBEE<OffPho,float>(trigName+"_"+monElemCont->name()+"_pho_pass_etUnCut",monElemCont->name()+"_gsfEle_pass E_{T} (Uncut);E_{T} (GeV)",
495  bins.et.nr,bins.et.min,bins.et.max,&OffPho::et,new EgObjTrigCut<OffPho>(TrigCodes::getCode(trigName),EgObjTrigCut<OffPho>::AND)));*/
496  phoMonElems.push_back(monElemCont);
497  } //end filter names loop
498 
499 }
egHLT::MonElemContainer::name
const std::string & name() const
Definition: EgHLTMonElemContainer.h:60
egHLT::EgTrigTagProbeCut_NewPho
Definition: EgHLTDQMCut.h:485
egHLT::MonElemFuncs::initStdPhoCutHists
void initStdPhoCutHists(std::vector< MonElemWithCutBase< OffPho > * > &histVec, const std::string &filterName, const std::string &baseName, const BinData &bins, EgHLTDQMCut< OffPho > *cut=NULL)
Definition: EgHLTMonElemFuncs.cc:224
egHLT::MonElemContainer::cutMonElems
std::vector< MonElemWithCutBase< T > * > & cutMonElems()
Definition: EgHLTMonElemContainer.h:54
Generated for CMSSW Reference Manual by doxygen 1.8.5