#include <SimHitsValidationHcal.h>

Inheritance diagram for SimHitsValidationHcal:

Classes
struct	energysum

struct	etaRange

struct	idType

Public Member Functions
	SimHitsValidationHcal (const edm::ParameterSet &ps)

	~SimHitsValidationHcal () override

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

virtual void	analyze (edm::Event const &, edm::EventSetup const &)

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)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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
void	analyze (const edm::Event &e, const edm::EventSetup &c) override

void	analyzeHits (std::vector< PCaloHit > &)

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

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)

Private Member Functions
std::vector< std::pair< std::string, std::string > >	getHistogramTypes ()

etaRange	getLimits (idType)

std::pair< int, int >	histId (int subdet, int eta, int depth, unsigned int dep)

Private Attributes
std::string	g4Label_

std::string	hcalHits_

const HcalDDDRecConstants *	hcons

bool	initialized

int	maxDepthHB_

int	maxDepthHE_

int	maxDepthHF_

int	maxDepthHO_

MonitorElement *	meEnergy_HB

MonitorElement *	meEnergy_HE

MonitorElement *	meEnergy_HF

MonitorElement *	meEnergy_HO

std::vector< MonitorElement * >	meHcalEnergyl100_

std::vector< MonitorElement * >	meHcalEnergyl250_

std::vector< MonitorElement * >	meHcalEnergyl25_

std::vector< MonitorElement * >	meHcalEnergyl50_

std::vector< MonitorElement * >	meHcalHitEta_

std::vector< MonitorElement * >	meHcalHitTimeEta_

MonitorElement *	metime_enweighted_HB

MonitorElement *	metime_enweighted_HE

MonitorElement *	metime_enweighted_HF

MonitorElement *	metime_enweighted_HO

MonitorElement *	metime_HB

MonitorElement *	metime_HE

MonitorElement *	metime_HF

MonitorElement *	metime_HO

bool	testNumber_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_hits_

std::vector< idType >	types

bool	verbose_

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

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 29 of file SimHitsValidationHcal.h.

Constructor & Destructor Documentation

SimHitsValidationHcal::SimHitsValidationHcal ( const edm::ParameterSet & ps )

Definition at line 8 of file SimHitsValidationHcal.cc.

References g4Label_, edm::ParameterSet::getParameter(), hcalHits_, HLT_2018_cff::InputTag, AlCaHLTBitMon_QueryRunRegistry::string, testNumber_, tok_hits_, and verbose_.

                                                                       {
   g4Label_ = ps.getParameter<std::string>("ModuleLabel");
   hcalHits_ = ps.getParameter<std::string>("HitCollection");
   verbose_ = ps.getParameter<bool>("Verbose");
   testNumber_ = ps.getParameter<bool>("TestNumber");
 
   tok_hits_ = consumes<edm::PCaloHitContainer>(edm::InputTag(g4Label_, hcalHits_));
 
   edm::LogVerbatim("HitsValidationHcal") << "Module Label: " << g4Label_ << "   Hits: " << hcalHits_
                                          << " TestNumbering " << testNumber_;
 }

SimHitsValidationHcal::~SimHitsValidationHcal ( )

override

Definition at line 20 of file SimHitsValidationHcal.cc.

20 {}

Member Function Documentation

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

overrideprotected

Definition at line 150 of file SimHitsValidationHcal.cc.

