#include <EgHLTPhoHLTFilterMon.h>

Public Member Functions
void	fill (const OffEvt &evt, float weight)

const std::string &	filterName () const

bool	operator< (const PhoHLTFilterMon &rhs) const

	PhoHLTFilterMon (MonElemFuncs &monElemFuncs, std::string filterName, TrigCodes::TrigBitSet filterBit, const BinData &bins, const CutMasks &masks, bool doHEP)

bool	ptrCompStr (const PhoHLTFilterMon *lhs, const std::string &rhs)

bool	ptrCompStr (const std::string &lhs, const PhoHLTFilterMon *rhs)

template<class T >
bool	ptrLess (const T lhs, const T rhs)

	~PhoHLTFilterMon ()

Private Member Functions
PhoHLTFilterMon &	operator= (const PhoHLTFilterMon &)

	PhoHLTFilterMon (const PhoHLTFilterMon &)

Private Attributes
MonElemManagerBase< ParticlePair< OffPho > > *	diPhoMassBothHighME_

MonElemManagerBase< ParticlePair< OffPho > > *	diPhoMassBothME_

MonElemManagerBase< ParticlePair< OffPho > > *	diPhoMassOnlyOneHighME_

MonElemManagerBase< ParticlePair< OffPho > > *	diPhoMassOnlyOneME_

bool	doHEP_

const TrigCodes::TrigBitSet	filterBit_

std::string	filterName_

std::vector< MonElemContainer< OffPho > * >	phoEffHists_

std::vector< MonElemContainer< OffPho > * >	phoFailMonElems_

std::vector< MonElemContainer< OffPho > * >	phoMonElems_

std::vector< MonElemManagerBase< trigger::TriggerObject > * >	trigMonElems_

Detailed Description

Definition at line 40 of file EgHLTPhoHLTFilterMon.h.

Constructor & Destructor Documentation

egHLT::PhoHLTFilterMon::PhoHLTFilterMon ( const PhoHLTFilterMon & )

inlineprivate

Definition at line 70 of file EgHLTPhoHLTFilterMon.h.

70 {}

PhoHLTFilterMon::PhoHLTFilterMon	(	MonElemFuncs &	monElemFuncs,
		std::string	filterName,
		TrigCodes::TrigBitSet	filterBit,
		const BinData &	bins,
		const CutMasks &	masks,
		bool	doHEP
	)

Definition at line 16 of file EgHLTPhoHLTFilterMon.cc.

References create_public_pileup_plots::bins, diPhoMassBothHighME_, diPhoMassBothME_, diPhoMassOnlyOneHighME_, diPhoMassOnlyOneME_, doHEP_, egHLT::BinData::et, egHLT::OffPho::et(), egHLT::BinData::eta, egHLT::OffPho::eta(), filterName_, egHLT::MonElemFuncs::getIB(), mps_fire::i, egHLT::MonElemFuncs::initStdEffHists(), egHLT::MonElemFuncs::initStdPhoHists(), egHLT::MonElemFuncs::initStdPhoHistsHEP(), egHLT::BinData::mass, egHLT::BinData::massHigh, egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, dataset::name, egHLT::BinData::Data1D::nr, phoEffHists_, phoFailMonElems_, phoMonElems_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                                                                      :
   filterName_(std::move(filterName)),
   filterBit_(filterBit),
   doHEP_(doHEP)
 {
   bool monHLTFailedPho=false;
   bool doN1andSingleEffsPho=false;
   std::string histname="egamma";
  
   phoMonElems_.push_back(new MonElemContainer<OffPho>());
   //phoMonElems_.push_back(new MonElemContainer<OffPho>("_cut"," cut, debug hists ",new EgHLTDQMVarCut<OffPho>(~0x0,&OffPho::cutCode)));
   for(auto & phoMonElem : phoMonElems_){
    if(doHEP_){
                monElemFuncs.initStdPhoHistsHEP(phoMonElem->monElems(),filterName_,histname+"_passFilter"+phoMonElem->name(),bins);
               }else{ 
                      monElemFuncs.initStdPhoHists(phoMonElem->monElems(),filterName_,filterName_+"_pho_passFilter"+phoMonElem->name(),bins);
                     }
   }
 
   if(monHLTFailedPho) phoFailMonElems_.push_back(new MonElemContainer<OffPho>());
 
   for(size_t i=0;i<phoFailMonElems_.size();i++){
    if(doHEP_){
                monElemFuncs.initStdPhoHistsHEP(phoFailMonElems_[i]->monElems(),filterName_,histname+"_failFilter"+phoMonElems_[i]->name(),bins);
              }else{ 
                    monElemFuncs.initStdPhoHists(phoFailMonElems_[i]->monElems(),filterName_,filterName_+"_pho_failFilter"+phoMonElems_[i]->name(),bins);
                   }
   } 
   phoEffHists_.push_back(new MonElemContainer<OffPho>()); 
   // phoEffHists_.push_back(new MonElemContainer<OffPho>("_jetTag"," Tag and Probe ",new EgJetB2BCut<OffPho>(-M_PI/12,M_PI/12,0.3)));
   if(doN1andSingleEffsPho){
     for(auto & phoEffHist : phoEffHists_){ 
       monElemFuncs.initStdEffHists(phoEffHist->cutMonElems(),filterName_,
                     filterName_+"_pho_effVsEt"+phoEffHist->name(),bins.et,&OffPho::et,masks);
       monElemFuncs.initStdEffHists(phoEffHist->cutMonElems(),filterName_,
                     filterName_+"_pho_effVsEta"+phoEffHist->name(),bins.eta,&OffPho::eta,masks); 
       /* monElemFuncs.initStdEffHists(phoEffHists_[i]->cutMonElems(),filterName_,
      filterName_+"_pho_effVsPhi"+phoEffHists_[i]->name(),bins.phi,&OffPho::phi,masks);*/
     }
   }
  if(!doHEP_)
  {
   typedef MonElemManager<ParticlePair<OffPho>,float >  DiPhoMon;
   diPhoMassBothME_ = new DiPhoMon(monElemFuncs.getIB(), filterName_+"_diPho_bothPassFilter_mass",
                   filterName_+"_diPho_bothPassFilter Mass;M_{#gamma#gamma} (GeV/c^{2})",
                   bins.mass.nr,bins.mass.min,bins.mass.max,&ParticlePair<OffPho>::mass);
   diPhoMassOnlyOneME_ = new DiPhoMon(monElemFuncs.getIB(), filterName_+"_diPho_onlyOnePassFilter_mass",
                      filterName_+"_diPho_onlyOnePassFilter Mass;M_{#gamma#gamma} (GeV/c^{2})",
                      bins.mass.nr,bins.mass.min,bins.mass.max,&ParticlePair<OffPho>::mass);
   diPhoMassBothHighME_ = new DiPhoMon(monElemFuncs.getIB(), filterName_+"_diPho_bothPassFilter_massHigh",
                   filterName_+"_diPho_bothPassFilter Mass;M_{#gamma#gamma} (GeV/c^{2})",
                   bins.massHigh.nr,bins.massHigh.min,bins.massHigh.max,&ParticlePair<OffPho>::mass);
   diPhoMassOnlyOneHighME_ = new DiPhoMon(monElemFuncs.getIB(), filterName_+"_diPho_onlyOnePassFilter_massHigh",
                      filterName_+"_diPho_onlyOnePassFilter Mass;M_{#gamma#gamma} (GeV/c^{2})",
                      bins.massHigh.nr,bins.massHigh.min,bins.massHigh.max,&ParticlePair<OffPho>::mass);
   
  }
 }

