#include <CaloTowersValidation.h>

Inheritance diagram for CaloTowersValidation:

Public Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &c) override

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

	CaloTowersValidation (edm::ParameterSet const &conf)

	~CaloTowersValidation () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual void	dqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

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

	DQMEDAnalyzer ()

virtual void	dqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	dqmEndRun (edm::Run const &, edm::EventSetup const &)

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &, edm::EventSetup const &) final

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
typedef math::RhoEtaPhiVector	Vector

Private Member Functions
double	dR (double eta1, double phi1, double eta2, double phi2)

Private Attributes
MonitorElement *	emean_vs_ieta_E

MonitorElement *	emean_vs_ieta_E1

MonitorElement *	emean_vs_ieta_EH

MonitorElement *	emean_vs_ieta_EH1

MonitorElement *	emean_vs_ieta_H

MonitorElement *	emean_vs_ieta_H1

MonitorElement *	emEnergyTiming_HB

MonitorElement *	emEnergyTiming_HE

MonitorElement *	emEnergyTiming_HF

MonitorElement *	emEnergyTiming_High_HB

MonitorElement *	emEnergyTiming_Low_HB

MonitorElement *	emEnergyTiming_Low_HE

MonitorElement *	emEnergyTiming_profile_HB

MonitorElement *	emEnergyTiming_profile_HE

MonitorElement *	emEnergyTiming_profile_HF

MonitorElement *	emEnergyTiming_profile_High_HB

MonitorElement *	emEnergyTiming_profile_Low_HB

MonitorElement *	emEnergyTiming_profile_Low_HE

MonitorElement *	emTiming_HB

MonitorElement *	emTiming_HE

MonitorElement *	emTiming_HF

double	etaMax [3]

double	etaMin [3]

MonitorElement *	hadEnergyTiming_HB

MonitorElement *	hadEnergyTiming_HE

MonitorElement *	hadEnergyTiming_HF

MonitorElement *	hadEnergyTiming_High_HB

MonitorElement *	hadEnergyTiming_Low_HB

MonitorElement *	hadEnergyTiming_Low_HE

MonitorElement *	hadEnergyTiming_Low_HF

MonitorElement *	hadEnergyTiming_profile_HB

MonitorElement *	hadEnergyTiming_profile_HE

MonitorElement *	hadEnergyTiming_profile_HF

MonitorElement *	hadEnergyTiming_profile_High_HB

MonitorElement *	hadEnergyTiming_profile_Low_HB

MonitorElement *	hadEnergyTiming_profile_Low_HE

MonitorElement *	hadEnergyTiming_profile_Low_HF

MonitorElement *	hadTiming_HB

MonitorElement *	hadTiming_HE

MonitorElement *	hadTiming_HF

std::string	hcalselector_

int	imc

int	isub

MonitorElement *	mapEnergy_E

MonitorElement *	mapEnergy_EH

MonitorElement *	mapEnergy_H

MonitorElement *	mapEnergy_HB

MonitorElement *	mapEnergy_HE

MonitorElement *	mapEnergy_HF

MonitorElement *	mapEnergy_N

MonitorElement *	mapEnergyEcal_HB

MonitorElement *	mapEnergyEcal_HE

MonitorElement *	mapEnergyEcal_HF

MonitorElement *	mapEnergyHcal_HB

MonitorElement *	mapEnergyHcal_HE

MonitorElement *	mapEnergyHcal_HF

bool	mc_

MonitorElement *	meEnergyEcal_HB

MonitorElement *	meEnergyEcal_HE

MonitorElement *	meEnergyEcal_HF

MonitorElement *	meEnergyEcalTower_HB

MonitorElement *	meEnergyEcalTower_HE

MonitorElement *	meEnergyEcalTower_HF

MonitorElement *	meEnergyHcal_HB

MonitorElement *	meEnergyHcal_HE

MonitorElement *	meEnergyHcal_HF

MonitorElement *	meEnergyHcalTower_HB

MonitorElement *	meEnergyHcalTower_HE

MonitorElement *	meEnergyHcalTower_HF

MonitorElement *	meEnergyHcalvsEcal_HB

MonitorElement *	meEnergyHcalvsEcal_HE

MonitorElement *	meEnergyHcalvsEcal_HF

MonitorElement *	meEnergyHO_HB

MonitorElement *	meEnergyHO_HE

MonitorElement *	meEnergyHO_HF

MonitorElement *	meNumFiredTowers_HB

MonitorElement *	meNumFiredTowers_HE

MonitorElement *	meNumFiredTowers_HF

MonitorElement *	MET_HB

MonitorElement *	MET_HE

MonitorElement *	MET_HF

MonitorElement *	meTotEnergy_HB

MonitorElement *	meTotEnergy_HE

MonitorElement *	meTotEnergy_HF

int	nevent

MonitorElement *	Ntowers_vs_ieta

MonitorElement *	numBadCellsEcal_EB

MonitorElement *	numBadCellsEcal_EE

MonitorElement *	numBadCellsHcal_HB

MonitorElement *	numBadCellsHcal_HE

MonitorElement *	numBadCellsHcal_HF

MonitorElement *	numPrbCellsEcal_EB

MonitorElement *	numPrbCellsEcal_EE

MonitorElement *	numPrbCellsHcal_HB

MonitorElement *	numPrbCellsHcal_HE

MonitorElement *	numPrbCellsHcal_HF

MonitorElement *	numRcvCellsEcal_EB

MonitorElement *	numRcvCellsEcal_EE

MonitorElement *	numRcvCellsHcal_HB

MonitorElement *	numRcvCellsHcal_HE

MonitorElement *	numRcvCellsHcal_HF