References analyzeHits(), edm::EventID::event(), edm::Event::getByToken(), hcons, mps_fire::i, edm::EventBase::id(), edm::HandleBase::isValid(), DetId::rawId(), HcalHitRelabeller::relabel(), edm::EventID::run(), testNumber_, and tok_hits_.

                                                                             {
 #ifdef DebugLog
   edm::LogVerbatim("HitsValidationHcal") << "Run = " << e.id().run() << " Event = " << e.id().event();
 #endif
   std::vector<PCaloHit> caloHits;
   edm::Handle<edm::PCaloHitContainer> hitsHcal;
 
   bool getHits = false;
   e.getByToken(tok_hits_, hitsHcal);
   if (hitsHcal.isValid())
     getHits = true;
 #ifdef DebugLog
   edm::LogVerbatim("HitsValidationHcal") << "HitsValidationHcal.: Input flags Hits " << getHits;
 #endif
   if (getHits) {
     caloHits.insert(caloHits.end(), hitsHcal->begin(), hitsHcal->end());
 #ifdef DebugLog
     edm::LogVerbatim("HitsValidationHcal") << "testNumber_:" << testNumber_;
 #endif
     if (testNumber_) {
       for (unsigned int i = 0; i < caloHits.size(); ++i) {
         unsigned int id_ = caloHits[i].id();
         HcalDetId hid = HcalHitRelabeller::relabel(id_, hcons);
         caloHits[i].setID(hid.rawId());
 #ifdef DebugLog
         edm::LogVerbatim("HitsValidationHcal") << "Hit[" << i << "] " << hid;
 #endif
       }
     }
 #ifdef DebugLog
     edm::LogVerbatim("HitsValidationHcal") << "HitsValidationHcal: Hit buffer " << caloHits.size();
 #endif
     analyzeHits(caloHits);
   }
 }

void SimHitsValidationHcal::analyzeHits ( std::vector< PCaloHit > & hits )

protected

Definition at line 186 of file SimHitsValidationHcal.cc.

References TauDecayModes::dec, LEDCalibrationChannels::depth, SimHitsValidationHcal::energysum::e100, SimHitsValidationHcal::energysum::e25, SimHitsValidationHcal::energysum::e250, SimHitsValidationHcal::energysum::e50, HCALHighEnergyHPDFilter_cfi::energy, PVValHelper::eta, dqm::impl::MonitorElement::Fill(), HcalBarrel, HcalEndcap, HcalForward, HcalOuter, histId(), mps_fire::i, LEDCalibrationChannels::ieta, createfilelist::int, meEnergy_HB, meEnergy_HE, meEnergy_HF, meEnergy_HO, meHcalEnergyl100_, meHcalEnergyl250_, meHcalEnergyl25_, meHcalEnergyl50_, meHcalHitEta_, meHcalHitTimeEta_, metime_enweighted_HB, metime_enweighted_HE, metime_enweighted_HF, metime_enweighted_HO, metime_HB, metime_HE, metime_HF, metime_HO, phi, and ntuplemaker::time.

