#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 (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 39 of file EgHLTPhoHLTFilterMon.h.

Constructor & Destructor Documentation

egHLT::PhoHLTFilterMon::PhoHLTFilterMon ( const PhoHLTFilterMon & ) [inline, private]

Definition at line 72 of file EgHLTPhoHLTFilterMon.h.

{}

PhoHLTFilterMon::PhoHLTFilterMon	(	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::OffPho::et(), egHLT::BinData::et, egHLT::BinData::eta, egHLT::OffPho::eta(), filterName_, i, egHLT::MonElemFuncs::initStdEffHists(), egHLT::MonElemFuncs::initStdPhoHists(), egHLT::BinData::mass, egHLT::BinData::massHigh, mergeVDriftHistosByStation::name, phoEffHists_, phoFailMonElems_, and phoMonElems_.

                                                                                                                                   :
  filterName_(filterName),
  filterBit_(filterBit)
{
  bool monHLTFailedPho=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_+"_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_+"_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)));
  for(size_t i=0;i<phoEffHists_.size();i++){ 
    MonElemFuncs::initStdEffHists(phoEffHists_[i]->cutMonElems(),
                                  filterName_+"_pho_effVsEt"+phoEffHists_[i]->name(),bins.et,&OffPho::et,masks);
    MonElemFuncs::initStdEffHists(phoEffHists_[i]->cutMonElems(),
                                  filterName_+"_pho_effVsEta"+phoEffHists_[i]->name(),bins.eta,&OffPho::eta,masks); 
    /* MonElemFuncs::initStdEffHists(phoEffHists_[i]->cutMonElems(),
       filterName_+"_pho_effVsPhi"+phoEffHists_[i]->name(),bins.phi,&OffPho::phi,masks);*/
  }

  typedef MonElemManager<ParticlePair<OffPho>,float >  DiPhoMon;
  diPhoMassBothME_ = new DiPhoMon(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(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(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(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 58 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 70 of file EgHLTPhoHLTFilterMon.cc.

References diPhoMassBothME_, diPhoMassOnlyOneME_, egHLT::OffEvt::evtTrigBits(), egHLT::MonElemManagerBase< T >::fill(), 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(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
}