#include <EgHLTPhoHLTFilterMon.h>

Classes
struct	ptrCompStr

struct	ptrLess

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

const std::string &	filterName () const

bool	operator< (const PhoHLTFilterMon &rhs) const

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

	~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_

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 73 of file EgHLTPhoHLTFilterMon.h.

73 {}

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

Definition at line 14 of file EgHLTPhoHLTFilterMon.cc.

References diPhoMassBothHighME_, diPhoMassBothME_, diPhoMassOnlyOneHighME_, diPhoMassOnlyOneME_, egHLT::BinData::et, egHLT::OffPho::et(), egHLT::BinData::eta, egHLT::OffPho::eta(), filterName_, egHLT::MonElemFuncs::getIB(), i, egHLT::MonElemFuncs::initStdEffHists(), egHLT::MonElemFuncs::initStdPhoHists(), egHLT::BinData::mass, egHLT::BinData::massHigh, egHLT::BinData::Data1D::max, egHLT::BinData::Data1D::min, mergeVDriftHistosByStation::name, egHLT::BinData::Data1D::nr, phoEffHists_, phoFailMonElems_, and phoMonElems_.

                                                                                                                                                                :
   filterName_(filterName),
   filterBit_(filterBit)
 {
   bool monHLTFailedPho=false;
   bool doN1andSingleEffsPho=false;
 
   phoMonElems_.push_back(new MonElemContainer<OffPho>());
   //phoMonElems_.push_back(new MonElemContainer<OffPho>("_cut"," cut, debug hists ",new EgHLTDQMVarCut<OffPho>(~0x0,&OffPho::cutCode)));
   for(size_t i=0;i<phoMonElems_.size();i++){
     monElemFuncs.initStdPhoHists(phoMonElems_[i]->monElems(),filterName_,filterName_+"_pho_passFilter"+phoMonElems_[i]->name(),bins);
   }
   
   if(monHLTFailedPho) phoFailMonElems_.push_back(new MonElemContainer<OffPho>());
   for(size_t i=0;i<phoFailMonElems_.size();i++){
     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(size_t i=0;i<phoEffHists_.size();i++){ 
       monElemFuncs.initStdEffHists(phoEffHists_[i]->cutMonElems(),filterName_,
                     filterName_+"_pho_effVsEt"+phoEffHists_[i]->name(),bins.et,&OffPho::et,masks);
       monElemFuncs.initStdEffHists(phoEffHists_[i]->cutMonElems(),filterName_,
                     filterName_+"_pho_effVsEta"+phoEffHists_[i]->name(),bins.eta,&OffPho::eta,masks); 
       /* monElemFuncs.initStdEffHists(phoEffHists_[i]->cutMonElems(),filterName_,
      filterName_+"_pho_effVsPhi"+phoEffHists_[i]->name(),bins.phi,&OffPho::phi,masks);*/
     }
   }
   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 60 of file EgHLTPhoHLTFilterMon.cc.

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

 {
   for(size_t i=0;i<phoMonElems_.size();i++) delete phoMonElems_[i];
   for(size_t i=0;i<phoFailMonElems_.size();i++) delete phoFailMonElems_[i];
   for(size_t i=0;i<phoEffHists_.size();i++) delete phoEffHists_[i];
   delete diPhoMassBothME_;
   delete diPhoMassOnlyOneME_; 
   delete diPhoMassBothHighME_;
   delete diPhoMassOnlyOneHighME_;
 }

Member Function Documentation

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

Definition at line 72 of file EgHLTPhoHLTFilterMon.cc.

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

Referenced by fill().

 { 
   for(size_t phoNr=0;phoNr<evt.phos().size();phoNr++){
     const OffPho& pho = evt.phos()[phoNr];
     if((pho.trigBits()&filterBit_)!=0){ //pho passes
       for(size_t monElemNr=0;monElemNr<phoMonElems_.size();monElemNr++) phoMonElems_[monElemNr]->fill(pho,evt,weight);
       for(size_t monElemNr=0;monElemNr<phoEffHists_.size();monElemNr++) phoEffHists_[monElemNr]->fill(pho,evt,weight);
     }else { //pho didnt pass trigger
       for(size_t monElemNr=0;monElemNr<phoFailMonElems_.size();monElemNr++) phoFailMonElems_[monElemNr]->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((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
 }