Referenced by analyze().

                                                                  {
   int nHit = hits.size();
   double entotHB = 0, entotHE = 0, entotHF = 0, entotHO = 0;
   double timetotHB = 0, timetotHE = 0, timetotHF = 0, timetotHO = 0;
   int nHB = 0, nHE = 0, nHO = 0, nHF = 0;
 
   std::map<std::pair<HcalDetId, unsigned int>, energysum> map_try;
   map_try.clear();
   std::map<std::pair<HcalDetId, unsigned int>, energysum>::iterator itr;
 
   for (int i = 0; i < nHit; i++) {
     double energy = hits[i].energy();
     double time = hits[i].time();
     HcalDetId id = HcalDetId(hits[i].id());
     int itime = (int)(time);
     int subdet = id.subdet();
     int depth = id.depth();
     int eta = id.ieta();
     unsigned int dep = hits[i].depth();
 
     std::pair<int, int> types = histId(subdet, eta, depth, dep);
     if (subdet == static_cast<int>(HcalBarrel)) {
       entotHB += energy;
       timetotHB += time;
       nHB++;
     } else if (subdet == static_cast<int>(HcalEndcap)) {
       entotHE += energy;
       timetotHE += time;
       nHE++;
     } else if (subdet == static_cast<int>(HcalOuter)) {
       entotHO += energy;
       timetotHO += time;
       nHO++;
     } else if (subdet == static_cast<int>(HcalForward)) {
       entotHF += energy;
       timetotHF += time;
       nHF++;
     }
 
     std::pair<HcalDetId, unsigned int> id0(id, dep);
     energysum ensum;
     if (map_try.count(id0) != 0)
       ensum = map_try[id0];
     if (itime < 250) {
       ensum.e250 += energy;
       if (itime < 100) {
         ensum.e100 += energy;
         if (itime < 50) {
           ensum.e50 += energy;
           if (itime < 25)
             ensum.e25 += energy;
         }
       }
     }
     map_try[id0] = ensum;
 
 #ifdef DebugLog
     edm::LogVerbatim("HitsValidationHcal")
         << "Hit[" << i << "] ID " << std::dec << " " << id << std::dec << " Det " << id.det() << " Sub " << subdet
         << " depth " << depth << " depthX " << dep << " Eta " << eta << " Phi " << id.iphi() << " E " << energy
         << " time " << time << " type " << types.first << " " << types.second;
 #endif
 
     double etax = eta - 0.5;
     if (eta < 0)
       etax += 1;
     if (types.first >= 0) {
       meHcalHitEta_[types.first]->Fill(etax, energy);
       meHcalHitTimeEta_[types.first]->Fill(etax, time);
     }
     if (types.second >= 0) {
       meHcalHitEta_[types.second]->Fill(etax, energy);
       meHcalHitTimeEta_[types.second]->Fill(etax, time);
     }
   }
 
   meEnergy_HB->Fill(entotHB);
   meEnergy_HE->Fill(entotHE);
   meEnergy_HF->Fill(entotHF);
   meEnergy_HO->Fill(entotHO);
 
   metime_HB->Fill(timetotHB);
   metime_HE->Fill(timetotHE);
   metime_HF->Fill(timetotHF);
   metime_HO->Fill(timetotHO);
 
   metime_enweighted_HB->Fill(timetotHB, entotHB);
   metime_enweighted_HE->Fill(timetotHE, entotHE);
   metime_enweighted_HF->Fill(timetotHF, entotHF);
   metime_enweighted_HO->Fill(timetotHO, entotHO);
 
   for (itr = map_try.begin(); itr != map_try.end(); ++itr) {
     HcalDetId id = (*itr).first.first;
     energysum ensum = (*itr).second;
     std::pair<int, int> types = histId((int)(id.subdet()), id.ieta(), id.depth(), (*itr).first.second);
     int eta = id.ieta();
     int phi = id.iphi();
     double etax = eta - 0.5;
     double phix = phi - 0.5;
     if (types.first >= 0) {
       meHcalEnergyl25_[types.first]->Fill(etax, phix, ensum.e25);
       meHcalEnergyl50_[types.first]->Fill(etax, phix, ensum.e50);
       meHcalEnergyl100_[types.first]->Fill(etax, phix, ensum.e100);
       meHcalEnergyl250_[types.first]->Fill(etax, phix, ensum.e250);
     }
     if (types.second >= 0) {
       meHcalEnergyl25_[types.second]->Fill(etax, phix, ensum.e25);
       meHcalEnergyl50_[types.second]->Fill(etax, phix, ensum.e50);
       meHcalEnergyl100_[types.second]->Fill(etax, phix, ensum.e100);
       meHcalEnergyl250_[types.second]->Fill(etax, phix, ensum.e250);
     }
 
 #ifdef DebugLog
     edm::LogVerbatim("HitsValidationHcal")
         << " energy of tower =" << (*itr).first.first << " in time 25ns is == " << (*itr).second.e25
         << " in time 25-50ns == " << (*itr).second.e50 << " in time 50-100ns == " << (*itr).second.e100
         << " in time 100-250 ns == " << (*itr).second.e250;
 #endif
   }
 }