MonitorElement *	occupancy_map

MonitorElement *	occupancy_vs_ieta

std::string	outputFile_

MonitorElement *	phiMET_HB

MonitorElement *	phiMET_HE

MonitorElement *	phiMET_HF

MonitorElement *	SET_HB

MonitorElement *	SET_HE

MonitorElement *	SET_HF

edm::EDGetTokenT< CaloTowerCollection >	tok_calo_

edm::EDGetTokenT< edm::HepMCProduct >	tok_evt_

bool	useAllHistos_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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)

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 31 of file CaloTowersValidation.h.

Member Typedef Documentation

typedef math::RhoEtaPhiVector CaloTowersValidation::Vector

private

Definition at line 46 of file CaloTowersValidation.h.

Constructor & Destructor Documentation

CaloTowersValidation::CaloTowersValidation ( edm::ParameterSet const & conf )

Definition at line 6 of file CaloTowersValidation.cc.

References etaMax, etaMin, edm::ParameterSet::getUntrackedParameter(), hcalselector_, imc, HLT_2018_cff::InputTag, isub, mc_, nevent, outputFile_, AlCaHLTBitMon_QueryRunRegistry::string, tok_calo_, tok_evt_, and useAllHistos_.

                                                                       {
   tok_calo_ = consumes<CaloTowerCollection>(conf.getUntrackedParameter<edm::InputTag>("CaloTowerCollectionLabel"));
   tok_evt_ = consumes<edm::HepMCProduct>(edm::InputTag("generatorSmeared"));
 
   // DQM ROOT output
   outputFile_ = conf.getUntrackedParameter<std::string>("outputFile", "myfile.root");
 
   hcalselector_ = conf.getUntrackedParameter<std::string>("hcalselector", "all");
 
   mc_ = conf.getUntrackedParameter<bool>("mc", true);
   useAllHistos_ = conf.getUntrackedParameter<bool>("useAllHistos", false);
 
   etaMin[0] = 0.;
   etaMax[0] = 1.4;
   etaMin[1] = 1.4;
   etaMax[1] = 2.9;
   etaMin[2] = 2.9;
   etaMax[2] = 5.2;
 
   isub = 0;
   if (hcalselector_ == "HB")
     isub = 1;
   if (hcalselector_ == "HE")
     isub = 2;
   if (hcalselector_ == "HF")
     isub = 3;
 
   imc = 1;
   if (!mc_)
     imc = 0;
 
   if (!outputFile_.empty()) {
     edm::LogInfo("OutputInfo") << " Hcal RecHit Task histograms will be saved to '" << outputFile_.c_str() << "'";
   } else {
     edm::LogInfo("OutputInfo") << " Hcal RecHit Task histograms will NOT be saved";
   }
 
   nevent = 0;
   // const char * sub = hcalselector_.c_str();
 }

CaloTowersValidation::~CaloTowersValidation ( )

override

Definition at line 47 of file CaloTowersValidation.cc.

47 {}

Member Function Documentation

