#include <EmDQMReco.h>

Inheritance diagram for EmDQMReco:

Classes
class	FourVectorMonitorElements

Public Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &)

void	beginJob ()

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

void	dqmBeginRun (const edm::Run &, const edm::EventSetup &)

	EmDQMReco (const edm::ParameterSet &pset)
	Constructor. More...

void	endJob ()

	~EmDQMReco ()
	Destructor. More...

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	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

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Attributes
std::string	dirname_

int	eventnum

HistoFillerReco < reco::RecoEcalCandidateCollection > *	histoFillerClu

HistoFillerReco < reco::ElectronCollection > *	histoFillerEle

HistoFillerReco < l1extra::L1EmParticleCollection > *	histoFillerL1Iso

HistoFillerReco < l1extra::L1EmParticleCollection > *	histoFillerL1NonIso

HistoFillerReco < reco::RecoEcalCandidateCollection > *	histoFillerPho

HLTConfigProvider	hltConfig_

edm::EDGetTokenT < edm::TriggerResults >	hltResultsT

bool	isHltConfigInitialized_

std::vector< std::vector < edm::InputTag > >	isoNames

unsigned int	numOfHLTCollectionLabels

int	pdgGen

unsigned int	plotBins

std::vector< std::pair< double, double > >	plotBounds

double	plotEtaMax

std::vector< bool >	plotiso

double	plotPhiMax

double	plotPtMax

double	plotPtMin

std::string	processNameRecoMonPath

GreaterByPt< reco::Particle >	pTComparator_

GreaterByPt< reco::GsfElectron >	pTRecoComparator_

unsigned int	recocut_

edm::EDGetTokenT < reco::GsfElectronCollection >	recoElectronsInput

double	recoEtaAcc

double	recoEtAcc

edm::EDGetTokenT< std::vector < reco::SuperCluster > >	recoObjectsEBT

edm::EDGetTokenT< std::vector < reco::SuperCluster > >	recoObjectsEET

unsigned int	reqNum

std::vector< std::string >	theHLTCollectionHumanNames

std::vector< edm::InputTag >	theHLTCollectionLabels

std::string	theHltName

std::vector< int >	theHLTOutputTypes

MonitorElement *	totalmatchreco

MonitorElement *	totalreco

std::string	triggerNameRecoMonPath

edm::EDGetTokenT < trigger::TriggerEventWithRefs >	triggerObjT

bool	useHumanReadableHistTitles


boost::ptr_vector < FourVectorMonitorElements >	standardHist

boost::ptr_vector < FourVectorMonitorElements >	histMatchReco

boost::ptr_vector < FourVectorMonitorElements >	histMatchRecoMonPath

boost::ptr_vector < FourVectorMonitorElements >	histHltObjMatchToReco


std::vector< MonitorElement * >	etahistiso

std::vector< MonitorElement * >	ethistiso

std::vector< MonitorElement * >	phiHistIso

std::vector< MonitorElement * >	etahistisomatchreco

std::vector< MonitorElement * >	ethistisomatchreco

std::vector< MonitorElement * >	phiHistIsoMatchReco

std::vector< MonitorElement * >	histEtIsoOfHltObjMatchToReco

std::vector< MonitorElement * >	histEtaIsoOfHltObjMatchToReco

std::vector< MonitorElement * >	histPhiIsoOfHltObjMatchToReco

reco histograms
boost::scoped_ptr < FourVectorMonitorElements >	histReco

boost::scoped_ptr < FourVectorMonitorElements >	histRecoMonpath

boost::scoped_ptr < FourVectorMonitorElements >	histMonpath

Friends
class	HistoFillerReco< l1extra::L1EmParticleCollection >

class	HistoFillerReco< reco::ElectronCollection >

class	HistoFillerReco< reco::RecoEcalCandidateCollection >

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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

Definition at line 43 of file EmDQMReco.h.

Constructor & Destructor Documentation

EmDQMReco::EmDQMReco ( const edm::ParameterSet & pset )

explicit

Constructor.

Definition at line 102 of file EmDQMReco.cc.