void SimHitsValidationHcal::bookHistograms	(	DQMStore::IBooker &	ib,
		edm::Run const &	run,
		edm::EventSetup const &	es
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 22 of file SimHitsValidationHcal.cc.

References SimHitsValidationHcal::etaRange::bins, dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), dqm::dqmstoreimpl::DQMStore::IBooker::book2D(), dqmdumpme::first, edm::EventSetup::get(), HcalDDDRecConstants::getEtaRange(), getHistogramTypes(), getLimits(), HcalDDDRecConstants::getMaxDepth(), HcalDDDRecConstants::getNPhi(), hcons, SimHitsValidationHcal::etaRange::high, mps_fire::i, hcalTTPDigis_cfi::iEtaMax, createfilelist::int, MessageLogger_cff::limit, SimHitsValidationHcal::etaRange::low, SiStripPI::max, maxDepthHB_, maxDepthHE_, maxDepthHF_, maxDepthHO_, meEnergy_HB, meEnergy_HE, meEnergy_HF, meEnergy_HO, meHcalEnergyl100_, meHcalEnergyl250_, meHcalEnergyl25_, meHcalEnergyl50_, meHcalHitEta_, meHcalHitTimeEta_, metime_enweighted_HB, metime_enweighted_HE, metime_enweighted_HF, metime_enweighted_HO, metime_HB, metime_HE, metime_HF, metime_HO, Skims_PA_cff::name, edm::second(), dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder(), and overlapproblemtsosanalyzer_cfi::title.

                                                                                                           {
   edm::ESHandle<HcalDDDRecConstants> pHRNDC;
   es.get<HcalRecNumberingRecord>().get(pHRNDC);
   hcons = &(*pHRNDC);
   maxDepthHB_ = hcons->getMaxDepth(0);
   maxDepthHE_ = hcons->getMaxDepth(1);
   maxDepthHF_ = hcons->getMaxDepth(2);
   maxDepthHO_ = hcons->getMaxDepth(3);
 
   // Get Phi segmentation from geometry, use the max phi number so that all iphi
   // values are included.
 
   int NphiMax = hcons->getNPhi(0);
 
   NphiMax = (hcons->getNPhi(1) > NphiMax ? hcons->getNPhi(1) : NphiMax);
   NphiMax = (hcons->getNPhi(2) > NphiMax ? hcons->getNPhi(2) : NphiMax);
   NphiMax = (hcons->getNPhi(3) > NphiMax ? hcons->getNPhi(3) : NphiMax);
 
   // Center the iphi bins on the integers
   float iphi_min = 0.5;
   float iphi_max = NphiMax + 0.5;
   int iphi_bins = (int)(iphi_max - iphi_min);
 
   int iEtaHBMax = hcons->getEtaRange(0).second;
   int iEtaHEMax = std::max(hcons->getEtaRange(1).second, 1);
   int iEtaHFMax = hcons->getEtaRange(2).second;
   int iEtaHOMax = hcons->getEtaRange(3).second;
 
   // Retain classic behavior, all plots have same ieta range.
   // Comment out    code to allow each subdetector to have its on range
 
   int iEtaMax = (iEtaHBMax > iEtaHEMax ? iEtaHBMax : iEtaHEMax);
   iEtaMax = (iEtaMax > iEtaHFMax ? iEtaMax : iEtaHFMax);
   iEtaMax = (iEtaMax > iEtaHOMax ? iEtaMax : iEtaHOMax);
 
   iEtaHBMax = iEtaMax;
   iEtaHEMax = iEtaMax;
   iEtaHFMax = iEtaMax;
   iEtaHOMax = iEtaMax;
 
   // Give an empty bin around the subdet ieta range to make it clear that all
   // ieta rings have been included float ieta_min_HB = -iEtaHBMax - 1.5; float
   // ieta_max_HB = iEtaHBMax + 1.5; int ieta_bins_HB = (int) (ieta_max_HB -
   // ieta_min_HB);
 
   // float ieta_min_HE = -iEtaHEMax - 1.5;
   // float ieta_max_HE = iEtaHEMax + 1.5;
   // int ieta_bins_HE = (int) (ieta_max_HE - ieta_min_HE);
 
   // float ieta_min_HF = -iEtaHFMax - 1.5;
   // float ieta_max_HF = iEtaHFMax + 1.5;
   // int ieta_bins_HF = (int) (ieta_max_HF - ieta_min_HF);
 
   // float ieta_min_HO = -iEtaHOMax - 1.5;
   // float ieta_max_HO = iEtaHOMax + 1.5;
   // int ieta_bins_HO = (int) (ieta_max_HO - ieta_min_HO);
 
 #ifdef DebugLog
   edm::LogVerbatim("HitsValidationHcal") << " Maximum Depths HB:" << maxDepthHB_ << " HE:" << maxDepthHE_
                                          << " HO:" << maxDepthHO_ << " HF:" << maxDepthHF_;
 #endif
   std::vector<std::pair<std::string, std::string>> divisions = getHistogramTypes();
 
   edm::LogVerbatim("HitsValidationHcal") << "Booking the Histograms";
   ib.setCurrentFolder("HcalHitsV/SimHitsValidationHcal");
 
   // Histograms for Hits
 
   char name[100], title[200];
   for (unsigned int i = 0; i < types.size(); ++i) {
     etaRange limit = getLimits(types[i]);
     sprintf(name, "HcalHitEta%s", divisions[i].first.c_str());
     sprintf(title, "Hit energy as a function of eta tower index in %s", divisions[i].second.c_str());
     meHcalHitEta_.push_back(ib.book1D(name, title, limit.bins, limit.low, limit.high));
 
     sprintf(name, "HcalHitTimeAEta%s", divisions[i].first.c_str());
     sprintf(title, "Hit time as a function of eta tower index in %s", divisions[i].second.c_str());
     meHcalHitTimeEta_.push_back(ib.book1D(name, title, limit.bins, limit.low, limit.high));
 
     sprintf(name, "HcalHitE25%s", divisions[i].first.c_str());
     sprintf(title, "Energy in time window 0 to 25 for a tower in %s", divisions[i].second.c_str());
     meHcalEnergyl25_.push_back(
         ib.book2D(name, title, limit.bins, limit.low, limit.high, iphi_bins, iphi_min, iphi_max));
 
     sprintf(name, "HcalHitE50%s", divisions[i].first.c_str());
     sprintf(title, "Energy in time window 0 to 50 for a tower in %s", divisions[i].second.c_str());
     meHcalEnergyl50_.push_back(
         ib.book2D(name, title, limit.bins, limit.low, limit.high, iphi_bins, iphi_min, iphi_max));
 
     sprintf(name, "HcalHitE100%s", divisions[i].first.c_str());
     sprintf(title, "Energy in time window 0 to 100 for a tower in %s", divisions[i].second.c_str());
     meHcalEnergyl100_.push_back(
         ib.book2D(name, title, limit.bins, limit.low, limit.high, iphi_bins, iphi_min, iphi_max));
 
     sprintf(name, "HcalHitE250%s", divisions[i].first.c_str());
     sprintf(title, "Energy in time window 0 to 250 for a tower in %s", divisions[i].second.c_str());
     meHcalEnergyl250_.push_back(
         ib.book2D(name, title, limit.bins, limit.low, limit.high, iphi_bins, iphi_min, iphi_max));
   }
 
   sprintf(name, "Energy_HB");
   meEnergy_HB = ib.book1D(name, name, 100, 0, 1);
   sprintf(name, "Energy_HE");
   meEnergy_HE = ib.book1D(name, name, 100, 0, 1);
   sprintf(name, "Energy_HO");
   meEnergy_HO = ib.book1D(name, name, 100, 0, 1);
   sprintf(name, "Energy_HF");
   meEnergy_HF = ib.book1D(name, name, 100, 0, 50);
 
   sprintf(name, "Time_HB");
   metime_HB = ib.book1D(name, name, 300, -150, 150);
   sprintf(name, "Time_HE");
   metime_HE = ib.book1D(name, name, 300, -150, 150);
   sprintf(name, "Time_HO");
   metime_HO = ib.book1D(name, name, 300, -150, 150);
   sprintf(name, "Time_HF");
   metime_HF = ib.book1D(name, name, 300, -150, 150);
 
   sprintf(name, "Time_Enweighted_HB");
   metime_enweighted_HB = ib.book1D(name, name, 300, -150, 150);
   sprintf(name, "Time_Enweighted_HE");
   metime_enweighted_HE = ib.book1D(name, name, 300, -150, 150);
   sprintf(name, "Time_Enweighted_HO");
   metime_enweighted_HO = ib.book1D(name, name, 300, -150, 150);
   sprintf(name, "Time_Enweighted_HF");
   metime_enweighted_HF = ib.book1D(name, name, 300, -150, 150);
 }

