#include <EcalBarrelSimHitsValidation.h>

Inheritance diagram for EcalBarrelSimHitsValidation:

Public Types
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
	EcalBarrelSimHitsValidation (const edm::ParameterSet &ps)
	Constructor. More...

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

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer ()

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

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

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
	Analyze. More...

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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Types
typedef std::map< uint32_t, float, std::less< uint32_t > >	MapType

Private Member Functions
float	eCluster2x2 (MapType &themap)

float	eCluster4x4 (float e33, MapType &themap)

virtual float	energyInMatrixEB (int nCellInEta, int nCellInPhi, int centralEta, int centralPhi, int centralZ, MapType &themap)

bool	fillEBMatrix (int nCellInEta, int nCellInPhi, int CentralEta, int CentralPhi, int CentralZ, MapType &fillmap, MapType &themap)

std::vector< uint32_t >	getIdsAroundMax (int nCellInEta, int nCellInPhi, int centralEta, int centralPhi, int centralZ, MapType &themap)

uint32_t	getUnitWithMaxEnergy (MapType &themap)

Private Attributes
std::string	EBHitsCollection

edm::EDGetTokenT< edm::PCaloHitContainer >	EBHitsToken

float	eRLength [26]

std::string	g4InfoLabel

MonitorElement *	meEBcrystalEnergy2_

MonitorElement *	meEBcrystalEnergy_

MonitorElement *	meEBe16_

MonitorElement *	meEBe16oe25_

MonitorElement *	meEBe1_

MonitorElement *	meEBe1oe25_

MonitorElement *	meEBe1oe4_

MonitorElement *	meEBe1oe9_

MonitorElement *	meEBe25_

MonitorElement *	meEBe4_

MonitorElement *	meEBe4oe9_

MonitorElement *	meEBe9_

MonitorElement *	meEBe9oe16_

MonitorElement *	meEBe9oe25_

MonitorElement *	meEBhitEnergy2_

MonitorElement *	meEBhitEnergy_

MonitorElement *	meEBhitLog10Energy25Norm_

MonitorElement *	meEBhitLog10Energy_

MonitorElement *	meEBhitLog10EnergyNorm_

MonitorElement *	meEBLongitudinalShower_

MonitorElement *	meEBOccupancy_

MonitorElement *	menEBCrystals_

MonitorElement *	menEBHits_

int	myEntries

std::string	ValidationCollection

edm::EDGetTokenT< PEcalValidInfo >	ValidationCollectionToken

bool	verbose_

Additional Inherited Members
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 29 of file EcalBarrelSimHitsValidation.h.

Member Typedef Documentation

◆ DQMStore

typedef dqm::legacy::DQMStore EcalBarrelSimHitsValidation::DQMStore

Definition at line 33 of file EcalBarrelSimHitsValidation.h.

◆ MapType

typedef std::map<uint32_t, float, std::less<uint32_t> > EcalBarrelSimHitsValidation::MapType

private

Definition at line 30 of file EcalBarrelSimHitsValidation.h.

◆ MonitorElement

typedef dqm::legacy::MonitorElement EcalBarrelSimHitsValidation::MonitorElement

Definition at line 34 of file EcalBarrelSimHitsValidation.h.

Constructor & Destructor Documentation

◆ EcalBarrelSimHitsValidation()

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

Constructor.

Definition at line 17 of file EcalBarrelSimHitsValidation.cc.

References EBHitsCollection, EBHitsToken, eRLength, g4InfoLabel, edm::ParameterSet::getUntrackedParameter(), HLT_2022v11_cff::InputTag, myEntries, AlCaHLTBitMon_QueryRunRegistry::string, ValidationCollection, ValidationCollectionToken, and verbose_.

     : g4InfoLabel(ps.getParameter<std::string>("moduleLabelG4")),
       EBHitsCollection(ps.getParameter<std::string>("EBHitsCollection")),
       ValidationCollection(ps.getParameter<std::string>("ValidationCollection")) {
   EBHitsToken =
       consumes<edm::PCaloHitContainer>(edm::InputTag(std::string(g4InfoLabel), std::string(EBHitsCollection)));
   ValidationCollectionToken =
       consumes<PEcalValidInfo>(edm::InputTag(std::string(g4InfoLabel), std::string(ValidationCollection)));
   // verbosity switch
   verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
 
   myEntries = 0;
   for (int myStep = 0; myStep < 26; myStep++) {
     eRLength[myStep] = 0.0;
   }
 }