References assert(), edm::EDConsumerBase::consumes(), dirname_, eventnum, filters, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), histoFillerClu, histoFillerEle, histoFillerL1Iso, histoFillerL1NonIso, histoFillerPho, hltResultsT, i, HLT_25ns14e33_v1_cff::InputTag, isHltConfigInitialized_, isoNames, HistoFillerReco< T >::isoNameTokens_, numOfHLTCollectionLabels, pdgGen, plotBins, plotBounds, plotEtaMax, plotiso, plotPhiMax, plotPtMax, plotPtMin, processNameRecoMonPath, recocut_, recoElectronsInput, recoEtaAcc, recoEtAcc, recoObjectsEBT, recoObjectsEET, reqNum, AlCaHLTBitMon_QueryRunRegistry::string, theHLTCollectionHumanNames, theHLTCollectionLabels, theHLTOutputTypes, trigger::TriggerCluster, trigger::TriggerElectron, trigger::TriggerL1IsoEG, trigger::TriggerL1NoIsoEG, triggerNameRecoMonPath, triggerObjT, trigger::TriggerPhoton, and useHumanReadableHistTitles.

 {
   //          Read from configuration file                  //
   dirname_="HLT/HLTEgammaValidation/"+pset.getParameter<std::string>("@module_label");
 
   // parameters for generator study
   reqNum    = pset.getParameter<unsigned int>("reqNum");
   pdgGen    = pset.getParameter<int>("pdgGen");
   recoEtaAcc = pset.getParameter<double>("genEtaAcc");
   recoEtAcc  = pset.getParameter<double>("genEtAcc");
   // plotting parameters (untracked because they don't affect the physics)
   plotPtMin  = pset.getUntrackedParameter<double>("PtMin",0.);
   plotPtMax  = pset.getUntrackedParameter<double>("PtMax",1000.);
   plotEtaMax = pset.getUntrackedParameter<double>("EtaMax", 2.7);
   plotPhiMax = pset.getUntrackedParameter<double>("PhiMax", 3.15);
   plotBins   = pset.getUntrackedParameter<unsigned int>("Nbins",50);
   useHumanReadableHistTitles = pset.getUntrackedParameter<bool>("useHumanReadableHistTitles", false);
 
   triggerNameRecoMonPath = pset.getUntrackedParameter<std::string>("triggerNameRecoMonPath","HLT_MinBias");
   processNameRecoMonPath = pset.getUntrackedParameter<std::string>("processNameRecoMonPath","HLT");
 
   recoElectronsInput = consumes<reco::GsfElectronCollection>(pset.getUntrackedParameter<edm::InputTag>("recoElectrons",edm::InputTag("gsfElectrons")));
   recoObjectsEBT = consumes<std::vector<reco::SuperCluster>>(edm::InputTag("correctedHybridSuperClusters"));
   recoObjectsEET = consumes<std::vector<reco::SuperCluster>>(edm::InputTag("correctedMulti5x5SuperClustersWithPreshower"));
   hltResultsT    = consumes<edm::TriggerResults>(edm::InputTag("TriggerResults","",processNameRecoMonPath));
   triggerObjT    = consumes<trigger::TriggerEventWithRefs>(edm::InputTag("hltTriggerSummaryRAW"));
 
   // preselction cuts
   // recocutCollection_= pset.getParameter<edm::InputTag>("cutcollection");
   recocut_          = pset.getParameter<int>("cutnum");
 
   // prescale = 10;
   eventnum = 0;
 
   // just init
   isHltConfigInitialized_ = false;
 
   //         Read in the Vector of Parameter Sets.          //
   //           Information for each filter-step             //
   std::vector<edm::ParameterSet> filters =
        pset.getParameter<std::vector<edm::ParameterSet> >("filters");
 
   int i = 0;
   for(std::vector<edm::ParameterSet>::iterator filterconf = filters.begin() ; filterconf != filters.end() ; filterconf++)
   {
 
     theHLTCollectionLabels.push_back(filterconf->getParameter<edm::InputTag>("HLTCollectionLabels"));
     theHLTOutputTypes.push_back(filterconf->getParameter<int>("theHLTOutputTypes"));
     // Grab the human-readable name, if it is not specified, use the Collection Label
     theHLTCollectionHumanNames.push_back(filterconf->getUntrackedParameter<std::string>("HLTCollectionHumanName",theHLTCollectionLabels[i].label()));
 
     std::vector<double> bounds = filterconf->getParameter<std::vector<double> >("PlotBounds");
     // If the size of plot "bounds" vector != 2, abort
     assert(bounds.size() == 2);
     plotBounds.push_back(std::pair<double,double>(bounds[0],bounds[1]));
     isoNames.push_back(filterconf->getParameter<std::vector<edm::InputTag> >("IsoCollections"));
     
     for (unsigned int i=0; i<isoNames.back().size(); i++) {
       switch(theHLTOutputTypes.back())  {
       case trigger::TriggerL1NoIsoEG: 
     histoFillerL1NonIso->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<l1extra::L1EmParticleCollection , float>>>(isoNames.back()[i]));
     break;
       case trigger::TriggerL1IsoEG: // Isolated Level 1
     histoFillerL1Iso->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<l1extra::L1EmParticleCollection , float>>>(isoNames.back()[i]));
     break;
       case trigger::TriggerPhoton: // Photon 
     histoFillerPho->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<reco::RecoEcalCandidateCollection , float>>>(isoNames.back()[i]));
     break;
       case trigger::TriggerElectron: // Electron 
     histoFillerEle->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<reco::ElectronCollection , float>>>(isoNames.back()[i]));
     break;
       case trigger::TriggerCluster: // TriggerCluster
     histoFillerClu->isoNameTokens_.push_back(consumes<edm::AssociationMap<edm::OneToValue<reco::RecoEcalCandidateCollection , float>>>(isoNames.back()[i]));
     break;
       default: 
     throw(cms::Exception("Release Validation Error") << "HLT output type not implemented: theHLTOutputTypes[n]" );
       }
     }
     
     // If the size of the isoNames vector is not greater than zero, abort
     assert(isoNames.back().size()>0);
     if (isoNames.back().at(0).label()=="none") {
       plotiso.push_back(false);
     } else {
       plotiso.push_back(true);
     }
     i++;
   } // END of loop over parameter sets
 
   // Record number of HLTCollectionLabels
   numOfHLTCollectionLabels = theHLTCollectionLabels.size();
 
 }