void CaloTowersValidation::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 397 of file CaloTowersValidation.cc.

                                                                                 {
   nevent++;
 
   // bool     MC = false; // UNUSED
   double phi_MC = 9999.;
   double eta_MC = 9999.;
 
   if (imc != 0) {
     edm::Handle<edm::HepMCProduct> evtMC;
     event.getByToken(tok_evt_, evtMC);  // generator in late 310_preX
     if (!evtMC.isValid()) {
       std::cout << "no HepMCProduct found" << std::endl;
     } else {
       // MC=true; // UNUSED
       //    std::cout << "*** source HepMCProduct found"<< std::endl;
     }
 
     // MC particle with highest pt is taken as a direction reference
     double maxPt = -99999.;
     int npart = 0;
     const HepMC::GenEvent* myGenEvent = evtMC->GetEvent();
     for (HepMC::GenEvent::particle_const_iterator p = myGenEvent->particles_begin(); p != myGenEvent->particles_end();
          ++p) {
       double phip = (*p)->momentum().phi();
       double etap = (*p)->momentum().eta();
       //    phi_MC = phip;
       //    eta_MC = etap;
       double pt = (*p)->momentum().perp();
       if (pt > maxPt) {
         npart++;
         maxPt = pt;
         phi_MC = phip;
         eta_MC = etap;
       }
     }
     //  std::cout << "*** Max pT = " << maxPt <<  std::endl;
   }
 
   edm::Handle<CaloTowerCollection> towers;
   event.getByToken(tok_calo_, towers);
   CaloTowerCollection::const_iterator cal;
 
   double met;
   double phimet;
 
   // ieta scan
   double partR = 0.3;
   double Rmin = 9999.;
   double Econe = 0.;
   double Hcone = 0.;
   double Ee1 = 0.;
   double Eh1 = 0.;
   double ieta_MC = 9999;
   double iphi_MC = 9999;
   //  double  etaM   = 9999.;
 
   // HB
   double sumEnergyHcal_HB = 0.;
   double sumEnergyEcal_HB = 0.;
   double sumEnergyHO_HB = 0.;
   Int_t numFiredTowers_HB = 0;
   double metx_HB = 0.;
   double mety_HB = 0.;
   double metz_HB = 0.;
   double sEt_HB = 0.;
   // HE
   double sumEnergyHcal_HE = 0.;
   double sumEnergyEcal_HE = 0.;
   double sumEnergyHO_HE = 0.;
   Int_t numFiredTowers_HE = 0;
   double metx_HE = 0.;
   double mety_HE = 0.;
   double metz_HE = 0.;
   double sEt_HE = 0.;
   // HF
   double sumEnergyHcal_HF = 0.;
   double sumEnergyEcal_HF = 0.;
   double sumEnergyHO_HF = 0.;
   Int_t numFiredTowers_HF = 0;
   double metx_HF = 0.;
   double mety_HF = 0.;
   double metz_HF = 0.;
   double sEt_HF = 0.;
 
   for (cal = towers->begin(); cal != towers->end(); ++cal) {
     double eE = cal->emEnergy();
     double eH = cal->hadEnergy();
     double eHO = cal->outerEnergy();
     double etaT = cal->eta();
     double phiT = cal->phi();
     double en = cal->energy();
     double etT = cal->et();
     double had_tm = cal->hcalTime();
     double em_tm = cal->ecalTime();
 
     int numBadEcalCells = cal->numBadEcalCells();
     int numRcvEcalCells = cal->numRecoveredEcalCells();
     int numPrbEcalCells = cal->numProblematicEcalCells();
 
     int numBadHcalCells = cal->numBadHcalCells();
     int numRcvHcalCells = cal->numRecoveredHcalCells();
     int numPrbHcalCells = cal->numProblematicHcalCells();
 
     math::RhoEtaPhiVector mom(cal->et(), cal->eta(), cal->phi());
     //  Vector mom  = cal->momentum();
 
     // cell properties
     CaloTowerDetId idT = cal->id();
     int ieta = idT.ieta();
     int iphi = idT.iphi();
 
     // ecal:  0 EcalBarrel  1 EcalEndcap
     // hcal:  0 hcalBarrel  1 HcalEndcap  2 HcalForward
     std::vector<int> inEcals(2), inHcals(3);
     unsigned int constitSize = cal->constituentsSize();
     for (unsigned int ic = 0; ic < constitSize; ic++) {
       DetId detId = cal->constituent(ic);
       if (detId.det() == DetId::Ecal) {
         if (detId.subdetId() == EcalBarrel)
           inEcals[0] = 1;
         else if (detId.subdetId() == EcalEndcap)
           inEcals[1] = 1;
       }
       if (detId.det() == DetId::Hcal) {
         if (HcalDetId(detId).subdet() == HcalBarrel)
           inHcals[0] = 1;
         else if (HcalDetId(detId).subdet() == HcalEndcap)
           inHcals[1] = 1;
         else if (HcalDetId(detId).subdet() == HcalForward)
           inHcals[2] = 1;
       }
     }
     //All cell histos are used
     if (inEcals[0]) {
       numBadCellsEcal_EB->Fill(numBadEcalCells);
       numRcvCellsEcal_EB->Fill(numRcvEcalCells);
       numPrbCellsEcal_EB->Fill(numPrbEcalCells);
     }
     if (inEcals[1]) {
       numBadCellsEcal_EE->Fill(numBadEcalCells);
       numRcvCellsEcal_EE->Fill(numRcvEcalCells);
       numPrbCellsEcal_EE->Fill(numPrbEcalCells);
     }
 
     if (imc != 0) {
       double r = dR(eta_MC, phi_MC, etaT, phiT);
 
       if (r < partR) {
         Econe += eE;
         Hcone += eH;
 
         // closest to MC
         if (r < Rmin) {
           if (fabs(eta_MC) < 3.0 && (ieta > 29 || ieta < -29)) {
             ;
           } else {
             Rmin = r;
             ieta_MC = ieta;
             iphi_MC = iphi;
             Ee1 = eE;
             Eh1 = eH;
           }
         }
       }
     }
 
     //Ntowers is used in EndJob, occupancy_map is used for occupancy vs ieta
     Ntowers_vs_ieta->Fill(double(ieta), 1.);
     occupancy_map->Fill(double(ieta), double(iphi));
 
     if ((isub == 0 || isub == 1) && (fabs(etaT) < etaMax[0] && fabs(etaT) >= etaMin[0])) {
       //All cell histos are used
       numBadCellsHcal_HB->Fill(numBadHcalCells);
       numRcvCellsHcal_HB->Fill(numRcvHcalCells);
       numPrbCellsHcal_HB->Fill(numPrbHcalCells);
 
       //Map energy histos are not used
       if (useAllHistos_) {
         mapEnergy_HB->Fill(double(ieta), double(iphi), en);
         mapEnergyHcal_HB->Fill(double(ieta), double(iphi), eH);
         mapEnergyEcal_HB->Fill(double(ieta), double(iphi), eE);
       }
       //      std::cout << " e_ecal = " << eE << std::endl;
 
       //  simple sums
       sumEnergyHcal_HB += eH;
       sumEnergyEcal_HB += eE;
       sumEnergyHO_HB += eHO;
 
       numFiredTowers_HB++;
 
       //Not used
       if (useAllHistos_) {
         meEnergyEcalTower_HB->Fill(eE);
         meEnergyHcalTower_HB->Fill(eH);
       }
 
       // MET, SET & phimet
       //  double  etT = cal->et();
       metx_HB += mom.x();
       mety_HB += mom.y();  //etT * sin(phiT);
       sEt_HB += etT;
 
       //Timing (all histos are used)
       emTiming_HB->Fill(em_tm);
       hadTiming_HB->Fill(had_tm);
 
       emEnergyTiming_Low_HB->Fill(eE, em_tm);
       emEnergyTiming_HB->Fill(eE, em_tm);
       emEnergyTiming_High_HB->Fill(eE, em_tm);
       emEnergyTiming_profile_Low_HB->Fill(eE, em_tm);
       emEnergyTiming_profile_HB->Fill(eE, em_tm);
       emEnergyTiming_profile_High_HB->Fill(eE, em_tm);
 
       hadEnergyTiming_Low_HB->Fill(eH, had_tm);
       hadEnergyTiming_HB->Fill(eH, had_tm);
       hadEnergyTiming_High_HB->Fill(eH, had_tm);
       hadEnergyTiming_profile_Low_HB->Fill(eH, had_tm);
       hadEnergyTiming_profile_HB->Fill(eH, had_tm);
       hadEnergyTiming_profile_High_HB->Fill(eH, had_tm);
     }
 
     if ((isub == 0 || isub == 2) && (fabs(etaT) < etaMax[1] && fabs(etaT) >= etaMin[1])) {
       //All cell histos are used
       numBadCellsHcal_HE->Fill(numBadHcalCells);
       numRcvCellsHcal_HE->Fill(numRcvHcalCells);
       numPrbCellsHcal_HE->Fill(numPrbHcalCells);
 
       //Map energy histos are not used
       if (useAllHistos_) {
         mapEnergy_HE->Fill(double(ieta), double(iphi), en);
         mapEnergyHcal_HE->Fill(double(ieta), double(iphi), eH);
         mapEnergyEcal_HE->Fill(double(ieta), double(iphi), eE);
       }
       //      std::cout << " e_ecal = " << eE << std::endl;
 
       //  simple sums
       sumEnergyHcal_HE += eH;
       sumEnergyEcal_HE += eE;
       sumEnergyHO_HE += eHO;
 
       numFiredTowers_HE++;
 
       //Not used
       if (useAllHistos_) {
         meEnergyEcalTower_HE->Fill(eE);
         meEnergyHcalTower_HE->Fill(eH);
       }
       // MET, SET & phimet
       //  double  etT = cal->et();
       metx_HE += mom.x();
       mety_HE += mom.y();  //etT * sin(phiT);
       sEt_HE += etT;
 
       //Timing (all histos are used)
       emTiming_HE->Fill(em_tm);
       hadTiming_HE->Fill(had_tm);
 
       emEnergyTiming_Low_HE->Fill(eE, em_tm);
       emEnergyTiming_HE->Fill(eE, em_tm);
       emEnergyTiming_profile_Low_HE->Fill(eE, em_tm);
       emEnergyTiming_profile_HE->Fill(eE, em_tm);
 
       hadEnergyTiming_Low_HE->Fill(eH, had_tm);
       hadEnergyTiming_HE->Fill(eH, had_tm);
       hadEnergyTiming_profile_Low_HE->Fill(eH, had_tm);
       hadEnergyTiming_profile_HE->Fill(eH, had_tm);
     }
 
     if ((isub == 0 || isub == 3) && (fabs(etaT) < etaMax[2] && fabs(etaT) >= etaMin[2])) {
       //All cell histos are used
       numBadCellsHcal_HF->Fill(numBadHcalCells);
       numRcvCellsHcal_HF->Fill(numRcvHcalCells);
       numPrbCellsHcal_HF->Fill(numPrbHcalCells);
 
       //Map energy histos are not used
       if (useAllHistos_) {
         mapEnergy_HF->Fill(double(ieta), double(iphi), en);
         mapEnergyHcal_HF->Fill(double(ieta), double(iphi), eH);
         mapEnergyEcal_HF->Fill(double(ieta), double(iphi), eE);
       }
       //      std::cout << " e_ecal = " << eE << std::endl;
 
       //  simple sums
       sumEnergyHcal_HF += eH;
       sumEnergyEcal_HF += eE;
       sumEnergyHO_HF += eHO;
 
       numFiredTowers_HF++;
 
       //Not used
       if (useAllHistos_) {
         meEnergyEcalTower_HF->Fill(eE);
         meEnergyHcalTower_HF->Fill(eH);
       }
       // MET, SET & phimet
       //  double  etT = cal->et();
       metx_HF += mom.x();
       mety_HF += mom.y();  //etT * sin(phiT);
       sEt_HF += etT;
 
       //Timing (all histos are used)
       emTiming_HF->Fill(em_tm);
       hadTiming_HF->Fill(had_tm);
       emEnergyTiming_HF->Fill(eE, em_tm);
       emEnergyTiming_profile_HF->Fill(eE, em_tm);
 
       hadEnergyTiming_Low_HF->Fill(eH, had_tm);
       hadEnergyTiming_HF->Fill(eH, had_tm);
       hadEnergyTiming_profile_Low_HF->Fill(eH, had_tm);
       hadEnergyTiming_profile_HF->Fill(eH, had_tm);
     }
 
   }  // end of Towers cycle
 
   //These are the six single pion histos
   emean_vs_ieta_E->Fill(double(ieta_MC), Econe);
   emean_vs_ieta_H->Fill(double(ieta_MC), Hcone);
   emean_vs_ieta_EH->Fill(double(ieta_MC), Econe + Hcone);
   emean_vs_ieta_E1->Fill(double(ieta_MC), Ee1);
   emean_vs_ieta_H1->Fill(double(ieta_MC), Eh1);
   emean_vs_ieta_EH1->Fill(double(ieta_MC), Ee1 + Eh1);
 
   //Map histos are not used except the last one in EndJob
   if (useAllHistos_) {
     mapEnergy_E->Fill(double(ieta_MC), double(iphi_MC), Ee1);
     mapEnergy_H->Fill(double(ieta_MC), double(iphi_MC), Eh1);
     mapEnergy_EH->Fill(double(ieta_MC), double(iphi_MC), Ee1 + Eh1);
   }
   mapEnergy_N->Fill(double(ieta_MC), double(iphi_MC), 1.);
 
   if (isub == 0 || isub == 1) {
     met = sqrt(metx_HB * metx_HB + mety_HB * mety_HB);
     Vector metv(metx_HB, mety_HB, metz_HB);
     phimet = metv.phi();
 
     //Five oldest drawn histos first; the rest are not used
     meEnergyHcal_HB->Fill(sumEnergyHcal_HB);
     meEnergyEcal_HB->Fill(sumEnergyEcal_HB);
     meNumFiredTowers_HB->Fill(numFiredTowers_HB);
     MET_HB->Fill(met);
     SET_HB->Fill(sEt_HB);
 
     if (useAllHistos_) {
       meEnergyHcalvsEcal_HB->Fill(sumEnergyEcal_HB, sumEnergyHcal_HB);
       meEnergyHO_HB->Fill(sumEnergyHO_HB);
       meTotEnergy_HB->Fill(sumEnergyHcal_HB + sumEnergyEcal_HB + sumEnergyHO_HB);
       phiMET_HB->Fill(phimet);
     }
   }
 
   if (isub == 0 || isub == 2) {
     met = sqrt(metx_HE * metx_HE + mety_HE * mety_HE);
     Vector metv(metx_HE, mety_HE, metz_HE);
     phimet = metv.phi();
 
     //Five oldest drawn histos first; the rest are not used
     meEnergyHcal_HE->Fill(sumEnergyHcal_HE);
     meEnergyEcal_HE->Fill(sumEnergyEcal_HE);
     meNumFiredTowers_HE->Fill(numFiredTowers_HE);
     MET_HE->Fill(met);
     SET_HE->Fill(sEt_HE);
 
     if (useAllHistos_) {
       meEnergyHcalvsEcal_HE->Fill(sumEnergyEcal_HE, sumEnergyHcal_HE);
       meEnergyHO_HE->Fill(sumEnergyHO_HE);
       meTotEnergy_HE->Fill(sumEnergyHcal_HE + sumEnergyEcal_HE + sumEnergyHO_HE);
       phiMET_HE->Fill(phimet);
     }
   }
 
   if (isub == 0 || isub == 3) {
     met = sqrt(metx_HF * metx_HF + mety_HF * mety_HF);
     Vector metv(metx_HF, mety_HF, metz_HF);
     phimet = metv.phi();
 
     //Five oldest drawn histos first; the rest are not used
     meEnergyHcal_HF->Fill(sumEnergyHcal_HF);
     meEnergyEcal_HF->Fill(sumEnergyEcal_HF);
     meNumFiredTowers_HF->Fill(numFiredTowers_HF);
     MET_HF->Fill(met);
     SET_HF->Fill(sEt_HF);
 
     if (useAllHistos_) {
       meEnergyHcalvsEcal_HF->Fill(sumEnergyEcal_HF, sumEnergyHcal_HF);
       meEnergyHO_HF->Fill(sumEnergyHO_HF);
       meTotEnergy_HF->Fill(sumEnergyHcal_HF + sumEnergyEcal_HF + sumEnergyHO_HF);
       phiMET_HF->Fill(phimet);
     }
   }
 }

