Inheritance diagram for HGCalHitCalibration:

Public Member Functions
	HGCalHitCalibration (const edm::ParameterSet &)

	~HGCalHitCalibration () 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

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

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

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 &)

Private Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

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

void	fillWithRecHits (std::map< DetId, const HGCRecHit *> &, DetId, unsigned int, float, int &, float &)

Private Attributes
int	algo_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeomToken_

edm::EDGetTokenT< std::vector< CaloParticle > >	caloParticles_

int	debug_

int	depletion0_

edm::EDGetTokenT< std::vector< reco::GsfElectron > >	electrons_

std::array< float, layers_ >	Energy_layer_calib_

std::array< float, layers_ >	Energy_layer_calib_fraction_

std::map< int, MonitorElement * >	h_EoP_CPene_calib_fraction_

std::map< int, MonitorElement * >	hgcal_ele_EoP_CPene_calib_fraction_

std::map< int, MonitorElement * >	hgcal_EoP_CPene_calib_fraction_

std::map< int, MonitorElement * >	hgcal_photon_EoP_CPene_calib_fraction_

edm::EDGetTokenT< std::vector< reco::PFCluster > >	hgcalMultiClusters_

MonitorElement *	LayerOccupancy_

edm::EDGetTokenT< std::vector< reco::Photon > >	photons_

bool	rawRecHits_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsBH_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsEE_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsFH_

hgcal::RecHitTools	recHitTools_

Static Private Attributes
static constexpr int	depletion1_ = 200

static constexpr int	depletion2_ = 300

static constexpr int	layers_ = 60

static constexpr int	scint_ = 400

Additional Inherited Members
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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 38 of file HGCalHitCalibration.cc.

Constructor & Destructor Documentation

◆ HGCalHitCalibration()

HGCalHitCalibration::HGCalHitCalibration ( const edm::ParameterSet & iConfig )

explicit

Definition at line 79 of file HGCalHitCalibration.cc.

References algo_, caloTruthCellsProducer_cfi::caloParticles, caloParticles_, depletion0_, hgcalTestNeighbor_cfi::detector, pwdgSkimBPark_cfi::electrons, electrons_, Energy_layer_calib_, Energy_layer_calib_fraction_, edm::ParameterSet::getParameter(), hgcalMultiClusters_, BPHMonitor_cfi::photons, photons_, recHitsBH_, EcalDeadCellBoundaryEnergyFilter_cfi::recHitsEE, recHitsEE_, recHitsFH_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : caloGeomToken_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
       rawRecHits_(iConfig.getParameter<bool>("rawRecHits")),
       debug_(iConfig.getParameter<int>("debug")) {
   auto detector = iConfig.getParameter<std::string>("detector");
   auto recHitsEE = iConfig.getParameter<edm::InputTag>("recHitsEE");
   auto recHitsFH = iConfig.getParameter<edm::InputTag>("recHitsFH");
   auto recHitsBH = iConfig.getParameter<edm::InputTag>("recHitsBH");
   auto caloParticles = iConfig.getParameter<edm::InputTag>("caloParticles");
   auto hgcalMultiClusters = iConfig.getParameter<edm::InputTag>("hgcalMultiClusters");
   auto electrons = iConfig.getParameter<edm::InputTag>("electrons");
   auto photons = iConfig.getParameter<edm::InputTag>("photons");
   if (detector == "all") {
     recHitsEE_ = consumes<HGCRecHitCollection>(recHitsEE);
     recHitsFH_ = consumes<HGCRecHitCollection>(recHitsFH);
     recHitsBH_ = consumes<HGCRecHitCollection>(recHitsBH);
     algo_ = 1;
   } else if (detector == "EM") {
     recHitsEE_ = consumes<HGCRecHitCollection>(recHitsEE);
     algo_ = 2;
   } else if (detector == "HAD") {
     recHitsFH_ = consumes<HGCRecHitCollection>(recHitsFH);
     recHitsBH_ = consumes<HGCRecHitCollection>(recHitsBH);
     algo_ = 3;
   }
   depletion0_ = iConfig.getParameter<int>("depletionFine");
   caloParticles_ = consumes<std::vector<CaloParticle> >(caloParticles);
   hgcalMultiClusters_ = consumes<std::vector<reco::PFCluster> >(hgcalMultiClusters);
   electrons_ = consumes<std::vector<reco::GsfElectron> >(electrons);
   photons_ = consumes<std::vector<reco::Photon> >(photons);
 
   // size should be HGC layers 52 is enough
   Energy_layer_calib_.fill(0.);
   Energy_layer_calib_fraction_.fill(0.);
 }