void SimHitsValidationHcal::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 463 of file SimHitsValidationHcal.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("ModuleLabel", "g4SimHits");
   desc.add<std::string>("HitCollection", "HcalHits");
   desc.add<bool>("Verbose", false);
   desc.add<bool>("TestNumber", false);
 
   descriptions.addDefault(desc);
 }

std::vector< std::pair< std::string, std::string > > SimHitsValidationHcal::getHistogramTypes ( )

private

Definition at line 387 of file SimHitsValidationHcal.cc.

References LEDCalibrationChannels::depth, HcalBarrel, HcalEmpty, HcalEndcap, HcalForward, HcalOuter, dqmdumpme::k, SiStripPI::max, HLT_2018_cff::maxDepth, maxDepthHB_, maxDepthHE_, maxDepthHF_, maxDepthHO_, hfnoseParametersInitialization_cfi::name2, names, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by bookHistograms().

                                                                                   {
   int maxDepth = std::max(maxDepthHB_, maxDepthHE_);
   maxDepth = std::max(maxDepth, maxDepthHF_);
   maxDepth = std::max(maxDepth, maxDepthHO_);
 
   std::vector<std::pair<std::string, std::string>> divisions;
   std::pair<std::string, std::string> names;
   char name1[40], name2[40];
   SimHitsValidationHcal::idType type;
   // first overall Hcal
   for (int depth = 0; depth < maxDepth; ++depth) {
     snprintf(name1, 40, "HC%d", depth);
     snprintf(name2, 40, "HCAL depth%d", depth + 1);
     names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
     type = SimHitsValidationHcal::idType(HcalEmpty, 0, depth + 1, depth + 1);
     divisions.push_back(names);
     types.push_back(type);
   }
   // HB
   for (int depth = 0; depth < maxDepthHB_; ++depth) {
     snprintf(name1, 40, "HB%d", depth);
     snprintf(name2, 40, "HB depth%d", depth + 1);
     names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
     type = SimHitsValidationHcal::idType(HcalBarrel, 0, depth + 1, depth + 1);
     divisions.push_back(names);
     types.push_back(type);
   }
   // HE
   for (int depth = 0; depth < maxDepthHE_; ++depth) {
     snprintf(name1, 40, "HE%d+z", depth);
     snprintf(name2, 40, "HE +z depth%d", depth + 1);
     names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
     type = SimHitsValidationHcal::idType(HcalEndcap, 1, depth + 1, depth + 1);
     divisions.push_back(names);
     types.push_back(type);
     snprintf(name1, 40, "HE%d-z", depth);
     snprintf(name2, 40, "HE -z depth%d", depth + 1);
     names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
     type = SimHitsValidationHcal::idType(HcalEndcap, -1, depth + 1, depth + 1);
     divisions.push_back(names);
     types.push_back(type);
   }
   // HO
   {
     int depth = maxDepthHO_;
     snprintf(name1, 40, "HO%d", depth);
     snprintf(name2, 40, "HO depth%d", depth);
     names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
     type = SimHitsValidationHcal::idType(HcalOuter, 0, depth, depth);
     divisions.push_back(names);
     types.push_back(type);
   }
   // HF (first absorber, then different types of abnormal hits)
   std::string hfty1[4] = {"A", "W", "B", "J"};
   std::string hfty2[4] = {"Absorber", "Window", "Bundle", "Jungle"};
   int dept0[4] = {0, 1, 2, 3};
   for (int k = 0; k < 4; ++k) {
     for (int depth = 0; depth < maxDepthHF_; ++depth) {
       snprintf(name1, 40, "HF%s%d+z", hfty1[k].c_str(), depth);
       snprintf(name2, 40, "HF (%s) +z depth%d", hfty2[k].c_str(), depth + 1);
       names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
       type = SimHitsValidationHcal::idType(HcalForward, 1, depth + 1, dept0[k]);
       divisions.push_back(names);
       types.push_back(type);
       snprintf(name1, 40, "HF%s%d-z", hfty1[k].c_str(), depth);
       snprintf(name2, 40, "HF (%s) -z depth%d", hfty2[k].c_str(), depth + 1);
       names = std::pair<std::string, std::string>(std::string(name1), std::string(name2));
       type = SimHitsValidationHcal::idType(HcalForward, -1, depth + 1, dept0[k]);
       divisions.push_back(names);
       types.push_back(type);
     }
   }
 
   return divisions;
 }