void CaloTowersValidation::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	irun,
		edm::EventSetup const &	isetup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 49 of file CaloTowersValidation.cc.

                                                                        {
   Char_t histo[100];
 
   ibooker.setCurrentFolder("CaloTowersV/CaloTowersTask");
 
   //These two histos are not drawn by our macros, but they are used
   //in the EndJob for norms and such so I am leaving them alone for now
   //-------------------------------------------------------------------------------------------
   sprintf(histo, "Ntowers_per_event_vs_ieta");
   Ntowers_vs_ieta = ibooker.book1D(histo, histo, 83, -41.5, 41.5);
 
   sprintf(histo, "CaloTowersTask_map_Nentries");
   mapEnergy_N = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
   //-------------------------------------------------------------------------------------------
 
   //These the single pion scan histos
   //-------------------------------------------------------------------------------------------
   sprintf(histo, "emean_vs_ieta_E");
   emean_vs_ieta_E = ibooker.bookProfile(histo, histo, 83, -41.5, 41.5, -100., 2000., " ");
   sprintf(histo, "emean_vs_ieta_H");
   emean_vs_ieta_H = ibooker.bookProfile(histo, histo, 83, -41.5, 41.5, -100., 2000., " ");
   sprintf(histo, "emean_vs_ieta_EH");
   emean_vs_ieta_EH = ibooker.bookProfile(histo, histo, 83, -41.5, 41.5, -100., 2000., " ");
   //These are drawn
   sprintf(histo, "emean_vs_ieta_E1");
   emean_vs_ieta_E1 = ibooker.bookProfile(histo, histo, 83, -41.5, 41.5, -100., 2000., " ");
   sprintf(histo, "emean_vs_ieta_H1");
   emean_vs_ieta_H1 = ibooker.bookProfile(histo, histo, 83, -41.5, 41.5, -100., 2000., " ");
   sprintf(histo, "emean_vs_ieta_EH1");
   emean_vs_ieta_EH1 = ibooker.bookProfile(histo, histo, 83, -41.5, 41.5, -100., 2000., " ");
   //-------------------------------------------------------------------------------------------
 
   //Map energy histos are not drawn
   if (useAllHistos_) {
     sprintf(histo, "CaloTowersTask_map_energy_E");
     mapEnergy_E = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
     sprintf(histo, "CaloTowersTask_map_energy_H");
     mapEnergy_H = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
     sprintf(histo, "CaloTowersTask_map_energy_EH");
     mapEnergy_EH = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
   }
 
   //All ECAL cell histos are used
   // XXX: ECAL 0-25 [0-26, 26 bins]   HCAL 0-4 [0-5, 5 bins]
   sprintf(histo, "number_of_bad_cells_Ecal_EB");
   numBadCellsEcal_EB = ibooker.book1D(histo, histo, 26, 0, 26);
   sprintf(histo, "number_of_bad_cells_Ecal_EE");
   numBadCellsEcal_EE = ibooker.book1D(histo, histo, 26, 0, 26);
   sprintf(histo, "number_of_recovered_cells_Ecal_EB");
   numRcvCellsEcal_EB = ibooker.book1D(histo, histo, 26, 0, 26);
   sprintf(histo, "number_of_recovered_cells_Ecal_EE");
   numRcvCellsEcal_EE = ibooker.book1D(histo, histo, 26, 0, 26);
   sprintf(histo, "number_of_problematic_cells_Ecal_EB");
   numPrbCellsEcal_EB = ibooker.book1D(histo, histo, 26, 0, 26);
   sprintf(histo, "number_of_problematic_cells_Ecal_EE");
   numPrbCellsEcal_EE = ibooker.book1D(histo, histo, 26, 0, 26);
 
   //Occupancy vs. ieta is drawn, occupancy map is needed to draw it
   sprintf(histo, "CaloTowersTask_map_occupancy");
   occupancy_map = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
 
   sprintf(histo, "CaloTowersTask_occupancy_vs_ieta");
   occupancy_vs_ieta = ibooker.book1D(histo, histo, 83, -41.5, 41.5);
 
   if (isub == 1 || isub == 0) {
     //All cell histos are used
     sprintf(histo, "number_of_bad_cells_Hcal_HB");
     numBadCellsHcal_HB = ibooker.book1D(histo, histo, 5, 0, 5);
     sprintf(histo, "number_of_recovered_cells_Hcal_HB");
     numRcvCellsHcal_HB = ibooker.book1D(histo, histo, 5, 0, 5);
     sprintf(histo, "number_of_problematic_cells_Hcal_HB");
     numPrbCellsHcal_HB = ibooker.book1D(histo, histo, 5, 0, 5);
 
     //These are the five oldest CaloTower histos used: NTowers, E in HCAL/ECAL, MET and SET
     //-------------------------------------------------------------------------------------------
     sprintf(histo, "CaloTowersTask_energy_HCAL_HB");
     meEnergyHcal_HB = ibooker.book1D(histo, histo, 4100, -200, 8000);
 
     sprintf(histo, "CaloTowersTask_energy_ECAL_HB");
     meEnergyEcal_HB = ibooker.book1D(histo, histo, 3100, -200, 6000);
 
     sprintf(histo, "CaloTowersTask_number_of_fired_towers_HB");
     meNumFiredTowers_HB = ibooker.book1D(histo, histo, 1000, 0, 2000);
 
     sprintf(histo, "CaloTowersTask_MET_HB");
     MET_HB = ibooker.book1D(histo, histo, 3000, 0., 3000.);
 
     sprintf(histo, "CaloTowersTask_SET_HB");
     SET_HB = ibooker.book1D(histo, histo, 8000, 0., 8000.);
     //-------------------------------------------------------------------------------------------
 
     //Timing histos and profiles -- all six are necessary
     //-------------------------------------------------------------------------------------------
     sprintf(histo, "CaloTowersTask_EM_Timing_HB");
     emTiming_HB = ibooker.book1D(histo, histo, 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_HAD_Timing_HB");
     hadTiming_HB = ibooker.book1D(histo, histo, 70, -48., 92.);
 
     //Energy-Timing histos are divided into low, medium and high to reduce memory usage
     //EM
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_Low_HB");
     emEnergyTiming_Low_HB = ibooker.book2D(histo, histo, 40, 0., 40., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_HB");
     emEnergyTiming_HB = ibooker.book2D(histo, histo, 200, 0., 400., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_High_HB");
     emEnergyTiming_High_HB = ibooker.book2D(histo, histo, 200, 0., 3000., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_profile_Low_HB");
     emEnergyTiming_profile_Low_HB = ibooker.bookProfile(histo, histo, 40, 0., 40., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_profile_HB");
     emEnergyTiming_profile_HB = ibooker.bookProfile(histo, histo, 200, 0., 400., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_profile_High_HB");
     emEnergyTiming_profile_High_HB = ibooker.bookProfile(histo, histo, 200, 0., 3000., 110, -120., 100.);
 
     //HAD
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_Low_HB");
     hadEnergyTiming_Low_HB = ibooker.book2D(histo, histo, 40, 0., 40., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_HB");
     hadEnergyTiming_HB = ibooker.book2D(histo, histo, 100, 0., 200., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_High_HB");
     hadEnergyTiming_High_HB = ibooker.book2D(histo, histo, 300, 0., 3000., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_Low_HB");
     hadEnergyTiming_profile_Low_HB = ibooker.bookProfile(histo, histo, 40, 0., 40., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_HB");
     hadEnergyTiming_profile_HB = ibooker.bookProfile(histo, histo, 100, 0., 200., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_High_HB");
     hadEnergyTiming_profile_High_HB = ibooker.bookProfile(histo, histo, 300, 0., 3000., 70, -48., 92.);
     //-------------------------------------------------------------------------------------------
 
     //Everything else is not drawn
     if (useAllHistos_) {
       sprintf(histo, "CaloTowersTask_sum_of_energy_HCAL_vs_ECAL_HB");
       meEnergyHcalvsEcal_HB = ibooker.book2D(histo, histo, 500, 0., 500., 500, 0., 500.);
 
       sprintf(histo, "CaloTowersTask_energy_OUTER_HB");
       meEnergyHO_HB = ibooker.book1D(histo, histo, 1640, -200, 8000);
 
       sprintf(histo, "CaloTowersTask_energy_of_ECAL_component_of_tower_HB");
       meEnergyEcalTower_HB = ibooker.book1D(histo, histo, 440, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_of_HCAL_component_of_tower_HB");
       meEnergyHcalTower_HB = ibooker.book1D(histo, histo, 440, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_HcalPlusEcalPlusHO_HB");
       meTotEnergy_HB = ibooker.book1D(histo, histo, 400, 0., 2000.);
 
       sprintf(histo, "CaloTowersTask_map_energy_HB");
       mapEnergy_HB = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
       sprintf(histo, "CaloTowersTask_map_energy_HCAL_HB");
       mapEnergyHcal_HB = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
       sprintf(histo, "CaloTowersTask_map_energy_ECAL_HB");
       mapEnergyEcal_HB = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
 
       sprintf(histo, "CaloTowersTask_phi_MET_HB");
       phiMET_HB = ibooker.book1D(histo, histo, 72, -3.1415926535898, 3.1415926535898);
     }
   }
 
   if (isub == 2 || isub == 0) {
     //All cell histos are used
     sprintf(histo, "number_of_bad_cells_Hcal_HE");
     numBadCellsHcal_HE = ibooker.book1D(histo, histo, 5, 0, 5);
     sprintf(histo, "number_of_recovered_cells_Hcal_HE");
     numRcvCellsHcal_HE = ibooker.book1D(histo, histo, 5, 0, 5);
     sprintf(histo, "number_of_problematic_cells_Hcal_HE");
     numPrbCellsHcal_HE = ibooker.book1D(histo, histo, 5, 0, 5);
 
     //These are the five oldest CaloTower histos used: NTowers, E in HCAL/ECAL, MET and SET
     //-------------------------------------------------------------------------------------------
     sprintf(histo, "CaloTowersTask_energy_HCAL_HE");
     meEnergyHcal_HE = ibooker.book1D(histo, histo, 1240, -200, 6000);
 
     sprintf(histo, "CaloTowersTask_energy_ECAL_HE");
     meEnergyEcal_HE = ibooker.book1D(histo, histo, 1240, -200, 6000);
 
     sprintf(histo, "CaloTowersTask_number_of_fired_towers_HE");
     meNumFiredTowers_HE = ibooker.book1D(histo, histo, 1000, 0, 2000);
 
     sprintf(histo, "CaloTowersTask_MET_HE");
     MET_HE = ibooker.book1D(histo, histo, 1000, 0., 1000.);
 
     sprintf(histo, "CaloTowersTask_SET_HE");
     SET_HE = ibooker.book1D(histo, histo, 2000, 0., 2000.);
     //-------------------------------------------------------------------------------------------
 
     //Timing histos and profiles -- all six are necessary
     //-------------------------------------------------------------------------------------------
     sprintf(histo, "CaloTowersTask_EM_Timing_HE");
     emTiming_HE = ibooker.book1D(histo, histo, 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_HAD_Timing_HE");
     hadTiming_HE = ibooker.book1D(histo, histo, 70, -48., 92.);
 
     //Energy-Timing histos are divided into low and normal to reduce memory usage
     //EM
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_Low_HE");
     emEnergyTiming_Low_HE = ibooker.book2D(histo, histo, 160, 0., 160., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_HE");
     emEnergyTiming_HE = ibooker.book2D(histo, histo, 200, 0., 800., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_profile_Low_HE");
     emEnergyTiming_profile_Low_HE = ibooker.bookProfile(histo, histo, 160, 0., 160., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_profile_HE");
     emEnergyTiming_profile_HE = ibooker.bookProfile(histo, histo, 200, 0., 800., 110, -120., 100.);
 
     //HAD
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_Low_HE");
     hadEnergyTiming_Low_HE = ibooker.book2D(histo, histo, 160, 0., 160., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_HE");
     hadEnergyTiming_HE = ibooker.book2D(histo, histo, 200, 0., 800., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_Low_HE");
     hadEnergyTiming_profile_Low_HE = ibooker.bookProfile(histo, histo, 160, 0., 160., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_HE");
     hadEnergyTiming_profile_HE = ibooker.bookProfile(histo, histo, 200, 0., 800., 70, -48., 92.);
     //-------------------------------------------------------------------------------------------
 
     //Everything else is not drawn
     if (useAllHistos_) {
       sprintf(histo, "CaloTowersTask_sum_of_energy_HCAL_vs_ECAL_HE");
       meEnergyHcalvsEcal_HE = ibooker.book2D(histo, histo, 500, 0., 500., 500, 0., 500.);
 
       sprintf(histo, "CaloTowersTask_energy_OUTER_HE");
       meEnergyHO_HE = ibooker.book1D(histo, histo, 440, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_of_ECAL_component_of_tower_HE");
       meEnergyEcalTower_HE = ibooker.book1D(histo, histo, 1100, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_of_HCAL_component_of_tower_HE");
       meEnergyHcalTower_HE = ibooker.book1D(histo, histo, 1100, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_HcalPlusEcalPlusHO_HE");
       meTotEnergy_HE = ibooker.book1D(histo, histo, 400, 0., 2000.);
 
       sprintf(histo, "CaloTowersTask_map_energy_HE");
       mapEnergy_HE = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
       sprintf(histo, "CaloTowersTask_map_energy_HCAL_HE");
       mapEnergyHcal_HE = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
       sprintf(histo, "CaloTowersTask_map_energy_ECAL_HE");
       mapEnergyEcal_HE = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
 
       sprintf(histo, "CaloTowersTask_phi_MET_HE");
       phiMET_HE = ibooker.book1D(histo, histo, 72, -3.1415926535898, 3.1415926535898);
     }
   }
 
   if (isub == 3 || isub == 0) {
     //All cell histos are used
     sprintf(histo, "number_of_bad_cells_Hcal_HF");
     numBadCellsHcal_HF = ibooker.book1D(histo, histo, 5, 0, 5);
     sprintf(histo, "number_of_recovered_cells_Hcal_HF");
     numRcvCellsHcal_HF = ibooker.book1D(histo, histo, 5, 0, 5);
     sprintf(histo, "number_of_problematic_cells_Hcal_HF");
     numPrbCellsHcal_HF = ibooker.book1D(histo, histo, 5, 0, 5);
 
     //These are the five oldest CaloTower histos used: NTowers, E in HCAL/ECAL, MET and SET
     //-------------------------------------------------------------------------------------------
     sprintf(histo, "CaloTowersTask_energy_HCAL_HF");
     meEnergyHcal_HF = ibooker.book1D(histo, histo, 4040, -200, 20000);
 
     sprintf(histo, "CaloTowersTask_energy_ECAL_HF");
     meEnergyEcal_HF = ibooker.book1D(histo, histo, 2440, -200, 12000);
 
     sprintf(histo, "CaloTowersTask_number_of_fired_towers_HF");
     meNumFiredTowers_HF = ibooker.book1D(histo, histo, 1000, 0, 2000);
 
     sprintf(histo, "CaloTowersTask_MET_HF");
     MET_HF = ibooker.book1D(histo, histo, 500, 0., 500.);
 
     sprintf(histo, "CaloTowersTask_SET_HF");
     SET_HF = ibooker.book1D(histo, histo, 2000, 0., 2000.);
     //-------------------------------------------------------------------------------------------
 
     //Timing histos and profiles -- all six are necessary
     //-------------------------------------------------------------------------------------------
     sprintf(histo, "CaloTowersTask_EM_Timing_HF");
     emTiming_HF = ibooker.book1D(histo, histo, 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_HAD_Timing_HF");
     hadTiming_HF = ibooker.book1D(histo, histo, 70, -48., 92.);
 
     //EM
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_HF");
     emEnergyTiming_HF = ibooker.book2D(histo, histo, 150, 0., 300., 110, -120., 100.);
 
     sprintf(histo, "CaloTowersTask_EM_Energy_Timing_profile_HF");
     emEnergyTiming_profile_HF = ibooker.bookProfile(histo, histo, 150, 0., 300., 110, -120., 100.);
 
     //HAD (requires two different sets of histograms to lower RAM usage)
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_Low_HF");
     hadEnergyTiming_Low_HF = ibooker.book2D(histo, histo, 40, 0., 40., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_HF");
     hadEnergyTiming_HF = ibooker.book2D(histo, histo, 200, 0., 600., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_Low_HF");
     hadEnergyTiming_profile_Low_HF = ibooker.bookProfile(histo, histo, 40, 0., 40., 70, -48., 92.);
 
     sprintf(histo, "CaloTowersTask_HAD_Energy_Timing_profile_HF");
     hadEnergyTiming_profile_HF = ibooker.bookProfile(histo, histo, 200, 0., 600., 70, -48., 92.);
     //-------------------------------------------------------------------------------------------
 
     //Everything else is not drawn
     if (useAllHistos_) {
       sprintf(histo, "CaloTowersTask_sum_of_energy_HCAL_vs_ECAL_HF");
       meEnergyHcalvsEcal_HF = ibooker.book2D(histo, histo, 500, 0., 500., 500, 0., 500.);
 
       sprintf(histo, "CaloTowersTask_energy_OUTER_HF");
       meEnergyHO_HF = ibooker.book1D(histo, histo, 440, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_of_ECAL_component_of_tower_HF");
       meEnergyEcalTower_HF = ibooker.book1D(histo, histo, 440, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_of_HCAL_component_of_tower_HF");
       meEnergyHcalTower_HF = ibooker.book1D(histo, histo, 440, -200, 2000);
 
       sprintf(histo, "CaloTowersTask_energy_HcalPlusEcalPlusHO_HF");
       meTotEnergy_HF = ibooker.book1D(histo, histo, 400, 0., 2000.);
 
       sprintf(histo, "CaloTowersTask_map_energy_HF");
       mapEnergy_HF = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
       sprintf(histo, "CaloTowersTask_map_energy_HCAL_HF");
       mapEnergyHcal_HF = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
       sprintf(histo, "CaloTowersTask_map_energy_ECAL_HF");
       mapEnergyEcal_HF = ibooker.book2D(histo, histo, 83, -41.5, 41.5, 72, 0., 72.);
 
       sprintf(histo, "CaloTowersTask_phi_MET_HF");
       phiMET_HF = ibooker.book1D(histo, histo, 72, -3.1415926535898, 3.1415926535898);
     }
   }
 }

double CaloTowersValidation::dR	(	double	eta1,
		double	phi1,
		double	eta2,
		double	phi2
	)

private

Definition at line 789 of file CaloTowersValidation.cc.

References DEFINE_FWK_MODULE, HLT_2018_cff::eta1, PI, mathSSE::sqrt(), and createJobs::tmp.

Referenced by analyze().

                                                                                   {
   double PI = 3.1415926535898;
   double deltaphi = phi1 - phi2;
   if (phi2 > phi1) {
     deltaphi = phi2 - phi1;
   }
   if (deltaphi > PI) {
     deltaphi = 2. * PI - deltaphi;
   }
   double deltaeta = eta2 - eta1;
   double tmp = sqrt(deltaeta * deltaeta + deltaphi * deltaphi);
   return tmp;
 }