Member Function Documentation

◆ analyze()

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

overrideprotectedvirtual

Analyze.

Reimplemented from DQMEDAnalyzer.

Definition at line 108 of file EcalBarrelSimHitsValidation.cc.

References simKBmtfDigis_cfi::bx, PEcalValidInfo::bX0(), MillePedeFileConverter_cfg::e, PEcalValidInfo::eb1x1(), EBHitsToken, eCluster2x2(), eCluster4x4(), HCALHighEnergyHPDFilter_cfi::energy, energyInMatrixEB(), eRLength, dqm::impl::MonitorElement::Fill(), fillEBMatrix(), getIdsAroundMax(), getUnitWithMaxEnergy(), mps_fire::i, EBDetId::ietaAbs(), createfilelist::int, EBDetId::iphi(), edm::HandleBase::isValid(), dqmiolumiharvest::j, LogDebug, genParticles_cff::map, meEBcrystalEnergy2_, meEBcrystalEnergy_, meEBe16_, meEBe16oe25_, meEBe1_, meEBe1oe25_, meEBe1oe4_, meEBe1oe9_, meEBe25_, meEBe4_, meEBe4oe9_, meEBe9_, meEBe9oe16_, meEBe9oe25_, meEBhitEnergy2_, meEBhitEnergy_, meEBhitLog10Energy25Norm_, meEBhitLog10Energy_, meEBhitLog10EnergyNorm_, meEBLongitudinalShower_, meEBOccupancy_, menEBCrystals_, menEBHits_, myEntries, dqm::impl::MonitorElement::Reset(), ValidationCollectionToken, and EBDetId::zside().

                                                                                    {
   edm::LogInfo("EventInfo") << " Run = " << e.id().run() << " Event = " << e.id().event();
 
   edm::Handle<edm::PCaloHitContainer> EcalHitsEB;
   e.getByToken(EBHitsToken, EcalHitsEB);
 
   // Do nothing if no Barrel data available
   if (!EcalHitsEB.isValid())
     return;
 
   edm::Handle<PEcalValidInfo> MyPEcalValidInfo;
   e.getByToken(ValidationCollectionToken, MyPEcalValidInfo);
 
   std::vector<PCaloHit> theEBCaloHits;
   theEBCaloHits.insert(theEBCaloHits.end(), EcalHitsEB->begin(), EcalHitsEB->end());
 
   myEntries++;
 
   double EBEnergy_ = 0.;
   std::map<unsigned int, std::vector<PCaloHit *>, std::less<unsigned int>> CaloHitMap;
 
   double eb1 = 0.0;
   double eb4 = 0.0;
   double eb9 = 0.0;
   double eb16 = 0.0;
   double eb25 = 0.0;
   std::vector<double> econtr(140, 0.);
   std::vector<double> econtr25(140, 0.);
 
   MapType ebmap;
   uint32_t nEBHits = 0;
 
   for (std::vector<PCaloHit>::iterator isim = theEBCaloHits.begin(); isim != theEBCaloHits.end(); ++isim) {
     if (isim->time() > 500.) {
       continue;
     }
 
     CaloHitMap[isim->id()].push_back(&(*isim));
 
     EBDetId ebid(isim->id());
 
     LogDebug("HitInfo") << " CaloHit " << isim->getName() << "\n"
                         << " DetID = " << isim->id() << " EBDetId = " << ebid.ieta() << " " << ebid.iphi() << "\n"
                         << " Time = " << isim->time() << "\n"
                         << " Track Id = " << isim->geantTrackId() << "\n"
                         << " Energy = " << isim->energy();
 
     meEBOccupancy_->Fill(ebid.iphi(), ebid.ieta());
 
     uint32_t crystid = ebid.rawId();
     ebmap[crystid] += isim->energy();
 
     EBEnergy_ += isim->energy();
     nEBHits++;
     meEBhitEnergy_->Fill(isim->energy());
     if (isim->energy() > 0) {
       meEBhitLog10Energy_->Fill(log10(isim->energy()));
       int log10i = int((log10(isim->energy()) + 10.) * 10.);
       if (log10i >= 0 && log10i < 140)
         econtr[log10i] += isim->energy();
     }
     meEBhitEnergy2_->Fill(isim->energy());
   }
 
   menEBCrystals_->Fill(ebmap.size());
   if (meEBcrystalEnergy_) {
     for (std::map<uint32_t, float, std::less<uint32_t>>::iterator it = ebmap.begin(); it != ebmap.end(); ++it)
       meEBcrystalEnergy_->Fill((*it).second);
   }
   if (meEBcrystalEnergy2_) {
     for (std::map<uint32_t, float, std::less<uint32_t>>::iterator it = ebmap.begin(); it != ebmap.end(); ++it)
       meEBcrystalEnergy2_->Fill((*it).second);
   }
 
   menEBHits_->Fill(nEBHits);
 
   if (nEBHits > 0) {
     uint32_t ebcenterid = getUnitWithMaxEnergy(ebmap);
     EBDetId myEBid(ebcenterid);
     int bx = myEBid.ietaAbs();
     int by = myEBid.iphi();
     int bz = myEBid.zside();
     eb1 = energyInMatrixEB(1, 1, bx, by, bz, ebmap);
     meEBe1_->Fill(eb1);
     eb9 = energyInMatrixEB(3, 3, bx, by, bz, ebmap);
     meEBe9_->Fill(eb9);
     eb25 = energyInMatrixEB(5, 5, bx, by, bz, ebmap);
     meEBe25_->Fill(eb25);
 
     std::vector<uint32_t> ids25;
     ids25 = getIdsAroundMax(5, 5, bx, by, bz, ebmap);
 
     for (unsigned i = 0; i < 25; i++) {
       for (unsigned int j = 0; j < CaloHitMap[ids25[i]].size(); j++) {
         if (CaloHitMap[ids25[i]][j]->energy() > 0) {
           int log10i = int((log10(CaloHitMap[ids25[i]][j]->energy()) + 10.) * 10.);
           if (log10i >= 0 && log10i < 140)
             econtr25[log10i] += CaloHitMap[ids25[i]][j]->energy();
         }
       }
     }
 
     MapType newebmap;
     if (fillEBMatrix(3, 3, bx, by, bz, newebmap, ebmap)) {
       eb4 = eCluster2x2(newebmap);
       meEBe4_->Fill(eb4);
     }
     if (fillEBMatrix(5, 5, bx, by, bz, newebmap, ebmap)) {
       eb16 = eCluster4x4(eb9, newebmap);
       meEBe16_->Fill(eb16);
     }
 
     if (eb4 > 0.1)
       meEBe1oe4_->Fill(eb1 / eb4);
     if (eb9 > 0.1)
       meEBe1oe9_->Fill(eb1 / eb9);
     if (eb9 > 0.1)
       meEBe4oe9_->Fill(eb4 / eb9);
     if (eb16 > 0.1)
       meEBe9oe16_->Fill(eb9 / eb16);
     if (eb25 > 0.1)
       meEBe1oe25_->Fill(eb1 / eb25);
     if (eb25 > 0.1)
       meEBe9oe25_->Fill(eb9 / eb25);
     if (eb25 > 0.1)
       meEBe16oe25_->Fill(eb16 / eb25);
 
     if (EBEnergy_ != 0) {
       for (int i = 0; i < 140; i++) {
         meEBhitLog10EnergyNorm_->Fill(-10. + (float(i) + 0.5) / 10., econtr[i] / EBEnergy_);
       }
     }
 
     if (eb25 != 0) {
       for (int i = 0; i < 140; i++) {
         meEBhitLog10Energy25Norm_->Fill(-10. + (float(i) + 0.5) / 10., econtr25[i] / eb25);
       }
     }
   }
 
   if (MyPEcalValidInfo.isValid()) {
     if (MyPEcalValidInfo->eb1x1() > 0.) {
       std::vector<float> BX0 = MyPEcalValidInfo->bX0();
       meEBLongitudinalShower_->Reset();
       for (int myStep = 0; myStep < 26; myStep++) {
         eRLength[myStep] += BX0[myStep];
         meEBLongitudinalShower_->Fill(float(myStep), eRLength[myStep] / myEntries);
       }
     }
   }
 }