SimHitsValidationHcal::etaRange SimHitsValidationHcal::getLimits ( idType type )

private

Definition at line 307 of file SimHitsValidationHcal.cc.

References trigObjTnPSource_cfi::bins, generateTowerEtThresholdLUT::etaRange, HcalDDDRecConstants::getEtaRange(), HcalBarrel, HcalEndcap, HcalForward, HcalOuter, hcons, LaserClient_cfi::high, LaserClient_cfi::low, FastTimerService_cff::range, SimHitsValidationHcal::idType::subdet, and SimHitsValidationHcal::idType::z.

Referenced by bookHistograms().

                                                                           {
   int bins;
   std::pair<int, int> range;
   double low, high;
 
   if (type.subdet == HcalBarrel) {
     range = hcons->getEtaRange(0);
     low = -range.second;
     high = range.second;
     bins = (high - low);
   } else if (type.subdet == HcalEndcap) {
     range = hcons->getEtaRange(1);
     bins = range.second - range.first;
     if (type.z == 1) {
       low = range.first;
       high = range.second;
     } else {
       low = -range.second;
       high = -range.first;
     }
   } else if (type.subdet == HcalOuter) {
     range = hcons->getEtaRange(3);
     low = -range.second;
     high = range.second;
     bins = high - low;
   } else if (type.subdet == HcalForward) {
     range = hcons->getEtaRange(2);
     bins = range.second - range.first;
     if (type.z == 1) {
       low = range.first;
       high = range.second;
     } else {
       low = -range.second;
       high = -range.first;
     }
   } else {
     bins = 82;
     low = -41;
     high = 41;
   }
 #ifdef DebugLog
   edm::LogVerbatim("HitsValidationHcal") << "Subdetector:" << type.subdet << " z:" << type.z
                                          << " range.first:" << range.first << " and second:" << range.second;
   edm::LogVerbatim("HitsValidationHcal") << "bins: " << bins << " low:" << low << " high:" << high;
 #endif
   return SimHitsValidationHcal::etaRange(bins, low, high);
 }