EmDQMReco::~EmDQMReco ( )

Destructor.

Definition at line 505 of file EmDQMReco.cc.

505 {

506 }

Member Function Documentation

void EmDQMReco::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

virtual

NOTE: hltConfigProvider initialization has been moved to beginRun()

Implements edm::stream::EDAnalyzerBase.

Definition at line 513 of file EmDQMReco.cc.

References reco::Particle::energy(), eventnum, MonitorElement::Fill(), HistoFillerReco< T >::fillHistos(), histoFillerClu, histoFillerEle, histoFillerL1Iso, histoFillerL1NonIso, histoFillerPho, histReco, histRecoMonpath, hltConfig_, hltResultsT, i, isHltConfigInitialized_, edm::HandleBase::isValid(), gen::n, numOfHLTCollectionLabels, p4, pdgGen, funct::pow(), pTComparator_, recocut_, recoElectronsInput, recoObjectsEBT, recoObjectsEET, reqNum, findQualityFiles::size, python.multivaluedict::sort(), mathSSE::sqrt(), theHLTOutputTypes, totalmatchreco, totalreco, trigger::TriggerCluster, trigger::TriggerElectron, HLTConfigProvider::triggerIndex(), trigger::TriggerL1IsoEG, trigger::TriggerL1NoIsoEG, triggerNameRecoMonPath, triggerObjT, and trigger::TriggerPhoton.

 {
 
   // protect from hlt config failure
   if( !isHltConfigInitialized_ ) return;
 
   eventnum++;
   bool plotMonpath = false;
   bool plotReco = true;
 
   edm::Handle<edm::View<reco::Candidate> > recoObjects;
   edm::Handle<std::vector<reco::SuperCluster> > recoObjectsEB;
   edm::Handle<std::vector<reco::SuperCluster> > recoObjectsEE;
 
   if (pdgGen == 11) {
 
     event.getByToken(recoElectronsInput, recoObjects);
 
     if (recoObjects->size() < (unsigned int)recocut_) {
       // edm::LogWarning("EmDQMReco") << "Less than "<< recocut_ <<" Reco particles with pdgId=" << pdgGen << ".  Only " << cutRecoCounter->size() << " particles.";
       return;
     }
   } else if (pdgGen == 22) {
 
     event.getByToken(recoObjectsEBT, recoObjectsEB);
     event.getByToken(recoObjectsEET, recoObjectsEE);
 
     if (recoObjectsEB->size() + recoObjectsEE->size() < (unsigned int)recocut_) {
       // edm::LogWarning("EmDQMReco") << "Less than "<< recocut_ <<" Reco particles with pdgId=" << pdgGen << ".  Only " << cutRecoCounter.size() << " particles.";
       return;
     }
   }
 
   edm::Handle<edm::TriggerResults> HLTR;
   event.getByToken(hltResultsT, HLTR);
 
 
   /* if (theHLTCollectionHumanNames[0] == "hltL1sRelaxedSingleEgammaEt8"){
     triggerIndex = hltConfig.triggerIndex("HLT_L1SingleEG8");
   } else if (theHLTCollectionHumanNames[0] == "hltL1sRelaxedSingleEgammaEt5") {
     triggerIndex = hltConfig.triggerIndex("HLT_L1SingleEG5");
   } else if (theHLTCollectionHumanNames[0] == "hltL1sRelaxedDoubleEgammaEt5") {
     triggerIndex = hltConfig.triggerIndex("HLT_L1DoubleEG5");
   } else {
     triggerIndex = hltConfig.triggerIndex("");
     } */
 
   unsigned int triggerIndex;
   triggerIndex = hltConfig_.triggerIndex(triggerNameRecoMonPath);
 
   //triggerIndex must be less than the size of HLTR or you get a CMSException
   bool isFired = false;
   if (triggerIndex < HLTR->size()){
     isFired = HLTR->accept(triggerIndex);
   }
 
   // fill L1 and HLT info
   // get objects possed by each filter
   edm::Handle<trigger::TriggerEventWithRefs> triggerObj;
   event.getByToken(triggerObjT, triggerObj);
 
   if(!triggerObj.isValid()) {
     edm::LogWarning("EmDQMReco") << "RAW-type HLT results not found, skipping event";
     return;
   }
 
   //  Fill the bin labeled "Total"                          //
   //   This will be the number of events looked at.         //
   totalreco->Fill(numOfHLTCollectionLabels+0.5);
   totalmatchreco->Fill(numOfHLTCollectionLabels+.5);
 
   //  Fill the bin labeled "Total"                          //
   //   This will be the number of events looked at.         //
   //total->Fill(numOfHLTCollectionLabels+0.5);
   //totalmatch->Fill(numOfHLTCollectionLabels+0.5);
 
 
   //               Fill reconstruction info                      //
   // the recocut_ highest Et generator objects of the preselected type are our matches
 
   std::vector<reco::Particle> sortedReco;
   if (plotReco == true) {
     if (pdgGen == 11) {
       for(edm::View<reco::Candidate>::const_iterator recopart = recoObjects->begin(); recopart != recoObjects->end();recopart++){
         reco::Particle tmpcand(  recopart->charge(), recopart->p4(), recopart->vertex(),recopart->pdgId(),recopart->status() );
         sortedReco.push_back(tmpcand);
       }
     }
     else if (pdgGen == 22) {
       for(std::vector<reco::SuperCluster>::const_iterator recopart2 = recoObjectsEB->begin(); recopart2 != recoObjectsEB->end();recopart2++){
         float en = recopart2->energy();
         float er = sqrt(pow(recopart2->x(),2) + pow(recopart2->y(),2) + pow(recopart2->z(),2) );
         float px = recopart2->energy()*recopart2->x()/er;
         float py = recopart2->energy()*recopart2->y()/er;
         float pz = recopart2->energy()*recopart2->z()/er;
         reco::Candidate::LorentzVector thisLV(px,py,pz,en);
         reco::Particle tmpcand(  0, thisLV, math::XYZPoint(0.,0.,0.), 22, 1 );
         sortedReco.push_back(tmpcand);
       }
       for(std::vector<reco::SuperCluster>::const_iterator recopart2 = recoObjectsEE->begin(); recopart2 != recoObjectsEE->end();recopart2++){
         float en = recopart2->energy();
         float er = sqrt(pow(recopart2->x(),2) + pow(recopart2->y(),2) + pow(recopart2->z(),2) );
         float px = recopart2->energy()*recopart2->x()/er;
         float py = recopart2->energy()*recopart2->y()/er;
         float pz = recopart2->energy()*recopart2->z()/er;
         reco::Candidate::LorentzVector thisLV(px,py,pz,en);
         reco::Particle tmpcand(  0, thisLV, math::XYZPoint(0.,0.,0.), 22, 1 );
         sortedReco.push_back(tmpcand);
       }
     }
 
     std::sort(sortedReco.begin(),sortedReco.end(),pTComparator_ );
 
     // Now the collection of gen particles is sorted by pt.
     // So, remove all particles from the collection so that we
     // only have the top "1 thru recocut_" particles in it
 
     sortedReco.erase(sortedReco.begin()+recocut_,sortedReco.end());
 
     for (unsigned int i = 0 ; i < recocut_ ; i++ ) {
         //validity has been implicitily checked by the cut on recocut_ above
         histReco->fill(sortedReco[i].p4());
 
 //      etreco ->Fill( sortedReco[i].et()  );
 //      etareco->Fill( sortedReco[i].eta() );
 //      phiReco->Fill( sortedReco[i].phi() );
 
       if (isFired) {
         histRecoMonpath->fill(sortedReco[i].p4());
         plotMonpath = true;
       }
 
     } // END of loop over Reconstructed particles
 
     if (recocut_ >= reqNum) totalreco->Fill(numOfHLTCollectionLabels+1.5); // this isn't really needed anymore keep for backward comp.
     if (recocut_ >= reqNum) totalmatchreco->Fill(numOfHLTCollectionLabels+1.5); // this isn't really needed anymore keep for backward comp.
 
   }
 
 
 
 
   //            Loop over filter modules                    //
   for(unsigned int n=0; n < numOfHLTCollectionLabels ; n++) {
     // These numbers are from the Parameter Set, such as:
     //   theHLTOutputTypes = cms.uint32(100)
     switch(theHLTOutputTypes[n])
     {
       case trigger::TriggerL1NoIsoEG: // Non-isolated Level 1
         histoFillerL1NonIso->fillHistos(triggerObj,event,n, sortedReco, plotReco, plotMonpath);
     break;
       case trigger::TriggerL1IsoEG: // Isolated Level 1
         histoFillerL1Iso->fillHistos(triggerObj,event,n, sortedReco, plotReco, plotMonpath);
     break;
       case trigger::TriggerPhoton: // Photon
         histoFillerPho->fillHistos(triggerObj,event,n, sortedReco, plotReco, plotMonpath);
     break;
       case trigger::TriggerElectron: // Electron
         histoFillerEle->fillHistos(triggerObj,event,n, sortedReco, plotReco, plotMonpath);
     break;
       case trigger::TriggerCluster: // TriggerCluster
         histoFillerClu->fillHistos(triggerObj,event,n, sortedReco, plotReco, plotMonpath);
     break;
       default:
         throw(cms::Exception("Release Validation Error") << "HLT output type not implemented: theHLTOutputTypes[n]" );
     }
     } // END of loop over filter modules
 }