◆ bookHistograms()

void EcalBarrelSimHitsValidation::bookHistograms	(	DQMStore::IBooker &	ib,
		edm::Run const &	,
		edm::EventSetup const &	c
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 34 of file EcalBarrelSimHitsValidation.cc.

References timingPdfMaker::histo, cuy::ib, meEBcrystalEnergy2_, meEBcrystalEnergy_, meEBe16_, meEBe16oe25_, meEBe1_, meEBe1oe25_, meEBe1oe4_, meEBe1oe9_, meEBe25_, meEBe4_, meEBe4oe9_, meEBe9_, meEBe9oe16_, meEBe9oe25_, meEBhitEnergy2_, meEBhitEnergy_, meEBhitLog10Energy25Norm_, meEBhitLog10Energy_, meEBhitLog10EnergyNorm_, meEBLongitudinalShower_, meEBOccupancy_, menEBCrystals_, menEBHits_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                             {
   ib.setCurrentFolder("EcalHitsV/EcalSimHitsValidation");
   ib.setScope(MonitorElementData::Scope::RUN);
 
   std::string histo = "EB hits multiplicity";
   menEBHits_ = ib.book1D(histo, histo, 50, 0., 5000.);
 
   histo = "EB crystals multiplicity";
   menEBCrystals_ = ib.book1D(histo, histo, 200, 0., 2000.);
 
   histo = "EB occupancy";
   meEBOccupancy_ = ib.book2D(histo, histo, 360, 0., 360., 170, -85., 85.);
 
   histo = "EB longitudinal shower profile";
   meEBLongitudinalShower_ = ib.bookProfile(histo, histo, 26, 0., 26., 100, 0., 20000.);
 
   histo = "EB hits energy spectrum";
   meEBhitEnergy_ = ib.book1D(histo, histo, 4000, 0., 400.);
 
   histo = "EB hits log10energy spectrum";
   meEBhitLog10Energy_ = ib.book1D(histo, histo, 140, -10., 4.);
 
   histo = "EB hits log10energy spectrum vs normalized energy";
   meEBhitLog10EnergyNorm_ = ib.bookProfile(histo, histo, 140, -10., 4., 100, 0., 1.);
 
   histo = "EB hits log10energy spectrum vs normalized energy25";
   meEBhitLog10Energy25Norm_ = ib.bookProfile(histo, histo, 140, -10., 4., 100, 0., 1.);
 
   histo = "EB hits energy spectrum 2";
   meEBhitEnergy2_ = ib.book1D(histo, histo, 1000, 0., 0.001);
 
   histo = "EB crystal energy spectrum";
   meEBcrystalEnergy_ = ib.book1D(histo, histo, 5000, 0., 50.);
 
   histo = "EB crystal energy spectrum 2";
   meEBcrystalEnergy2_ = ib.book1D(histo, histo, 1000, 0., 0.001);
 
   histo = "EB E1";
   meEBe1_ = ib.book1D(histo, histo, 400, 0., 400.);
 
   histo = "EB E4";
   meEBe4_ = ib.book1D(histo, histo, 400, 0., 400.);
 
   histo = "EB E9";
   meEBe9_ = ib.book1D(histo, histo, 400, 0., 400.);
 
   histo = "EB E16";
   meEBe16_ = ib.book1D(histo, histo, 400, 0., 400.);
 
   histo = "EB E25";
   meEBe25_ = ib.book1D(histo, histo, 400, 0., 400.);
 
   histo = "EB E1oE4";
   meEBe1oe4_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 
   histo = "EB E1oE9";
   meEBe1oe9_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 
   histo = "EB E4oE9";
   meEBe4oe9_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 
   histo = "EB E9oE16";
   meEBe9oe16_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 
   histo = "EB E1oE25";
   meEBe1oe25_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 
   histo = "EB E9oE25";
   meEBe9oe25_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 
   histo = "EB E16oE25";
   meEBe16oe25_ = ib.book1D(histo, histo, 100, 0.4, 1.1);
 }

◆ eCluster2x2()

float EcalBarrelSimHitsValidation::eCluster2x2 ( MapType & themap )

private

Definition at line 359 of file EcalBarrelSimHitsValidation.cc.

Referenced by analyze().

                                                               {
   float E22 = 0.;
   float e012 = themap[0] + themap[1] + themap[2];
   float e036 = themap[0] + themap[3] + themap[6];
   float e678 = themap[6] + themap[7] + themap[8];
   float e258 = themap[2] + themap[5] + themap[8];
 
   if ((e012 > e678 || e012 == e678) && (e036 > e258 || e036 == e258))
     E22 = themap[0] + themap[1] + themap[3] + themap[4];
   else if ((e012 > e678 || e012 == e678) && (e036 < e258 || e036 == e258))
     E22 = themap[1] + themap[2] + themap[4] + themap[5];
   else if ((e012 < e678 || e012 == e678) && (e036 > e258 || e036 == e258))
     E22 = themap[3] + themap[4] + themap[6] + themap[7];
   else if ((e012 < e678 || e012 == e678) && (e036 < e258 || e036 == e258))
     E22 = themap[4] + themap[5] + themap[7] + themap[8];
 
   return E22;
 }

◆ eCluster4x4()

float EcalBarrelSimHitsValidation::eCluster4x4	(	float	e33,
		MapType &	themap
	)

private

Definition at line 378 of file EcalBarrelSimHitsValidation.cc.

Referenced by analyze().

                                                                          {
   float E44 = 0.;
   float e0_4 = themap[0] + themap[1] + themap[2] + themap[3] + themap[4];
   float e0_20 = themap[0] + themap[5] + themap[10] + themap[15] + themap[20];
   float e4_24 = themap[4] + themap[9] + themap[14] + themap[19] + themap[24];
   float e0_24 = themap[20] + themap[21] + themap[22] + themap[23] + themap[24];
 
   if ((e0_4 > e0_24 || e0_4 == e0_24) && (e0_20 > e4_24 || e0_20 == e4_24))
     E44 = e33 + themap[0] + themap[1] + themap[2] + themap[3] + themap[5] + themap[10] + themap[15];
   else if ((e0_4 > e0_24 || e0_4 == e0_24) && (e0_20 < e4_24 || e0_20 == e4_24))
     E44 = e33 + themap[1] + themap[2] + themap[3] + themap[4] + themap[9] + themap[14] + themap[19];
   else if ((e0_4 < e0_24 || e0_4 == e0_24) && (e0_20 > e4_24 || e0_20 == e4_24))
     E44 = e33 + themap[5] + themap[10] + themap[15] + themap[20] + themap[21] + themap[22] + themap[23];
   else if ((e0_4 < e0_24 || e0_4 == e0_24) && (e0_20 < e4_24 || e0_20 == e4_24))
     E44 = e33 + themap[21] + themap[22] + themap[23] + themap[24] + themap[9] + themap[14] + themap[19];
 
   return E44;
 }

◆ energyInMatrixEB()

float EcalBarrelSimHitsValidation::energyInMatrixEB	(	int	nCellInEta,
		int	nCellInPhi,
		int	centralEta,
		int	centralPhi,
		int	centralZ,
		MapType &	themap
	)

privatevirtual

Definition at line 260 of file EcalBarrelSimHitsValidation.cc.

References funct::abs(), LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, LogDebug, and DetId::rawId().

Referenced by analyze().

                                                                                                    {
   int ncristals = 0;
   float totalEnergy = 0.;
 
   int goBackInEta = nCellInEta / 2;
   int goBackInPhi = nCellInPhi / 2;
   int startEta = centralZ * centralEta - goBackInEta;
   int startPhi = centralPhi - goBackInPhi;
 
   for (int ieta = startEta; ieta < startEta + nCellInEta; ieta++) {
     for (int iphi = startPhi; iphi < startPhi + nCellInPhi; iphi++) {
       uint32_t index;
       if (abs(ieta) > 85 || abs(ieta) < 1) {
         continue;
       }
       if (iphi < 1) {
         index = EBDetId(ieta, iphi + 360).rawId();
       } else if (iphi > 360) {
         index = EBDetId(ieta, iphi - 360).rawId();
       } else {
         index = EBDetId(ieta, iphi).rawId();
       }
 
       totalEnergy += themap[index];
       ncristals += 1;
     }
   }
 
   LogDebug("GeomInfo") << nCellInEta << " x " << nCellInPhi << " EB matrix energy = " << totalEnergy << " for "
                        << ncristals << " crystals";
   return totalEnergy;
 }

◆ fillEBMatrix()

bool EcalBarrelSimHitsValidation::fillEBMatrix	(	int	nCellInEta,
		int	nCellInPhi,
		int	CentralEta,
		int	CentralPhi,
		int	CentralZ,
		MapType &	fillmap,
		MapType &	themap
	)

private

Definition at line 325 of file EcalBarrelSimHitsValidation.cc.

References funct::abs(), getUnitWithMaxEnergy(), mps_fire::i, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, and DetId::rawId().

Referenced by analyze().

                                                                                                                      {
   int goBackInEta = nCellInEta / 2;
   int goBackInPhi = nCellInPhi / 2;
 
   int startEta = CentralZ * CentralEta - goBackInEta;
   int startPhi = CentralPhi - goBackInPhi;
 
   int i = 0;
   for (int ieta = startEta; ieta < startEta + nCellInEta; ieta++) {
     for (int iphi = startPhi; iphi < startPhi + nCellInPhi; iphi++) {
       uint32_t index;
       if (abs(ieta) > 85 || abs(ieta) < 1) {
         continue;
       }
       if (iphi < 1) {
         index = EBDetId(ieta, iphi + 360).rawId();
       } else if (iphi > 360) {
         index = EBDetId(ieta, iphi - 360).rawId();
       } else {
         index = EBDetId(ieta, iphi).rawId();
       }
       fillmap[i++] = themap[index];
     }
   }
 
   uint32_t ebcenterid = getUnitWithMaxEnergy(themap);
 
   if (fillmap[i / 2] == themap[ebcenterid])
     return true;
   else
     return false;
 }

◆ getIdsAroundMax()

std::vector< uint32_t > EcalBarrelSimHitsValidation::getIdsAroundMax	(	int	nCellInEta,
		int	nCellInPhi,
		int	centralEta,
		int	centralPhi,
		int	centralZ,
		MapType &	themap
	)

private

Definition at line 294 of file EcalBarrelSimHitsValidation.cc.

References funct::abs(), LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, and DetId::rawId().

Referenced by analyze().

                                                                                                    {
   int ncristals = 0;
   std::vector<uint32_t> ids(nCellInEta * nCellInPhi);
 
   int goBackInEta = nCellInEta / 2;
   int goBackInPhi = nCellInPhi / 2;
   int startEta = centralZ * centralEta - goBackInEta;
   int startPhi = centralPhi - goBackInPhi;
 
   for (int ieta = startEta; ieta < startEta + nCellInEta; ieta++) {
     for (int iphi = startPhi; iphi < startPhi + nCellInPhi; iphi++) {
       uint32_t index;
       if (abs(ieta) > 85 || abs(ieta) < 1) {
         continue;
       }
       if (iphi < 1) {
         index = EBDetId(ieta, iphi + 360).rawId();
       } else if (iphi > 360) {
         index = EBDetId(ieta, iphi - 360).rawId();
       } else {
         index = EBDetId(ieta, iphi).rawId();
       }
       ids[ncristals] = index;
       ncristals += 1;
     }
   }
 
   return ids;
 }

◆ getUnitWithMaxEnergy()

uint32_t EcalBarrelSimHitsValidation::getUnitWithMaxEnergy ( MapType & themap )

private

Definition at line 397 of file EcalBarrelSimHitsValidation.cc.

References LogDebug, and particleFlowClusterECALTimeSelected_cfi::maxEnergy.

Referenced by analyze(), and fillEBMatrix().

                                                                           {
   // look for max
   uint32_t unitWithMaxEnergy = 0;
   float maxEnergy = 0.;
 
   MapType::iterator iter;
   for (iter = themap.begin(); iter != themap.end(); iter++) {
     if (maxEnergy < (*iter).second) {
       maxEnergy = (*iter).second;
       unitWithMaxEnergy = (*iter).first;
     }
   }
 
   LogDebug("GeomInfo") << " max energy of " << maxEnergy << " GeV in Unit id " << unitWithMaxEnergy;
   return unitWithMaxEnergy;
 }