std::pair< int, int > SimHitsValidationHcal::histId	(	int	subdet,
		int	eta,
		int	depth,
		unsigned int	dep
	)

private

Definition at line 355 of file SimHitsValidationHcal.cc.

References HcalEmpty, HcalEndcap, HcalForward, globals_cff::id1, globals_cff::id2, dqmdumpme::k, and z.

Referenced by analyzeHits().

                                                                                                 {
   int id1(-1), id2(-1);
   for (unsigned int k = 0; k < types.size(); ++k) {
     if (subdet == HcalForward) {
       if (subdet == (int)(types[k].subdet) && depth == types[k].depth1 && eta * types[k].z > 0 &&
           dep == (unsigned int)(types[k].depth2)) {
         id1 = k;
         break;
       }
     } else if (subdet == HcalEndcap) {
       if (subdet == (int)(types[k].subdet) && depth == types[k].depth1 && eta * types[k].z > 0) {
         id1 = k;
         break;
       }
     } else {
       if (subdet == (int)(types[k].subdet) && depth == types[k].depth1) {
         id1 = k;
         break;
       }
     }
   }
   if (subdet == HcalForward)
     depth += 2 * dep;
   for (unsigned int k = 0; k < types.size(); ++k) {
     if (types[k].subdet == HcalEmpty && types[k].depth1 == depth) {
       id2 = k;
       break;
     }
   }
   return std::pair<int, int>(id1, id2);
 }