void EmDQMReco::beginJob ( )

void EmDQMReco::bookHistograms	(	DQMStore::IBooker &	iBooker,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 214 of file EmDQMReco.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), dirname_, etahistiso, etahistisomatchreco, ethistiso, ethistisomatchreco, histEtaIsoOfHltObjMatchToReco, histEtIsoOfHltObjMatchToReco, histHltObjMatchToReco, histMatchReco, histMatchRecoMonPath, histMonpath, histPhiIsoOfHltObjMatchToReco, histReco, histRecoMonpath, i, diffTwoXMLs::label, NULL, numOfHLTCollectionLabels, pdgGen, phiHistIso, phiHistIsoMatchReco, plotBins, plotBounds, plotEtaMax, plotiso, plotPhiMax, plotPtMax, plotPtMin, MonitorElement::setBinLabel(), DQMStore::IBooker::setCurrentFolder(), standardHist, AlCaHLTBitMon_QueryRunRegistry::string, theHLTCollectionHumanNames, theHLTCollectionLabels, totalmatchreco, totalreco, and useHumanReadableHistTitles.

 {
   //edm::Service<TFileService> fs;
   iBooker.setCurrentFolder(dirname_);
 
   //  Set up Histogram of Effiency vs Step.                 //
   //   theHLTCollectionLabels is a vector of InputTags      //
   //    from the configuration file.                        //
 
   std::string histName="total_eff";
   std::string histTitle = "total events passing";
   // This plot will have bins equal to 2+(number of
   //        HLTCollectionLabels in the config file)
   totalreco = iBooker.book1D(histName.c_str(),histTitle.c_str(),numOfHLTCollectionLabels+2,0,numOfHLTCollectionLabels+2);
   totalreco->setBinLabel(numOfHLTCollectionLabels+1,"Total");
   totalreco->setBinLabel(numOfHLTCollectionLabels+2,"Reco");
   for (unsigned int u=0; u<numOfHLTCollectionLabels; u++){totalreco->setBinLabel(u+1,theHLTCollectionLabels[u].label().c_str());}
 
   histName="total_eff_RECO_matched";
   histTitle="total events passing (Reco matched)";
   totalmatchreco = iBooker.book1D(histName.c_str(),histTitle.c_str(),numOfHLTCollectionLabels+2,0,numOfHLTCollectionLabels+2);
   totalmatchreco->setBinLabel(numOfHLTCollectionLabels+1,"Total");
   totalmatchreco->setBinLabel(numOfHLTCollectionLabels+2,"Reco");
   for (unsigned int u=0; u<numOfHLTCollectionLabels; u++){totalmatchreco->setBinLabel(u+1,theHLTCollectionLabels[u].label().c_str());}
 
   // MonitorElement* tmphisto;
   MonitorElement* tmpiso;
 
   // Set up generator-level histograms                      //
   std::string pdgIdString;
   switch(pdgGen) {
   case 11:
     pdgIdString="Electron";break;
   case 22:
     pdgIdString="Photon";break;
   default:
     pdgIdString="Particle";
   }
 
   //--------------------
 
   // reco
   // (note that reset(..) must be used to set the value of the scoped_ptr...)
   histReco.reset(
       new FourVectorMonitorElements(this, iBooker,
           "reco_%s",             // pattern for histogram name
           "%s of " + pdgIdString + "s"
       ));
 
   //--------------------
 
   // monpath
   histRecoMonpath.reset(
        new FourVectorMonitorElements(this, iBooker,
            "reco_%s_monpath",   // pattern for histogram name
            "%s of " + pdgIdString + "s monpath"
        )
   );
 
   //--------------------
 
   // TODO: WHAT ARE THESE HISTOGRAMS FOR ? THEY SEEM NEVER REFERENCED ANYWHERE IN THIS FILE...
   // final X monpath
   histMonpath.reset(
        new FourVectorMonitorElements(this, iBooker,
            "final_%s_monpath",   // pattern for histogram name
            "Final %s Monpath"
        )
   );
 
   //--------------------
 
   //  Set up histograms of HLT objects                      //
 
   // Determine what strings to use for histogram titles
   std::vector<std::string> HltHistTitle;
   if ( theHLTCollectionHumanNames.size() == numOfHLTCollectionLabels && useHumanReadableHistTitles ) {
     HltHistTitle = theHLTCollectionHumanNames;
   } else {
     for (unsigned int i =0; i < numOfHLTCollectionLabels; i++) {
       HltHistTitle.push_back(theHLTCollectionLabels[i].label());
     }
   }
 
   for(unsigned int i = 0; i< numOfHLTCollectionLabels ; i++){
     //--------------------
     // distributions of HLT objects passing filter i
     //--------------------
 
 //    // Et
 //    histName = theHLTCollectionLabels[i].label()+"et_all";
 //    histTitle = HltHistTitle[i]+" Et (ALL)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax);
 //    ethist.push_back(tmphisto);
 //
 //    // Eta
 //    histName = theHLTCollectionLabels[i].label()+"eta_all";
 //    histTitle = HltHistTitle[i]+" #eta (ALL)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax);
 //    etahist.push_back(tmphisto);
 //
 //    // phi
 //    histName = theHLTCollectionLabels[i].label()+"phi_all";
 //    histTitle = HltHistTitle[i]+" #phi (ALL)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax);
 //    phiHist.push_back(tmphisto);
 
     standardHist.push_back(new FourVectorMonitorElements(this, iBooker,
                              theHLTCollectionLabels[i].label()+"%s_all", // histogram name
                              HltHistTitle[i]+" %s (ALL)"                 // histogram title
                              ));
 
     //--------------------
     // distributions of reco object matching HLT object passing filter i
     //--------------------
 
     // Et
 //    histName = theHLTCollectionLabels[i].label()+"et_RECO_matched";
 //    histTitle = HltHistTitle[i]+" Et (RECO matched)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax);
 //    ethistmatchreco.push_back(tmphisto);
 
 //    // Eta
 //    histName = theHLTCollectionLabels[i].label()+"eta_RECO_matched";
 //    histTitle = HltHistTitle[i]+" #eta (RECO matched)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax);
 //    etahistmatchreco.push_back(tmphisto);
 //
 //    // phi
 //    histName = theHLTCollectionLabels[i].label()+"phi_RECO_matched";
 //    histTitle = HltHistTitle[i]+" #phi (RECO matched)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax);
 //    phiHistMatchReco.push_back(tmphisto);
     histMatchReco.push_back(new FourVectorMonitorElements(this, iBooker,
         theHLTCollectionLabels[i].label()+"%s_RECO_matched", // histogram name
         HltHistTitle[i]+" %s (RECO matched)"                 // histogram title
         ));
 
     //--------------------
     // distributions of reco object matching HLT object passing filter i
     //--------------------
 
 //    // Et
 //    histName = theHLTCollectionLabels[i].label()+"et_RECO_matched_monpath";
 //    histTitle = HltHistTitle[i]+" Et (RECO matched, monpath)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax);
 //    ethistmatchrecomonpath.push_back(tmphisto);
 //
 //    // Eta
 //    histName = theHLTCollectionLabels[i].label()+"eta_RECO_matched_monpath";
 //    histTitle = HltHistTitle[i]+" #eta (RECO matched, monpath)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax);
 //    etahistmatchrecomonpath.push_back(tmphisto);
 //
 //    // phi
 //    histName = theHLTCollectionLabels[i].label()+"phi_RECO_matched_monpath";
 //    histTitle = HltHistTitle[i]+" #phi (RECO matched, monpath)";
 //    tmphisto =  iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax);
 //    phiHistMatchRecoMonPath.push_back(tmphisto);
 
     histMatchRecoMonPath.push_back(new FourVectorMonitorElements(this, iBooker,
         theHLTCollectionLabels[i].label()+"%s_RECO_matched_monpath", // histogram name
         HltHistTitle[i]+" %s (RECO matched, monpath)"                // histogram title
         ));
     //--------------------
     // distributions of HLT object that is closest delta-R match to sorted reco particle(s)
     //--------------------
 
     // Et
 //    histName  = theHLTCollectionLabels[i].label()+"et_reco";
 //    histTitle = HltHistTitle[i]+" Et (reco)";
 //    tmphisto  = iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax);
 //    histEtOfHltObjMatchToReco.push_back(tmphisto);
 //
 //    // eta
 //    histName  = theHLTCollectionLabels[i].label()+"eta_reco";
 //    histTitle = HltHistTitle[i]+" eta (reco)";
 //    tmphisto  = iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax);
 //    histEtaOfHltObjMatchToReco.push_back(tmphisto);
 //
 //    // phi
 //    histName  = theHLTCollectionLabels[i].label()+"phi_reco";
 //    histTitle = HltHistTitle[i]+" phi (reco)";
 //    tmphisto  = iBooker.book1D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax);
 //    histPhiOfHltObjMatchToReco.push_back(tmphisto);
 
     histHltObjMatchToReco.push_back(new FourVectorMonitorElements(this, iBooker,
         theHLTCollectionLabels[i].label()+"%s_reco",   // histogram name
         HltHistTitle[i]+" %s (reco)"                  // histogram title
         ));
 
     //--------------------
 
     if (!plotiso[i]) {
       tmpiso = NULL;
       etahistiso.push_back(tmpiso);
       ethistiso.push_back(tmpiso);
       phiHistIso.push_back(tmpiso);
 
       etahistisomatchreco.push_back(tmpiso);
       ethistisomatchreco.push_back(tmpiso);
       phiHistIsoMatchReco.push_back(tmpiso);
 
       histEtaIsoOfHltObjMatchToReco.push_back(tmpiso);
       histEtIsoOfHltObjMatchToReco.push_back(tmpiso);
       histPhiIsoOfHltObjMatchToReco.push_back(tmpiso);
 
     } else {
 
       //--------------------
       // 2D plot: Isolation values vs X for all objects
       //--------------------
 
       // X = eta
       histName  = theHLTCollectionLabels[i].label()+"eta_isolation_all";
       histTitle = HltHistTitle[i]+" isolation vs #eta (all)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       etahistiso.push_back(tmpiso);
 
       // X = et
       histName  = theHLTCollectionLabels[i].label()+"et_isolation_all";
       histTitle = HltHistTitle[i]+" isolation vs Et (all)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       ethistiso.push_back(tmpiso);
 
       // X = phi
       histName  = theHLTCollectionLabels[i].label()+"phi_isolation_all";
       histTitle = HltHistTitle[i]+" isolation vs #phi (all)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       phiHistIso.push_back(tmpiso);
 
       //--------------------
       // 2D plot: Isolation values vs X for reco matched objects
       //--------------------
 
       // X = eta
       histName  = theHLTCollectionLabels[i].label()+"eta_isolation_RECO_matched";
       histTitle = HltHistTitle[i]+" isolation vs #eta (reco matched)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       etahistisomatchreco.push_back(tmpiso);
 
       // X = et
       histName  = theHLTCollectionLabels[i].label()+"et_isolation_RECO_matched";
       histTitle = HltHistTitle[i]+" isolation vs Et (reco matched)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       ethistisomatchreco.push_back(tmpiso);
 
       // X = eta
       histName  = theHLTCollectionLabels[i].label()+"phi_isolation_RECO_matched";
       histTitle = HltHistTitle[i]+" isolation vs #phi (reco matched)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       phiHistIsoMatchReco.push_back(tmpiso);
 
       //--------------------
       // 2D plot: Isolation values vs X for HLT object that
       // is closest delta-R match to sorted reco particle(s)
       //--------------------
 
       // X = eta
       histName  = theHLTCollectionLabels[i].label()+"eta_isolation_reco";
       histTitle = HltHistTitle[i]+" isolation vs #eta (reco)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,-plotEtaMax,plotEtaMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       histEtaIsoOfHltObjMatchToReco.push_back(tmpiso);
 
       // X = et
       histName  = theHLTCollectionLabels[i].label()+"et_isolation_reco";
       histTitle = HltHistTitle[i]+" isolation vs Et (reco)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,plotPtMin,plotPtMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       histEtIsoOfHltObjMatchToReco.push_back(tmpiso);
 
       // X = phi
       histName  = theHLTCollectionLabels[i].label()+"phi_isolation_reco";
       histTitle = HltHistTitle[i]+" isolation vs #phi (reco)";
       tmpiso    = iBooker.book2D(histName.c_str(),histTitle.c_str(),plotBins,-plotPhiMax,plotPhiMax,plotBins,plotBounds[i].first,plotBounds[i].second);
       histPhiIsoOfHltObjMatchToReco.push_back(tmpiso);
       //--------------------
 
     } // END of HLT histograms
   }
 }

void EmDQMReco::dqmBeginRun	(	const edm::Run &	iRun,
		const edm::EventSetup &	iSetup
	)

virtual

Reimplemented from DQMEDAnalyzer.

Definition at line 203 of file EmDQMReco.cc.

References hltConfig_, HLTConfigProvider::init(), and isHltConfigInitialized_.

                                                                             {
 
   bool isHltConfigChanged = false; // change of cfg at run boundaries?
   isHltConfigInitialized_ = hltConfig_.init( iRun, iSetup, "HLT", isHltConfigChanged );
 
 }