Inheritance diagram for HGCalHitCalibration:

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

	~HGCalHitCalibration () override

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

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

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

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

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

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

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

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

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

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

	~DQMEDAnalyzer () override=default

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 () 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

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)

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)

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::EDGetTokenT< std::vector< CaloParticle > >	caloParticles_

int	debug_

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 int	layers_ = 60

Additional Inherited Members
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 Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 43 of file HGCalHitCalibration.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 82 of file HGCalHitCalibration.cc.

References algo_, caloTruthProducer_cfi::caloParticles, caloParticles_, gamEcalExtractorBlocks_cff::detector, electrons_cff::electrons, electrons_, Energy_layer_calib_, Energy_layer_calib_fraction_, edm::ParameterSet::getParameter(), hgcalMultiClusters_, nano_cff::photons, photons_, recHitsBH_, EcalDeadCellBoundaryEnergyFilter_cfi::recHitsEE, recHitsEE_, recHitsFH_, and AlCaHLTBitMon_QueryRunRegistry::string.

   : 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;
   }
   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 ( )

override

Definition at line 116 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

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

overrideprivate

Definition at line 182 of file HGCalHitCalibration.cc.

References a, algo_, b, caloTruthProducer_cfi::caloParticles, caloParticles_, fastPrimaryVertexProducer_cfi::clusters, reco::CaloCluster::correctedEnergy(), debug_, reco::deltaR2(), DetId::det(), electrons_, reco::PFCluster::energy(), SimCluster::energy(), Energy_layer_calib_, Energy_layer_calib_fraction_, HcalObjRepresent::Fill(), fillWithRecHits(), DetId::Forward, edm::Event::getByToken(), hgcal::RecHitTools::getEventSetup(), hgcal::RecHitTools::getLayerWithOffset(), hgcal::RecHitTools::getSiThickness(), h_EoP_CPene_calib_fraction_, DetId::Hcal, HcalEndcap, hgcal_ele_EoP_CPene_calib_fraction_, hgcal_EoP_CPene_calib_fraction_, hgcal_photon_EoP_CPene_calib_fraction_, hgcalMultiClusters_, HGCEE, HGCHEB, HGCHEF, SimCluster::hits_and_fractions(), mps_fire::i, IfLogTrace, edm::HandleBase::isValid(), muons2muons_cfi::photon, photons_, rawRecHits_, recHitsBH_, recHitsEE_, recHitsFH_, recHitTools_, SimCluster::simEnergy(), edm::SortedCollection< T, SORT >::size(), and DetId::subdetId().

                                                                {
   using namespace edm;
 
   recHitTools_.getEventSetup(iSetup);
 
   Handle<HGCRecHitCollection> recHitHandleEE;
   Handle<HGCRecHitCollection> recHitHandleFH;
   Handle<HGCRecHitCollection> recHitHandleBH;
 
   Handle<std::vector<CaloParticle> > caloParticleHandle;
   iEvent.getByToken(caloParticles_, caloParticleHandle);
   const std::vector<CaloParticle>& caloParticles = *caloParticleHandle;
 
   Handle<std::vector<reco::PFCluster> > hgcalMultiClustersHandle;
     iEvent.getByToken(hgcalMultiClusters_, hgcalMultiClustersHandle);
 
   Handle<std::vector<reco::GsfElectron> > PFElectronHandle;
   iEvent.getByToken(electrons_, PFElectronHandle);
 
   Handle<std::vector<reco::Photon> > PFPhotonHandle;
   iEvent.getByToken(photons_, PFPhotonHandle);
 
   // make a map detid-rechit
   std::map<DetId, const HGCRecHit*> hitmap;
   switch (algo_) {
     case 1: {
       iEvent.getByToken(recHitsEE_, recHitHandleEE);
       iEvent.getByToken(recHitsFH_, recHitHandleFH);
       iEvent.getByToken(recHitsBH_, recHitHandleBH);
       const auto& rechitsEE = *recHitHandleEE;
       const auto& rechitsFH = *recHitHandleFH;
       const auto& rechitsBH = *recHitHandleBH;
       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: {
       iEvent.getByToken(recHitsEE_, recHitHandleEE);
       const HGCRecHitCollection& rechitsEE = *recHitHandleEE;
       for (unsigned int i = 0; i < rechitsEE.size(); i++) {
         hitmap[rechitsEE[i].detid()] = &rechitsEE[i];
       }
       break;
     }
     case 3: {
       iEvent.getByToken(recHitsFH_, recHitHandleFH);
       iEvent.getByToken(recHitsBH_, recHitHandleBH);
       const auto& rechitsFH = *recHitHandleFH;
       const auto& rechitsBH = *recHitHandleBH;
       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) {
     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.subdetId() == HGCEE || hitid.subdetId() == HGCHEF ||
         hitid.subdetId() == HGCHEB)) ||
           (hitid.det() == DetId::Hcal && hitid.subdetId() == HcalEndcap))
             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 (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
       && reco::deltaR2(*closest, it_caloPart) < 0.01) {
     seedDet = recHitTools_.getSiThickness(closest->superCluster()->seed()->seed());
     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
       && 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
 }

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

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 121 of file HGCalHitCalibration.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::cd(), h_EoP_CPene_calib_fraction_, hgcal_ele_EoP_CPene_calib_fraction_, hgcal_EoP_CPene_calib_fraction_, hgcal_photon_EoP_CPene_calib_fraction_, LayerOccupancy_, layers_, and DQMStore::IBooker::setCurrentFolder().

                                                                  {
   ibooker.cd();
   ibooker.setCurrentFolder("HGCalHitCalibration");
   h_EoP_CPene_calib_fraction_[100] =
       ibooker.book1D("h_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   h_EoP_CPene_calib_fraction_[200] =
       ibooker.book1D("h_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   h_EoP_CPene_calib_fraction_[300] =
       ibooker.book1D("h_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[100] =
       ibooker.book1D("hgcal_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[200] =
       ibooker.book1D("hgcal_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_EoP_CPene_calib_fraction_[300] =
       ibooker.book1D("hgcal_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[100] =
       ibooker.book1D("hgcal_ele_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[200] =
       ibooker.book1D("hgcal_ele_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_ele_EoP_CPene_calib_fraction_[300] =
       ibooker.book1D("hgcal_ele_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[100] =
       ibooker.book1D("hgcal_photon_EoP_CPene_100_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[200] =
       ibooker.book1D("hgcal_photon_EoP_CPene_200_calib_fraction", "", 1000, -0.5, 2.5);
   hgcal_photon_EoP_CPene_calib_fraction_[300] =
       ibooker.book1D("hgcal_photon_EoP_CPene_300_calib_fraction", "", 1000, -0.5, 2.5);
   LayerOccupancy_ = ibooker.book1D("LayerOccupancy", "", layers_, 0., (float)layers_);
 }

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

static

Definition at line 376 of file HGCalHitCalibration.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), DEFINE_FWK_MODULE, 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<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("particleFlowClusterHGCalFromMultiCl"));
   desc.add<edm::InputTag>("electrons", edm::InputTag("ecalDrivenGsfElectronsFromMultiCl"));
   desc.add<edm::InputTag>("photons", edm::InputTag("photonsFromMultiCl"));
   descriptions.add("hgcalHitCalibration", desc);
 }

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

private

Definition at line 153 of file HGCalHitCalibration.cc.

References debug_, TauDecayModes::dec, DetId::det(), Energy_layer_calib_fraction_, MonitorElement::Fill(), DetId::Forward, dedxEstimators_cff::fraction, hgcal::RecHitTools::getLayerWithOffset(), hgcal::RecHitTools::getSiThickness(), IfLogTrace, LayerOccupancy_, DetId::rawId(), recHitTools_, 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) {
     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);
   }
 }