PhoHLTFilterMon::~PhoHLTFilterMon ( )

Definition at line 75 of file EgHLTPhoHLTFilterMon.cc.

References diPhoMassBothHighME_, diPhoMassBothME_, diPhoMassOnlyOneHighME_, diPhoMassOnlyOneME_, doHEP_, phoEffHists_, phoFailMonElems_, and phoMonElems_.

 {
   for(auto & phoMonElem : phoMonElems_) delete phoMonElem;
   for(auto & phoFailMonElem : phoFailMonElems_) delete phoFailMonElem;
   for(auto & phoEffHist : phoEffHists_) delete phoEffHist;
  if(!doHEP_)
  { 
   delete diPhoMassBothME_;
   delete diPhoMassOnlyOneME_; 
   delete diPhoMassBothHighME_;
   delete diPhoMassOnlyOneHighME_;
  }
 }

Member Function Documentation

void PhoHLTFilterMon::fill	(	const OffEvt &	evt,
		float	weight
	)

Definition at line 89 of file EgHLTPhoHLTFilterMon.cc.

References diPhoMassBothME_, diPhoMassOnlyOneME_, doHEP_, egHLT::OffEvt::evtTrigBits(), filterBit_, phoEffHists_, phoFailMonElems_, phoMonElems_, egHLT::OffEvt::phos(), and egHLT::OffPho::trigBits().

 { 
   for(size_t phoNr=0;phoNr<evt.phos().size();phoNr++){
     const OffPho& pho = evt.phos()[phoNr];
     if((pho.trigBits()&filterBit_)!=0){ //pho passes
       for(auto & phoMonElem : phoMonElems_) phoMonElem->fill(pho,evt,weight);
       for(auto & phoEffHist : phoEffHists_) phoEffHist->fill(pho,evt,weight);
     }else { //pho didnt pass trigger
       for(auto & phoFailMonElem : phoFailMonElems_) phoFailMonElem->fill(pho,evt,weight);
     }
   }//end loop over photons
 
 
 
   if((evt.evtTrigBits()&filterBit_)!=0){
     for(size_t pho1Nr=0;pho1Nr<evt.phos().size();pho1Nr++){
       for(size_t pho2Nr=pho1Nr+1;pho2Nr<evt.phos().size();pho2Nr++){
     const OffPho& pho1 = evt.phos()[pho1Nr];
     const OffPho& pho2 = evt.phos()[pho2Nr];
         if(!doHEP_)
        {    
     if((pho1.trigBits()&pho2.trigBits()&filterBit_)==filterBit_) diPhoMassBothME_->fill(ParticlePair<OffPho>(pho1,pho2),weight);
     else if((pho1.trigBits()&filterBit_)==filterBit_ || 
         (pho2.trigBits()&filterBit_)==filterBit_){
       diPhoMassOnlyOneME_->fill(ParticlePair<OffPho>(pho1,pho2),weight);
     }
        }
       }//end inner pho loop
     }//end outer pho loop
   }//end check if filter is present
 }