◆ ~HGCalHitCalibration()

HGCalHitCalibration::~HGCalHitCalibration ( )

override

Definition at line 115 of file HGCalHitCalibration.cc.

                                           {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ analyze()

void HGCalHitCalibration::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 189 of file HGCalHitCalibration.cc.

References a, algo_, cms::cuda::assert(), b, caloGeomToken_, caloTruthCellsProducer_cfi::caloParticles, caloParticles_, pv::closest(), bsc_activity_cfg::clusters, debug_, reco::deltaR2(), DetId::det(), electrons_, SimCluster::energy(), Energy_layer_calib_, Energy_layer_calib_fraction_, HcalObjRepresent::Fill(), fillWithRecHits(), DetId::Forward, relativeConstraints::geom, edm::EventSetup::getHandle(), hgcal::RecHitTools::getLayerWithOffset(), hgcal::RecHitTools::getSiThickness(), h_EoP_CPene_calib_fraction_, hgcal_ele_EoP_CPene_calib_fraction_, hgcal_EoP_CPene_calib_fraction_, hgcal_photon_EoP_CPene_calib_fraction_, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, hgcalMultiClusters_, SimCluster::hits_and_fractions(), mps_fire::i, iEvent, IfLogTrace, edm::HandleBase::isValid(), LogDebug, or, displacedMuons_cfi::photon, photons_, rawRecHits_, recHitsBH_, recHitsEE_, recHitsFH_, recHitTools_, scint_, hgcal::RecHitTools::setGeometry(), SimCluster::simEnergy(), and edm::SortedCollection< T, SORT >::size().

                                                                                      {
   const edm::ESHandle<CaloGeometry>& geom = iSetup.getHandle(caloGeomToken_);
   recHitTools_.setGeometry(*geom);
 
   const edm::Handle<std::vector<CaloParticle> >& caloParticleHandle = iEvent.getHandle(caloParticles_);
   const std::vector<CaloParticle>& caloParticles = *caloParticleHandle;
 
   const edm::Handle<std::vector<reco::PFCluster> >& hgcalMultiClustersHandle = iEvent.getHandle(hgcalMultiClusters_);
 
   const edm::Handle<std::vector<reco::GsfElectron> >& PFElectronHandle = iEvent.getHandle(electrons_);
 
   const edm::Handle<std::vector<reco::Photon> >& PFPhotonHandle = iEvent.getHandle(photons_);
 
   // make a map detid-rechit
   std::map<DetId, const HGCRecHit*> hitmap;
   switch (algo_) {
     case 1: {
       const auto& rechitsEE = iEvent.get(recHitsEE_);
       const auto& rechitsFH = iEvent.get(recHitsFH_);
       const auto& rechitsBH = iEvent.get(recHitsBH_);
       for (unsigned int i = 0; i < rechitsEE.size(); ++i) {
         hitmap[rechitsEE[i].detid()] = &rechitsEE[i];
       }
       for (unsigned int i = 0; i < rechitsFH.size(); ++i) {
         hitmap[rechitsFH[i].detid()] = &rechitsFH[i];
       }
       for (unsigned int i = 0; i < rechitsBH.size(); ++i) {
         hitmap[rechitsBH[i].detid()] = &rechitsBH[i];
       }
       break;
     }
     case 2: {
       const HGCRecHitCollection& rechitsEE = iEvent.get(recHitsEE_);
       for (unsigned int i = 0; i < rechitsEE.size(); i++) {
         hitmap[rechitsEE[i].detid()] = &rechitsEE[i];
       }
       break;
     }
     case 3: {
       const auto& rechitsFH = iEvent.get(recHitsFH_);
       const auto& rechitsBH = iEvent.get(recHitsBH_);
       for (unsigned int i = 0; i < rechitsFH.size(); i++) {
         hitmap[rechitsFH[i].detid()] = &rechitsFH[i];
       }
       for (unsigned int i = 0; i < rechitsBH.size(); i++) {
         hitmap[rechitsBH[i].detid()] = &rechitsBH[i];
       }
       break;
     }
     default:
       assert(false);
       break;
   }
 
   // loop over caloParticles
   int seedDet = 0;
   float seedEnergy = 0.;
   IfLogTrace(debug_ > 0, "HGCalHitCalibration") << "Number of caloParticles: " << caloParticles.size() << std::endl;
   for (const auto& it_caloPart : caloParticles) {
     if (it_caloPart.g4Tracks()[0].eventId().event() != 0 or it_caloPart.g4Tracks()[0].eventId().bunchCrossing() != 0) {
       LogDebug("HGCalHitCalibration") << "Excluding CaloParticles from event: "
                                       << it_caloPart.g4Tracks()[0].eventId().event()
                                       << " with BX: " << it_caloPart.g4Tracks()[0].eventId().bunchCrossing()
                                       << std::endl;
       continue;
     }
 
     const SimClusterRefVector& simClusterRefVector = it_caloPart.simClusters();
     Energy_layer_calib_.fill(0.);
     Energy_layer_calib_fraction_.fill(0.);
 
     seedDet = 0;
     seedEnergy = 0.;
     for (const auto& it_sc : simClusterRefVector) {
       const SimCluster& simCluster = (*(it_sc));
       IfLogTrace(debug_ > 1, "HGCalHitCalibration")
           << ">>> SC.energy(): " << simCluster.energy() << " SC.simEnergy(): " << simCluster.simEnergy() << std::endl;
       const std::vector<std::pair<uint32_t, float> >& hits_and_fractions = simCluster.hits_and_fractions();
 
       // loop over hits
       for (const auto& it_haf : hits_and_fractions) {
         unsigned int hitlayer = recHitTools_.getLayerWithOffset(it_haf.first);
         DetId hitid = (it_haf.first);
         // dump raw RecHits and match
         if (rawRecHits_) {
           if ((hitid.det() == DetId::Forward) || (hitid.det() == DetId::HGCalEE) || (hitid.det() == DetId::HGCalHSi) ||
               (hitid.det() == DetId::HGCalHSc))
             fillWithRecHits(hitmap, hitid, hitlayer, it_haf.second, seedDet, seedEnergy);
         }
       }  // end simHit
     }    // end simCluster
 
     auto sumCalibRecHitCalib_fraction =
         std::accumulate(Energy_layer_calib_fraction_.begin(), Energy_layer_calib_fraction_.end(), 0.);
     IfLogTrace(debug_ > 0, "HGCalHitCalibration")
         << ">>> MC Energy: " << it_caloPart.energy() << " reco energy: " << sumCalibRecHitCalib_fraction << std::endl;
     if (h_EoP_CPene_calib_fraction_.count(seedDet))
       h_EoP_CPene_calib_fraction_[seedDet]->Fill(sumCalibRecHitCalib_fraction / it_caloPart.energy());
 
     // Loop on reconstructed SC.
     const auto& clusters = *hgcalMultiClustersHandle;
     float total_energy = 0.;
     float max_dR2 = 0.0025;
     auto closest =
         std::min_element(clusters.begin(), clusters.end(), [&](const reco::PFCluster& a, const reco::PFCluster& b) {
           auto dR2_a = reco::deltaR2(it_caloPart, a);
           auto dR2_b = reco::deltaR2(it_caloPart, b);
           auto ERatio_a = a.correctedEnergy() / it_caloPart.energy();
           auto ERatio_b = b.correctedEnergy() / it_caloPart.energy();
           // If both clusters are within 0.0025, mark as first (min) the
           // element with the highest ratio against the SimCluster
           if (dR2_a < max_dR2 && dR2_b < max_dR2)
             return ERatio_a > ERatio_b;
           return dR2_a < dR2_b;
         });
     if (closest != clusters.end() && reco::deltaR2(*closest, it_caloPart) < 0.01) {
       total_energy = closest->correctedEnergy();
       seedDet = recHitTools_.getSiThickness(closest->seed());
       if (closest->seed().det() == DetId::HGCalHSc) {
         seedDet = scint_;
       }
       if (hgcal_EoP_CPene_calib_fraction_.count(seedDet)) {
         hgcal_EoP_CPene_calib_fraction_[seedDet]->Fill(total_energy / it_caloPart.energy());
       }
     }
 
     auto closest_fcn = [&](auto const& a, auto const& b) {
       auto dR2_a = reco::deltaR2(it_caloPart, a);
       auto dR2_b = reco::deltaR2(it_caloPart, b);
       auto ERatio_a = a.energy() / it_caloPart.energy();
       auto ERatio_b = b.energy() / it_caloPart.energy();
       // If both clusters are within 0.0025, mark as first (min) the
       // element with the highest ratio against the SimCluster
       if (dR2_a < max_dR2 && dR2_b < max_dR2)
         return ERatio_a > ERatio_b;
       return dR2_a < dR2_b;
     };
     // ELECTRONS in HGCAL
     if (PFElectronHandle.isValid()) {
       auto const& ele = (*PFElectronHandle);
       auto closest = std::min_element(ele.begin(), ele.end(), closest_fcn);
       if (closest != ele.end() &&
           ((closest->superCluster()->seed()->seed().det() == DetId::Forward) ||
            (closest->superCluster()->seed()->seed().det() == DetId::HGCalEE) ||
            (closest->superCluster()->seed()->seed().det() == DetId::HGCalHSi)) &&
           reco::deltaR2(*closest, it_caloPart) < 0.01) {
         seedDet = recHitTools_.getSiThickness(closest->superCluster()->seed()->seed());
         if (closest->superCluster()->seed()->seed().det() == DetId::HGCalHSc) {
           seedDet = scint_;
         }
         if (hgcal_ele_EoP_CPene_calib_fraction_.count(seedDet)) {
           hgcal_ele_EoP_CPene_calib_fraction_[seedDet]->Fill(closest->energy() / it_caloPart.energy());
         }
       }
     }
 
     // PHOTONS in HGCAL
     if (PFPhotonHandle.isValid()) {
       auto const& photon = (*PFPhotonHandle);
       auto closest = std::min_element(photon.begin(), photon.end(), closest_fcn);
       if (closest != photon.end() &&
           ((closest->superCluster()->seed()->seed().det() == DetId::Forward) ||
            (closest->superCluster()->seed()->seed().det() == DetId::HGCalEE) ||
            (closest->superCluster()->seed()->seed().det() == DetId::HGCalHSi)) &&
           reco::deltaR2(*closest, it_caloPart) < 0.01) {
         seedDet = recHitTools_.getSiThickness(closest->superCluster()->seed()->seed());
         if (hgcal_photon_EoP_CPene_calib_fraction_.count(seedDet)) {
           hgcal_photon_EoP_CPene_calib_fraction_[seedDet]->Fill(closest->energy() / it_caloPart.energy());
         }
       }
     }
   }  // end caloparticle
 }

◆ bookHistograms()

void HGCalHitCalibration::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	iRun,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 120 of file HGCalHitCalibration.cc.

References dqm::implementation::IBooker::book1D(), dqm::implementation::NavigatorBase::cd(), depletion0_, depletion1_, depletion2_, h_EoP_CPene_calib_fraction_, hgcal_ele_EoP_CPene_calib_fraction_, hgcal_EoP_CPene_calib_fraction_, hgcal_photon_EoP_CPene_calib_fraction_, LayerOccupancy_, layers_, scint_, and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                  {
   ibooker.cd();
   ibooker.setCurrentFolder("HGCalHitCalibration");
   h_EoP_CPene_calib_fraction_[depletion0_] = ibooker.book1D("h_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   h_EoP_CPene_calib_fraction_[depletion1_] = ibooker.book1D("h_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   h_EoP_CPene_calib_fraction_[depletion2_] = ibooker.book1D("h_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   h_EoP_CPene_calib_fraction_[scint_] = ibooker.book1D("h_EoP_CPene_scint_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[depletion0_] =
       ibooker.book1D("hgcal_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[depletion1_] =
       ibooker.book1D("hgcal_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[depletion2_] =
       ibooker.book1D("hgcal_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[scint_] = ibooker.book1D("hgcal_EoP_CPene_scint_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[depletion0_] =
       ibooker.book1D("hgcal_ele_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[depletion1_] =
       ibooker.book1D("hgcal_ele_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[depletion2_] =
       ibooker.book1D("hgcal_ele_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[scint_] =
       ibooker.book1D("hgcal_ele_EoP_CPene_scint_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[depletion0_] =
       ibooker.book1D("hgcal_photon_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[depletion1_] =
       ibooker.book1D("hgcal_photon_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[depletion2_] =
       ibooker.book1D("hgcal_photon_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[scint_] =
       ibooker.book1D("hgcal_photon_EoP_CPene_scint_calib_fraction", "", 1000, -0.5, 2.5);
   LayerOccupancy_ = ibooker.book1D("LayerOccupancy", "", layers_, 0., (float)layers_);
 }

◆ fillDescriptions()

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

static

Definition at line 365 of file HGCalHitCalibration.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v15_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
   edm::ParameterSetDescription desc;
   desc.add<int>("debug", 0);
   desc.add<bool>("rawRecHits", true);
   desc.add<std::string>("detector", "all");
   desc.add<int>("depletionFine", 120);
   desc.add<edm::InputTag>("caloParticles", edm::InputTag("mix", "MergedCaloTruth"));
   desc.add<edm::InputTag>("recHitsEE", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
   desc.add<edm::InputTag>("recHitsFH", edm::InputTag("HGCalRecHit", "HGCHEFRecHits"));
   desc.add<edm::InputTag>("recHitsBH", edm::InputTag("HGCalRecHit", "HGCHEBRecHits"));
   desc.add<edm::InputTag>("hgcalMultiClusters", edm::InputTag("particleFlowClusterHGCal"));
   desc.add<edm::InputTag>("electrons", edm::InputTag("ecalDrivenGsfElectronsHGC"));
   desc.add<edm::InputTag>("photons", edm::InputTag("photonsHGC"));
   descriptions.add("hgcalHitCalibrationDefault", desc);
 }

◆ fillWithRecHits()

void HGCalHitCalibration::fillWithRecHits	(	std::map< DetId, const HGCRecHit *> &	hitmap,
		DetId	hitid,
		unsigned int	hitlayer,
		float	fraction,
		int &	seedDet,
		float &	seedEnergy
	)

private

Definition at line 155 of file HGCalHitCalibration.cc.

References cms::cuda::assert(), debug_, TauDecayModes::dec, DetId::det(), HCALHighEnergyHPDFilter_cfi::energy, Energy_layer_calib_fraction_, dqm::impl::MonitorElement::Fill(), DetId::Forward, HLT_2022v15_cff::fraction, hgcal::RecHitTools::getLayerWithOffset(), hgcal::RecHitTools::getSiThickness(), DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, IfLogTrace, pixelTopology::layer, LayerOccupancy_, DetId::rawId(), recHitTools_, scint_, and DetId::subdetId().

Referenced by analyze().

                                                              {
   if (hitmap.find(hitid) == hitmap.end()) {
     // Hit was not reconstructed
     IfLogTrace(debug_ > 0, "HGCalHitCalibration")
         << ">>> Failed to find detid " << std::hex << hitid.rawId() << std::dec << " Det " << hitid.det() << " Subdet "
         << hitid.subdetId() << std::endl;
     return;
   }
   if ((hitid.det() != DetId::Forward) && (hitid.det() != DetId::HGCalEE) && (hitid.det() != DetId::HGCalHSi) &&
       (hitid.det() != DetId::HGCalHSc)) {
     IfLogTrace(debug_ > 0, "HGCalHitCalibration")
         << ">>> Wrong type of detid " << std::hex << hitid.rawId() << std::dec << " Det " << hitid.det() << " Subdet "
         << hitid.subdetId() << std::endl;
     return;
   }
 
   unsigned int layer = recHitTools_.getLayerWithOffset(hitid);
   assert(hitlayer == layer);
   Energy_layer_calib_fraction_[layer] += hitmap[hitid]->energy() * fraction;
   LayerOccupancy_->Fill(layer);
   if (seedEnergy < hitmap[hitid]->energy()) {
     seedEnergy = hitmap[hitid]->energy();
     seedDet = recHitTools_.getSiThickness(hitid);
     if (hitid.det() == DetId::HGCalHSc) {
       seedDet = scint_;
     }
   }
 }