Inheritance diagram for AlCaHcalHBHEMuonProducer:

Public Member Functions
	AlCaHcalHBHEMuonProducer (const edm::ParameterSet &, const alcaHcalHBHEMuon::Counters *)

void	endStream () override

void	produce (edm::Event &, const edm::EventSetup &) override

	~AlCaHcalHBHEMuonProducer () override=default

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< alcaHcalHBHEMuon::Counters > >
	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 void	globalEndJob (const alcaHcalHBHEMuon::Counters *counters)

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

Private Member Functions
double	activeLength (const DetId &)

void	beginRun (edm::Run const &, edm::EventSetup const &) override

int	depth16HE (int ieta, int iphi)

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

double	gainFactor (const HcalDbService *dbserv, const HcalDetId &id)

bool	goodCell (const HcalDetId &hcid, const reco::Track pTrack, const CaloGeometry geo, const MagneticField *bField)

bool	isGoodVertex (const reco::Vertex &vtx)

int	matchId (const HcalDetId &, const HcalDetId &)

double	respCorr (const DetId &id)

Private Attributes
std::vector < HcalDDDRecConstants::HcalActiveLength >	actHB

std::vector < HcalDDDRecConstants::HcalActiveLength >	actHE

std::vector< std::string >	all_triggers_

const bool	collapseDepth_

std::map< DetId, double >	corrValue_

const std::string	fileInCorr_

const CaloGeometry *	geo_

const HcalDDDRecConstants *	hdc_

HLTConfigProvider	hltConfig_

std::vector< int >	hltresults_

const bool	isItPlan1_

const bool	isItPreRecHit_

const edm::InputTag	labelEBRecHit_

const edm::InputTag	labelEERecHit_

const std::string	labelHBHEMuon_

const edm::InputTag	labelHBHERecHit_

const std::string	labelMuon_

const std::string	labelVtx_

int	maxDepth_

bool	mergedDepth_

int	nAll_

int	nGood_

int	nRun_

const std::string	processName_

const HcalRespCorrs *	respCorrs_

const HcalTopology *	theHBHETopology_

edm::ESGetToken < EcalChannelStatus, EcalChannelStatusRcd >	tok_chan_

edm::ESGetToken< HcalDbService, HcalDbRecord >	tok_dbservice_

edm::ESGetToken < HcalDDDRecConstants, HcalRecNumberingRecord >	tok_ddrec_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EB_

edm::EDGetTokenT < EcalRecHitCollection >	tok_EE_

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	tok_geom_

edm::EDGetTokenT < HBHERecHitCollection >	tok_HBHE_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	tok_htopo_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	tok_magField_

edm::EDGetTokenT < reco::MuonCollection >	tok_Muon_

edm::ESGetToken< HcalRespCorrs, HcalRespCorrsRcd >	tok_respcorr_

edm::ESGetToken < EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd >	tok_sevlv_

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	tok_topo_

edm::EDGetTokenT < edm::TriggerResults >	tok_trigRes_

edm::EDGetTokenT < reco::VertexCollection >	tok_Vtx_

const edm::InputTag	triggerResults_

const std::vector< std::string >	trigNames_

bool	useMyCorr_

const int	verbosity_

const bool	writeRespCorr_

Static Private Attributes
static const int	depthMax_ = 7

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< alcaHcalHBHEMuon::Counters > >
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

Detailed Description

Definition at line 79 of file AlCaHcalHBHEMuonProducer.cc.

Constructor & Destructor Documentation

AlCaHcalHBHEMuonProducer::AlCaHcalHBHEMuonProducer	(	const edm::ParameterSet &	iConfig,
		const alcaHcalHBHEMuon::Counters *
	)

explicit

Definition at line 153 of file AlCaHcalHBHEMuonProducer.cc.

References collapseDepth_, corrValue_, depthMax_, fileInCorr_, edm::ParameterSet::getUntrackedParameter(), gpuClustering::id, timingPdfMaker::infile, isItPlan1_, isItPreRecHit_, labelEBRecHit_, labelEERecHit_, labelHBHEMuon_, labelHBHERecHit_, labelMuon_, labelVtx_, maxDepth_, mergedDepth_, tok_chan_, tok_dbservice_, tok_ddrec_, tok_EB_, tok_EE_, tok_geom_, tok_HBHE_, tok_htopo_, tok_magField_, tok_Muon_, tok_respcorr_, tok_sevlv_, tok_topo_, tok_trigRes_, tok_Vtx_, triggerResults_, and useMyCorr_.

     : trigNames_(iConfig.getParameter<std::vector<std::string>>("triggers")),
       processName_(iConfig.getParameter<std::string>("processName")),
       triggerResults_(iConfig.getParameter<edm::InputTag>("triggerResults")),
       labelEBRecHit_(iConfig.getParameter<edm::InputTag>("labelEBRecHit")),
       labelEERecHit_(iConfig.getParameter<edm::InputTag>("labelEERecHit")),
       labelHBHERecHit_(iConfig.getParameter<edm::InputTag>("labelHBHERecHit")),
       labelVtx_(iConfig.getParameter<std::string>("labelVertex")),
       labelMuon_(iConfig.getParameter<std::string>("labelMuon")),
       labelHBHEMuon_(iConfig.getParameter<std::string>("labelHBHEMuon")),
       collapseDepth_(iConfig.getParameter<bool>("collapseDepth")),
       isItPlan1_(iConfig.getParameter<bool>("isItPlan1")),
       verbosity_(iConfig.getUntrackedParameter<int>("verbosity", 0)),
       isItPreRecHit_(iConfig.getUntrackedParameter<bool>("isItPreRecHit", false)),
       writeRespCorr_(iConfig.getUntrackedParameter<bool>("writeRespCorr", false)),
       fileInCorr_(iConfig.getUntrackedParameter<std::string>("fileInCorr", "")),
       nRun_(0),
       nAll_(0),
       nGood_(0),
       hdc_(nullptr),
       theHBHETopology_(nullptr),
       respCorrs_(nullptr) {
   //now do what ever initialization is needed
   maxDepth_ = iConfig.getUntrackedParameter<int>("maxDepth", 4);
   if (maxDepth_ > depthMax_)
     maxDepth_ = depthMax_;
   else if (maxDepth_ < 1)
     maxDepth_ = 4;
 
   mergedDepth_ = (!isItPreRecHit_) || (collapseDepth_);
   tok_trigRes_ = consumes<edm::TriggerResults>(triggerResults_);
   tok_EB_ = consumes<EcalRecHitCollection>(labelEBRecHit_);
   tok_EE_ = consumes<EcalRecHitCollection>(labelEERecHit_);
   tok_HBHE_ = consumes<HBHERecHitCollection>(labelHBHERecHit_);
   tok_Vtx_ = consumes<reco::VertexCollection>(labelVtx_);
   tok_Muon_ = consumes<reco::MuonCollection>(labelMuon_);
   edm::LogVerbatim("HBHEMuon") << "Labels used: Trig " << triggerResults_ << " Vtx " << labelVtx_ << " EB "
                                << labelEBRecHit_ << " EE " << labelEERecHit_ << " HBHE " << labelHBHERecHit_ << " MU "
                                << labelMuon_;
 
   tok_ddrec_ = esConsumes<HcalDDDRecConstants, HcalRecNumberingRecord, edm::Transition::BeginRun>();
   tok_htopo_ = esConsumes<HcalTopology, HcalRecNumberingRecord, edm::Transition::BeginRun>();
   tok_respcorr_ = esConsumes<HcalRespCorrs, HcalRespCorrsRcd, edm::Transition::BeginRun>();
   tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord, edm::Transition::BeginRun>();
   tok_magField_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
   tok_chan_ = esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
   tok_sevlv_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>();
   tok_topo_ = esConsumes<CaloTopology, CaloTopologyRecord>();
   tok_dbservice_ = esConsumes<HcalDbService, HcalDbRecord>();
 
   if (!fileInCorr_.empty()) {
     std::ifstream infile(fileInCorr_.c_str());
     if (infile.is_open()) {
       while (true) {
         unsigned int id;
         double cfac;
         infile >> id >> cfac;
         if (!infile.good())
           break;
         corrValue_[DetId(id)] = cfac;
       }
       infile.close();
     }
   }
   useMyCorr_ = (!corrValue_.empty());
   edm::LogVerbatim("HBHEMuon") << "Flags used: ollapseDepth " << collapseDepth_ << ":" << mergedDepth_ << " IsItPlan1 "
                                << isItPlan1_ << " IsItPreRecHit " << isItPreRecHit_ << " UseMyCorr " << useMyCorr_;
 
   //create the objects for HcalHBHEMuonVariables which has information of isolated muons
   produces<HcalHBHEMuonVariablesCollection>(labelHBHEMuon_);
   edm::LogVerbatim("HcalIsoTrack") << " Expected to produce the collections:\n"
                                    << "HcalHBHEMuonVariablesCollection with label " << labelHBHEMuon_;
 }

AlCaHcalHBHEMuonProducer::~AlCaHcalHBHEMuonProducer ( )

overridedefault

Member Function Documentation

double AlCaHcalHBHEMuonProducer::activeLength ( const DetId & id_ )

private

Definition at line 1036 of file AlCaHcalHBHEMuonProducer.cc.

References actHB, actHE, HLT_FULL_cff::depth, spr::find(), HcalBarrel, hdc_, mps_fire::i, gpuClustering::id, mergedDepth_, HcalDDDRecConstants::unmergeDepthDetId(), and ecaldqm::zside().

Referenced by beginRun(), and produce().

                                                               {
   HcalDetId id(id_);
   int ieta = id.ietaAbs();
   int zside = id.zside();
   int iphi = id.iphi();
   std::vector<int> dpths;
   if (mergedDepth_) {
     std::vector<HcalDetId> ids;
     hdc_->unmergeDepthDetId(id, ids);
     for (auto idh : ids)
       dpths.emplace_back(idh.depth());
   } else {
     dpths.emplace_back(id.depth());
   }
   double lx(0);
   if (id.subdet() == HcalBarrel) {
     for (unsigned int i = 0; i < actHB.size(); ++i) {
       if ((ieta == actHB[i].ieta) && (zside == actHB[i].zside) &&
           (std::find(dpths.begin(), dpths.end(), actHB[i].depth) != dpths.end()) &&
           (std::find(actHB[i].iphis.begin(), actHB[i].iphis.end(), iphi) != actHB[i].iphis.end())) {
         lx += actHB[i].thick;
       }
     }
   } else {
     for (unsigned int i = 0; i < actHE.size(); ++i) {
       if ((ieta == actHE[i].ieta) && (zside == actHE[i].zside) &&
           (std::find(dpths.begin(), dpths.end(), actHE[i].depth) != dpths.end()) &&
           (std::find(actHE[i].iphis.begin(), actHE[i].iphis.end(), iphi) != actHE[i].iphis.end())) {
         lx += actHE[i].thick;
       }
     }
   }
   return lx;
 }

void AlCaHcalHBHEMuonProducer::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 970 of file AlCaHcalHBHEMuonProducer.cc.

References actHB, actHE, activeLength(), geo_, edm::EventSetup::getData(), CaloGeometry::getSubdetectorGeometry(), HcalDDDRecConstants::getThickActive(), HcalGeometry::getValidDetIds(), reco::JetExtendedAssociation::getValue(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, HcalBarrel, HcalEndcap, hdc_, hltConfig_, HLTConfigProvider::init(), relval_steps::k2, mergedDepth_, HcalDDDRecConstants::mergedDepthDetId(), nRun_, processName_, DetId::rawId(), respCorrs_, edm::RunBase::run(), theHBHETopology_, tok_ddrec_, tok_geom_, tok_htopo_, tok_respcorr_, and writeRespCorr_.

                                                                                        {
   hdc_ = &iSetup.getData(tok_ddrec_);
   actHB.clear();
   actHE.clear();
   actHB = hdc_->getThickActive(0);
   actHE = hdc_->getThickActive(1);
 #ifdef EDM_ML_DEBUG
   unsigned int k1(0), k2(0);
   edm::LogVerbatim("HBHEMuon") << actHB.size() << " Active Length for HB";
   for (const auto& act : actHB) {
     edm::LogVerbatim("HBHEMuon") << "[" << k1 << "] ieta " << act.ieta << " depth " << act.depth << " zside "
                                  << act.zside << " type " << act.stype << " phi " << act.iphis.size() << ":"
                                  << act.iphis[0] << " L " << act.thick;
     HcalDetId hcid1(HcalBarrel, (act.ieta) * (act.zside), act.iphis[0], act.depth);
     HcalDetId hcid2 = mergedDepth_ ? hdc_->mergedDepthDetId(hcid1) : hcid1;
     edm::LogVerbatim("HBHEMuon") << hcid1 << " | " << hcid2 << " L " << activeLength(DetId(hcid2));
     ++k1;
   }
   edm::LogVerbatim("HBHEMuon") << actHE.size() << " Active Length for HE";
   for (const auto& act : actHE) {
     edm::LogVerbatim("HBHEMuon") << "[" << k2 << "] ieta " << act.ieta << " depth " << act.depth << " zside "
                                  << act.zside << " type " << act.stype << " phi " << act.iphis.size() << ":"
                                  << act.iphis[0] << " L " << act.thick;
     HcalDetId hcid1(HcalEndcap, (act.ieta) * (act.zside), act.iphis[0], act.depth);
     HcalDetId hcid2 = mergedDepth_ ? hdc_->mergedDepthDetId(hcid1) : hcid1;
     edm::LogVerbatim("HBHEMuon") << hcid1 << " | " << hcid2 << " L " << activeLength(DetId(hcid2));
     ++k2;
   }
 #endif
 
   bool changed = true;
   bool flag = hltConfig_.init(iRun, iSetup, processName_, changed);
   edm::LogVerbatim("HBHEMuon") << "Run[" << nRun_ << "] " << iRun.run() << " hltconfig.init " << flag << std::endl;
 
   theHBHETopology_ = &iSetup.getData(tok_htopo_);
   respCorrs_ = &iSetup.getData(tok_respcorr_);
   geo_ = &iSetup.getData(tok_geom_);
 
   // Write correction factors for all HB/HE events
   if (writeRespCorr_) {
     const HcalGeometry* gHcal = static_cast<const HcalGeometry*>(geo_->getSubdetectorGeometry(DetId::Hcal, HcalBarrel));
     const std::vector<DetId>& ids = gHcal->getValidDetIds(DetId::Hcal, 0);
     edm::LogVerbatim("HBHEMuon") << "\nTable of Correction Factors for Run " << iRun.run() << "\n";
     for (auto const& id : ids) {
       if ((id.det() == DetId::Hcal) && ((id.subdetId() == HcalBarrel) || (id.subdetId() == HcalEndcap))) {
         edm::LogVerbatim("HBHEMuon") << HcalDetId(id) << " " << id.rawId() << " "
                                      << (respCorrs_->getValues(id))->getValue();
       }
     }
   }
 }

int AlCaHcalHBHEMuonProducer::depth16HE	(	int	ieta,
		int	iphi
	)

private

Definition at line 1103 of file AlCaHcalHBHEMuonProducer.cc.

References HcalTopology::dddConstants(), HLT_FULL_cff::depth, HcalDDDRecConstants::getMinDepth(), isItPlan1_, isItPreRecHit_, theHBHETopology_, and ecaldqm::zside().

Referenced by produce().

                                                           {
   // Transition between HB/HE is special
   // For Run 1 or for Plan1 standard reconstruction it is 3
   // For runs beyond 2018 or in Plan1 for HEP17 it is 4
   int zside = (ieta > 0) ? 1 : -1;
   int depth = theHBHETopology_->dddConstants()->getMinDepth(1, 16, iphi, zside);
   if (isItPlan1_ && (!isItPreRecHit_))
     depth = 3;
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HBHEMuon") << "Plan1 " << isItPlan1_ << " PreRecHit " << isItPreRecHit_ << " phi " << iphi
                                << " depth " << depth;
 #endif
   return depth;
 }

void AlCaHcalHBHEMuonProducer::endRun	(	edm::Run const &	iRun,
		edm::EventSetup const &
	)

overrideprivate

Definition at line 1022 of file AlCaHcalHBHEMuonProducer.cc.

References nRun_, and edm::RunBase::run().

                                                                               {
   edm::LogVerbatim("HBHEMuon") << "endRun[" << nRun_ << "] " << iRun.run() << "\n";
   ++nRun_;
 }

void AlCaHcalHBHEMuonProducer::endStream ( )

override

Definition at line 960 of file AlCaHcalHBHEMuonProducer.cc.

References nAll_, and nGood_.

                                          {
   globalCache()->nAll_ += nAll_;
   globalCache()->nGood_ += nGood_;
 }

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

static

Definition at line 937 of file AlCaHcalHBHEMuonProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
   edm::ParameterSetDescription desc;
   std::vector<std::string> triggers = {"HLT_IsoMu", "HLT_Mu"};
   desc.add<std::vector<std::string>>("triggers", triggers);
   desc.add<std::string>("processName", "HLT");
   desc.add<edm::InputTag>("triggerResults", edm::InputTag("TriggerResults", "", "HLT"));
   desc.add<edm::InputTag>("labelEBRecHit", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
   desc.add<edm::InputTag>("labelEERecHit", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
   desc.add<edm::InputTag>("labelHBHERecHit", edm::InputTag("hbhereco"));
   desc.add<std::string>("labelVertex", "offlinePrimaryVertices");
   desc.add<std::string>("labelMuon", "muons");
   desc.add<std::string>("labelHBHEMuon", "hbheMuon");
   desc.add<bool>("collapseDepth", false);
   desc.add<bool>("isItPlan1", false);
   desc.addUntracked<int>("verbosity", 0);
   desc.addUntracked<bool>("isItPreRecHit", false);
   desc.addUntracked<bool>("writeRespCorr", false);
   desc.addUntracked<std::string>("fileInCorr", "");
   desc.addUntracked<int>("maxDepth", 4);
   descriptions.add("alcaHcalHBHEMuonProducer", desc);
 }

double AlCaHcalHBHEMuonProducer::gainFactor	(	const HcalDbService *	dbserv,
		const HcalDetId &	id
	)

private

Definition at line 1095 of file AlCaHcalHBHEMuonProducer.cc.

References HcalDbService::getHcalCalibrations(), and HcalCalibrations::respcorrgain().

Referenced by produce().

                                                                                                 {
   double gain(0.0);
   const HcalCalibrations& calibs = conditions->getHcalCalibrations(id);
   for (int capid = 0; capid < 4; ++capid)
     gain += (0.25 * calibs.respcorrgain(capid));
   return gain;
 }

void AlCaHcalHBHEMuonProducer::globalEndJob ( const alcaHcalHBHEMuon::Counters * counters )

static

Definition at line 965 of file AlCaHcalHBHEMuonProducer.cc.

References alcaHcalHBHEMuon::Counters::nAll_, and alcaHcalHBHEMuon::Counters::nGood_.

                                                                                  {
   edm::LogVerbatim("HBHEMuon") << "Selects " << count->nGood_ << " out of " << count->nAll_ << " total # of events\n";
 }

bool AlCaHcalHBHEMuonProducer::goodCell	(	const HcalDetId &	hcid,
		const reco::Track *	pTrack,
		const CaloGeometry *	geo,
		const MagneticField *	bField
	)

private

Definition at line 1118 of file AlCaHcalHBHEMuonProducer.cc.

References HcalDDDRecConstants::getRZ(), HcalEndcap, hdc_, match(), spr::propagateHCAL(), HcalDetId::subdet(), and verbosity_.

Referenced by produce().

                                                                      {
   std::pair<double, double> rz = hdc_->getRZ(hcid);
   bool typeRZ = (hcid.subdet() == HcalEndcap) ? false : true;
   bool match = spr::propagateHCAL(pTrack, geo, bField, typeRZ, rz, (((verbosity_ / 10000) % 10) > 0));
   return match;
 }

static std::unique_ptr<alcaHcalHBHEMuon::Counters> AlCaHcalHBHEMuonProducer::initializeGlobalCache ( edm::ParameterSet const & )

inlinestatic

Definition at line 84 of file AlCaHcalHBHEMuonProducer.cc.

                                                                                                {
     return std::make_unique<alcaHcalHBHEMuon::Counters>();
   }

bool AlCaHcalHBHEMuonProducer::isGoodVertex ( const reco::Vertex & vtx )

private

Definition at line 1071 of file AlCaHcalHBHEMuonProducer.cc.

References reco::Vertex::isFake(), reco::Vertex::ndof(), and reco::Vertex::position().

Referenced by produce().

                                                                  {
   if (vtx.isFake())
     return false;
   if (vtx.ndof() < 4)
     return false;
   if (vtx.position().Rho() > 2.)
     return false;
   if (fabs(vtx.position().Z()) > 24.)
     return false;
   return true;
 }

int AlCaHcalHBHEMuonProducer::matchId	(	const HcalDetId &	id1,
		const HcalDetId &	id2
	)

private

Definition at line 1029 of file AlCaHcalHBHEMuonProducer.cc.

References HcalDetId::ieta(), HcalDetId::iphi(), match(), and HcalDetId::subdet().

Referenced by produce().

                                                                                 {
   HcalDetId kd1(id1.subdet(), id1.ieta(), id1.iphi(), 1);
   HcalDetId kd2(id1.subdet(), id2.ieta(), id2.iphi(), 1);
   int match = ((kd1 == kd2) ? 1 : 0);
   return match;
 }

void AlCaHcalHBHEMuonProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 232 of file AlCaHcalHBHEMuonProducer.cc.

                                                                                     {
   ++nAll_;
   auto outputHcalHBHEMuonColl = std::make_unique<HcalHBHEMuonVariablesCollection>();
 
   unsigned int runNumber = iEvent.id().run();
   unsigned int eventNumber = iEvent.id().event();
   unsigned int lumiNumber = iEvent.id().luminosityBlock();
   unsigned int bxNumber = iEvent.bunchCrossing();
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HBHEMuon") << "Run " << runNumber << " Event " << eventNumber << " Lumi " << lumiNumber << " BX "
                                << bxNumber << std::endl;
 #endif
 
   //Step1: Find if the event passes one of the chosen triggers
   bool ok(false);
   if (trigNames_.empty()) {
     ok = true;
   } else {
     auto const& triggerResults = iEvent.getHandle(tok_trigRes_);
     if (triggerResults.isValid()) {
       std::vector<std::string> modules;
       const edm::TriggerNames& triggerNames = iEvent.triggerNames(*triggerResults);
       const std::vector<std::string>& triggerNames_ = triggerNames.triggerNames();
       for (unsigned int iHLT = 0; iHLT < triggerResults->size(); iHLT++) {
         int hlt = triggerResults->accept(iHLT);
         for (unsigned int i = 0; i < trigNames_.size(); ++i) {
           if (triggerNames_[iHLT].find(trigNames_[i]) != std::string::npos) {
             if (hlt > 0) {
               ok = true;
             }
 #ifdef EDM_ML_DEBUG
             edm::LogVerbatim("HBHEMuon") << "AlCaHcalHBHEMuonFilter::Trigger " << triggerNames_[iHLT] << " Flag " << hlt
                                          << ":" << ok << std::endl;
 #endif
           }
         }
       }
     }
   }
 
   // get handles to calogeometry and calotopology
   const MagneticField* bField = &iSetup.getData(tok_magField_);
   const EcalChannelStatus* theEcalChStatus = &iSetup.getData(tok_chan_);
   const EcalSeverityLevelAlgo* sevlv = &iSetup.getData(tok_sevlv_);
   const CaloTopology* caloTopology = &iSetup.getData(tok_topo_);
   const HcalDbService* conditions = &iSetup.getData(tok_dbservice_);
 
   // Relevant blocks from iEvent
   auto const& vtx = iEvent.getHandle(tok_Vtx_);
   auto barrelRecHitsHandle = iEvent.getHandle(tok_EB_);
   auto endcapRecHitsHandle = iEvent.getHandle(tok_EE_);
   auto hbhe = iEvent.getHandle(tok_HBHE_);
   auto const& muons = iEvent.getHandle(tok_Muon_);
 
   // require a good vertex
   math::XYZPoint pvx;
   unsigned int goodVertex = 0;
   reco::VertexCollection::const_iterator firstGoodVertex;
   if (!vtx.isValid()) {
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HBHEMuon") << "No Good Vertex found == Reject";
 #endif
   } else {
     firstGoodVertex = vtx->end();
     for (reco::VertexCollection::const_iterator it = vtx->begin(); it != vtx->end(); it++) {
       if (isGoodVertex(*it)) {
         if (firstGoodVertex == vtx->end())
           firstGoodVertex = it;
         ++goodVertex;
       }
     }
     if (firstGoodVertex != vtx->end())
       pvx = firstGoodVertex->position();
   }
 
   if (ok && (goodVertex > 0) && muons.isValid() && barrelRecHitsHandle.isValid() && endcapRecHitsHandle.isValid() &&
       hbhe.isValid()) {
     for (reco::MuonCollection::const_iterator recMuon = muons->begin(); recMuon != muons->end(); ++recMuon) {
       HcalHBHEMuonVariables hbheMuon;
       hbheMuon.runNumber_ = runNumber;
       hbheMuon.eventNumber_ = eventNumber;
       hbheMuon.lumiNumber_ = lumiNumber;
       hbheMuon.bxNumber_ = bxNumber;
       hbheMuon.goodVertex_ = goodVertex;
       hbheMuon.muonGood_ = (recMuon->isPFMuon());
       hbheMuon.muonGlobal_ = (recMuon->isGlobalMuon());
       hbheMuon.muonTracker_ = (recMuon->isTrackerMuon());
       hbheMuon.ptGlob_ = ((recMuon)->pt());
       hbheMuon.etaGlob_ = (recMuon->eta());
       hbheMuon.phiGlob_ = (recMuon->phi());
       hbheMuon.energyMuon_ = (recMuon->energy());
       hbheMuon.pMuon_ = (recMuon->p());
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HBHEMuon") << "Energy:" << recMuon->energy() << " P:" << recMuon->p();
 #endif
       hbheMuon.muonTight_ = (muon::isTightMuon(*recMuon, *firstGoodVertex));
       hbheMuon.muonMedium_ = (muon::isMediumMuon(*recMuon));
       hbheMuon.muonTrkKink_ = (recMuon->combinedQuality().trkKink);
       hbheMuon.muonChi2LocalPosition_ = (recMuon->combinedQuality().chi2LocalPosition);
       hbheMuon.muonSegComp_ = (muon::segmentCompatibility(*recMuon));
       // acessing tracker hits info
       if (recMuon->track().isNonnull()) {
         hbheMuon.trackerLayer_ = (recMuon->track()->hitPattern().trackerLayersWithMeasurement());
       } else {
         hbheMuon.trackerLayer_ = -1;
       }
       if (recMuon->innerTrack().isNonnull()) {
         hbheMuon.innerTrack_ = true;
         hbheMuon.numPixelLayers_ = (recMuon->innerTrack()->hitPattern().pixelLayersWithMeasurement());
         hbheMuon.chiTracker_ = (recMuon->innerTrack()->normalizedChi2());
         hbheMuon.dxyTracker_ = (fabs(recMuon->innerTrack()->dxy(pvx)));
         hbheMuon.dzTracker_ = (fabs(recMuon->innerTrack()->dz(pvx)));
         hbheMuon.innerTrackPt_ = (recMuon->innerTrack()->pt());
         hbheMuon.innerTrackEta_ = (recMuon->innerTrack()->eta());
         hbheMuon.innerTrackPhi_ = (recMuon->innerTrack()->phi());
         hbheMuon.tightPixelHits_ = (recMuon->innerTrack()->hitPattern().numberOfValidPixelHits());
         hbheMuon.tightValidFraction_ = (recMuon->innerTrack()->validFraction());
       }
       // outer track info
       if (recMuon->outerTrack().isNonnull()) {
         hbheMuon.outerTrack_ = true;
         hbheMuon.outerTrackPt_ = (recMuon->outerTrack()->pt());
         hbheMuon.outerTrackEta_ = (recMuon->outerTrack()->eta());
         hbheMuon.outerTrackPhi_ = (recMuon->outerTrack()->phi());
         hbheMuon.outerTrackChi_ = (recMuon->outerTrack()->normalizedChi2());
         hbheMuon.outerTrackHits_ = (recMuon->outerTrack()->numberOfValidHits());
         hbheMuon.outerTrackRHits_ = (recMuon->outerTrack()->recHitsSize());
       }
       // Tight Muon cuts
       if (recMuon->globalTrack().isNonnull()) {
         hbheMuon.globalTrack_ = true;
         hbheMuon.chiGlobal_ = (recMuon->globalTrack()->normalizedChi2());
         hbheMuon.globalMuonHits_ = (recMuon->globalTrack()->hitPattern().numberOfValidMuonHits());
         hbheMuon.matchedStat_ = (recMuon->numberOfMatchedStations());
         hbheMuon.globalTrackPt_ = (recMuon->globalTrack()->pt());
         hbheMuon.globalTrackEta_ = (recMuon->globalTrack()->eta());
         hbheMuon.globalTrackPhi_ = (recMuon->globalTrack()->phi());
         hbheMuon.tightTransImpara_ = (fabs(recMuon->muonBestTrack()->dxy(pvx)));
         hbheMuon.tightLongPara_ = (fabs(recMuon->muonBestTrack()->dz(pvx)));
       }
 
       hbheMuon.isolationR04_ =
           ((recMuon->pfIsolationR04().sumChargedHadronPt +
             std::max(0.,
                      recMuon->pfIsolationR04().sumNeutralHadronEt + recMuon->pfIsolationR04().sumPhotonEt -
                          (0.5 * recMuon->pfIsolationR04().sumPUPt))) /
            recMuon->pt());
 
       hbheMuon.isolationR03_ =
           ((recMuon->pfIsolationR03().sumChargedHadronPt +
             std::max(0.,
                      recMuon->pfIsolationR03().sumNeutralHadronEt + recMuon->pfIsolationR03().sumPhotonEt -
                          (0.5 * recMuon->pfIsolationR03().sumPUPt))) /
            recMuon->pt());
 
       hbheMuon.ecalEnergy_ = (recMuon->calEnergy().emS9);
       hbheMuon.hcalEnergy_ = (recMuon->calEnergy().hadS9);
       hbheMuon.hoEnergy_ = (recMuon->calEnergy().hoS9);
 
       if (recMuon->innerTrack().isNonnull()) {
         const reco::Track* pTrack = (recMuon->innerTrack()).get();
         spr::propagatedTrackID trackID = spr::propagateCALO(pTrack, geo_, bField, (((verbosity_ / 100) % 10 > 0)));
 
         double activeLengthTot(0), activeLengthHotTot(0);
         double eHcalDepth[depthMax_], eHcalDepthHot[depthMax_];
         double eHcalDepthC[depthMax_], eHcalDepthHotC[depthMax_];
         double cHcalDepthHot[depthMax_], cHcalDepthHotBG[depthMax_];
         double eHcalDepthRaw[depthMax_], eHcalDepthHotRaw[depthMax_];
         double eHcalDepthCRaw[depthMax_], eHcalDepthHotCRaw[depthMax_];
         double cHcalDepthHotRaw[depthMax_], cHcalDepthHotBGRaw[depthMax_];
         double eHcalDepthAux[depthMax_], eHcalDepthHotAux[depthMax_];
         double eHcalDepthCAux[depthMax_], eHcalDepthHotCAux[depthMax_];
         double cHcalDepthHotAux[depthMax_], cHcalDepthHotBGAux[depthMax_];
         double activeL[depthMax_], activeHotL[depthMax_];
         bool matchDepth[depthMax_], matchDepthHot[depthMax_];
         HcalDetId eHcalDetId[depthMax_];
         unsigned int isHot(0);
         int ieta(-1000), iphi(-1000);
         for (int i = 0; i < depthMax_; ++i) {
           eHcalDepth[i] = eHcalDepthHot[i] = 0;
           eHcalDepthC[i] = eHcalDepthHotC[i] = 0;
           cHcalDepthHot[i] = cHcalDepthHotBG[i] = 0;
           eHcalDepthRaw[i] = eHcalDepthHotRaw[i] = 0;
           eHcalDepthCRaw[i] = eHcalDepthHotCRaw[i] = 0;
           cHcalDepthHotRaw[i] = cHcalDepthHotBGRaw[i] = 0;
           eHcalDepthAux[i] = eHcalDepthHotAux[i] = 0;
           eHcalDepthCAux[i] = eHcalDepthHotCAux[i] = 0;
           cHcalDepthHotAux[i] = cHcalDepthHotBGAux[i] = 0;
           activeL[i] = activeHotL[i] = 0;
           matchDepth[i] = matchDepthHot[i] = true;
         }
 #ifdef EDM_ML_DEBUG
         double eHcal(0);
 #endif
 
         hbheMuon.ecalDetId_ = ((trackID.detIdECAL)());
         hbheMuon.hcalDetId_ = ((trackID.detIdHCAL)());
         hbheMuon.ehcalDetId_ = ((trackID.detIdEHCAL)());
 
         HcalDetId check(false);
         std::pair<bool, HcalDetId> info = spr::propagateHCALBack(pTrack, geo_, bField, (((verbosity_ / 100) % 10 > 0)));
         if (info.first) {
           check = info.second;
         }
 
         bool okE = trackID.okECAL;
         if (okE) {
           const DetId isoCell(trackID.detIdECAL);
           std::pair<double, bool> e3x3 = spr::eECALmatrix(isoCell,
                                                           barrelRecHitsHandle,
                                                           endcapRecHitsHandle,
                                                           *theEcalChStatus,
                                                           geo_,
                                                           caloTopology,
                                                           sevlv,
                                                           1,
                                                           1,
                                                           -100.0,
                                                           -100.0,
                                                           -500.0,
                                                           500.0,
                                                           false);
           hbheMuon.ecal3x3Energy_ = e3x3.first;
           okE = e3x3.second;
         }
 #ifdef EDM_ML_DEBUG
         edm::LogVerbatim("HBHEMuon") << "Propagate Track to ECAL: " << okE << ":" << trackID.okECAL << " E "
                                      << hbheMuon.ecal3x3Energy_;
 #endif
 
         if (trackID.okHCAL) {
           DetId closestCell(trackID.detIdHCAL);
           HcalDetId hcidt(closestCell.rawId());
           if ((hcidt.ieta() == check.ieta()) && (hcidt.iphi() == check.iphi()))
             hbheMuon.matchedId_ = true;
 #ifdef EDM_ML_DEBUG
           edm::LogVerbatim("HBHEMuon") << "Front " << hcidt << " Back " << info.first << ":" << check << " Match "
                                        << hbheMuon.matchedId_;
 #endif
           HcalSubdetector subdet = hcidt.subdet();
           ieta = hcidt.ieta();
           iphi = hcidt.iphi();
           bool hborhe = (std::abs(ieta) == 16);
 
           hbheMuon.hcal1x1Energy_ = spr::eHCALmatrix(
               theHBHETopology_, closestCell, hbhe, 0, 0, false, true, -100.0, -100.0, -100.0, -100.0, -500., 500., 0);
           hbheMuon.hcal1x1EnergyAux_ = spr::eHCALmatrix(
               theHBHETopology_, closestCell, hbhe, 0, 0, false, true, -100.0, -100.0, -100.0, -100.0, -500., 500., 1);
           hbheMuon.hcal1x1EnergyRaw_ = spr::eHCALmatrix(
               theHBHETopology_, closestCell, hbhe, 0, 0, false, true, -100.0, -100.0, -100.0, -100.0, -500., 500., 2);
           std::vector<std::pair<double, int>> ehdepth, ehdepthAux, ehdepthRaw;
           spr::energyHCALCell((HcalDetId)closestCell,
                               hbhe,
                               ehdepth,
                               maxDepth_,
                               -100.0,
                               -100.0,
                               -100.0,
                               -100.0,
                               -500.0,
                               500.0,
                               0,
                               depth16HE(ieta, iphi),
                               (((verbosity_ / 1000) % 10) > 0));
           for (int i = 0; i < depthMax_; ++i)
             eHcalDetId[i] = HcalDetId();
           spr::energyHCALCell((HcalDetId)closestCell,
                               hbhe,
                               ehdepthAux,
                               maxDepth_,
                               -100.0,
                               -100.0,
                               -100.0,
                               -100.0,
                               -500.0,
                               500.0,
                               1,
                               depth16HE(ieta, iphi),
                               (((verbosity_ / 1000) % 10) > 0));
           spr::energyHCALCell((HcalDetId)closestCell,
                               hbhe,
                               ehdepthRaw,
                               maxDepth_,
                               -100.0,
                               -100.0,
                               -100.0,
                               -100.0,
                               -500.0,
                               500.0,
                               2,
                               depth16HE(ieta, iphi),
                               (((verbosity_ / 1000) % 10) > 0));
           for (unsigned int i = 0; i < ehdepth.size(); ++i) {
             HcalSubdetector subdet0 =
                 (hborhe) ? ((ehdepth[i].second >= depth16HE(ieta, iphi)) ? HcalEndcap : HcalBarrel) : subdet;
             HcalDetId hcid0(subdet0, ieta, iphi, ehdepth[i].second);
             double actL = activeLength(DetId(hcid0));
             double ene = ehdepth[i].first;
             double eneAux = ehdepthAux[i].first;
             double eneRaw = ehdepthRaw[i].first;
             bool tmpC(false);
             if (ene > 0.0) {
               if (!(theHBHETopology_->validHcal(hcid0))) {
                 edm::LogWarning("HBHEMuon") << "(1) Invalid ID " << hcid0 << " with E = " << ene;
                 edm::LogWarning("HBHEMuon") << HcalDetId(closestCell) << " with " << ehdepth.size() << " depths:";
                 for (const auto& ehd : ehdepth)
                   edm::LogWarning("HBHEMuon") << " " << ehd.second << ":" << ehd.first;
               } else {
                 tmpC = goodCell(hcid0, pTrack, geo_, bField);
                 double enec(ene);
                 double corr = respCorr(DetId(hcid0));
                 if (corr != 0)
                   ene /= corr;
 #ifdef EDM_ML_DEBUG
                 HcalDetId id = (isItPlan1_ && isItPreRecHit_) ? hdc_->mergedDepthDetId(hcid0) : hcid0;
                 edm::LogVerbatim("HBHEMuon") << hcid0 << ":" << id << " Corr " << corr;
 #endif
                 int depth = ehdepth[i].second - 1;
                 if (collapseDepth_) {
                   HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                   depth = id.depth() - 1;
                 }
                 eHcalDepth[depth] += ene;
                 eHcalDepthC[depth] += enec;
                 activeL[depth] += actL;
                 activeLengthTot += actL;
                 matchDepth[depth] = (matchDepth[depth] && tmpC);
 #ifdef EDM_ML_DEBUG
                 if ((verbosity_ % 10) > 0)
                   edm::LogVerbatim("HBHEMuon")
                       << hcid0 << " E " << ene << ":" << enec << " L " << actL << " Match " << tmpC;
 #endif
               }
             }
             if (eneAux > 0.0) {
               if (theHBHETopology_->validHcal(hcid0)) {
                 double enecAux(eneAux);
                 double corr = respCorr(DetId(hcid0));
                 if (corr != 0)
                   eneAux /= corr;
                 int depth = ehdepthAux[i].second - 1;
                 if (collapseDepth_) {
                   HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                   depth = id.depth() - 1;
                 }
                 eHcalDepthAux[depth] += eneAux;
                 eHcalDepthCAux[depth] += enecAux;
 #ifdef EDM_ML_DEBUG
                 if ((verbosity_ % 10) > 0)
                   edm::LogVerbatim("HBHEMuon")
                       << hcid0 << " E " << eneAux << ":" << enecAux << " L " << actL << " Match " << tmpC;
 #endif
               }
             }
             if (eneRaw > 0.0) {
               if (theHBHETopology_->validHcal(hcid0)) {
                 double enecRaw(eneRaw);
                 double corr = respCorr(DetId(hcid0));
                 if (corr != 0)
                   eneRaw /= corr;
                 int depth = ehdepthRaw[i].second - 1;
                 if (collapseDepth_) {
                   HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                   depth = id.depth() - 1;
                 }
                 eHcalDepthRaw[depth] += eneRaw;
                 eHcalDepthCRaw[depth] += enecRaw;
 #ifdef EDM_ML_DEBUG
                 if ((verbosity_ % 10) > 0)
                   edm::LogVerbatim("HBHEMuon")
                       << hcid0 << " E " << eneRaw << ":" << enecRaw << " L " << actL << " Match " << tmpC;
 #endif
               }
             }
           }
 #ifdef EDM_ML_DEBUG
           if ((verbosity_ % 10) > 0) {
             edm::LogVerbatim("HBHEMuon") << hcidt << " Match " << hbheMuon.matchedId_ << " Depths " << ehdepth.size();
             for (unsigned int k = 0; k < ehdepth.size(); ++k)
               edm::LogVerbatim("HBHEMuon") << " [" << k << ":" << ehdepth[k].second << "] " << matchDepth[k];
           }
 #endif
           HcalDetId hotCell;
           spr::eHCALmatrix(geo_, theHBHETopology_, closestCell, hbhe, 1, 1, hotCell, false, 0, false);
           isHot = matchId(closestCell, hotCell);
           if (hotCell != HcalDetId()) {
             subdet = HcalDetId(hotCell).subdet();
             ieta = HcalDetId(hotCell).ieta();
             iphi = HcalDetId(hotCell).iphi();
             hborhe = (std::abs(ieta) == 16);
             std::vector<std::pair<double, int>> ehdepth, ehdepthAux, ehdepthRaw;
             spr::energyHCALCell(hotCell,
                                 hbhe,
                                 ehdepth,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 0,
                                 depth16HE(ieta, iphi),
                                 false);
             spr::energyHCALCell(hotCell,
                                 hbhe,
                                 ehdepthAux,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 1,
                                 depth16HE(ieta, iphi),
                                 false);
             spr::energyHCALCell(hotCell,
                                 hbhe,
                                 ehdepthRaw,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 2,
                                 depth16HE(ieta, iphi),
                                 false);
             for (int i = 0; i < depthMax_; ++i)
               eHcalDetId[i] = HcalDetId();
             for (unsigned int i = 0; i < ehdepth.size(); ++i) {
               HcalSubdetector subdet0 =
                   (hborhe) ? ((ehdepth[i].second >= depth16HE(ieta, iphi)) ? HcalEndcap : HcalBarrel) : subdet;
               HcalDetId hcid0(subdet0, ieta, iphi, ehdepth[i].second);
               double actL = activeLength(DetId(hcid0));
               double ene = ehdepth[i].first;
               bool tmpC(false);
               if (ene > 0.0) {
                 if (!(theHBHETopology_->validHcal(hcid0))) {
                   edm::LogWarning("HBHEMuon") << "(2) Invalid ID " << hcid0 << " with E = " << ene;
                   edm::LogWarning("HBHEMuon") << HcalDetId(hotCell) << " with " << ehdepth.size() << " depths:";
                   for (const auto& ehd : ehdepth)
                     edm::LogWarning("HBHEMuon") << " " << ehd.second << ":" << ehd.first;
                 } else {
                   tmpC = goodCell(hcid0, pTrack, geo_, bField);
                   double chg(ene), enec(ene);
                   double corr = respCorr(DetId(hcid0));
                   if (corr != 0)
                     ene /= corr;
 #ifdef EDM_ML_DEBUG
                   HcalDetId id = (isItPlan1_ && isItPreRecHit_) ? hdc_->mergedDepthDetId(hcid0) : hcid0;
                   edm::LogVerbatim("HBHEMuon") << hcid0 << ":" << id << " Corr " << corr << " E " << ene << ":" << enec;
 #endif
                   double gain = gainFactor(conditions, hcid0);
                   if (gain != 0)
                     chg /= gain;
 #ifdef EDM_ML_DEBUG
                   edm::LogVerbatim("HBHEMuon") << hcid0 << " Gain " << gain << " C " << chg;
 #endif
                   int depth = ehdepth[i].second - 1;
                   if (collapseDepth_) {
                     HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                     depth = id.depth() - 1;
                   }
                   eHcalDepthHot[depth] += ene;
                   eHcalDepthHotC[depth] += enec;
                   cHcalDepthHot[depth] += chg;
                   activeHotL[depth] += actL;
                   activeLengthHotTot += actL;
                   matchDepthHot[depth] = (matchDepthHot[depth] && tmpC);
 #ifdef EDM_ML_DEBUG
                   eHcal += ene;
                   if ((verbosity_ % 10) > 0)
                     edm::LogVerbatim("HBHEMuon") << hcid0 << " depth " << depth << " E " << ene << ":" << enec << " C "
                                                  << chg << " L " << actL << " Match " << tmpC;
 #endif
                 }
               }
               double eneAux = ehdepthAux[i].first;
               if (eneAux > 0.0) {
                 if (theHBHETopology_->validHcal(hcid0)) {
                   double chgAux(eneAux), enecAux(eneAux);
                   double corr = respCorr(DetId(hcid0));
                   if (corr != 0)
                     eneAux /= corr;
                   double gain = gainFactor(conditions, hcid0);
                   if (gain != 0)
                     chgAux /= gain;
                   int depth = ehdepthAux[i].second - 1;
                   if (collapseDepth_) {
                     HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                     depth = id.depth() - 1;
                   }
                   eHcalDepthHotAux[depth] += eneAux;
                   eHcalDepthHotCAux[depth] += enecAux;
                   cHcalDepthHotAux[depth] += chgAux;
 #ifdef EDM_ML_DEBUG
                   if ((verbosity_ % 10) > 0)
                     edm::LogVerbatim("HBHEMuon") << hcid0 << " depth " << depth << " E " << eneAux << ":" << enecAux
                                                  << " C " << chgAux << " L " << actL << " Match " << tmpC;
 #endif
                 }
               }
               double eneRaw = ehdepthRaw[i].first;
               if (eneRaw > 0.0) {
                 if (theHBHETopology_->validHcal(hcid0)) {
                   double chgRaw(eneRaw), enecRaw(eneRaw);
                   double corr = respCorr(DetId(hcid0));
                   if (corr != 0)
                     eneRaw /= corr;
                   double gain = gainFactor(conditions, hcid0);
                   if (gain != 0)
                     chgRaw /= gain;
                   int depth = ehdepthRaw[i].second - 1;
                   if (collapseDepth_) {
                     HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                     depth = id.depth() - 1;
                   }
                   eHcalDepthHotRaw[depth] += eneRaw;
                   eHcalDepthHotCRaw[depth] += enecRaw;
                   cHcalDepthHotRaw[depth] += chgRaw;
 #ifdef EDM_ML_DEBUG
                   if ((verbosity_ % 10) > 0)
                     edm::LogVerbatim("HBHEMuon") << hcid0 << " depth " << depth << " E " << eneRaw << ":" << enecRaw
                                                  << " C " << chgRaw << " L " << actL << " Match " << tmpC;
 #endif
                 }
               }
             }
 
             HcalDetId oppCell(subdet, -ieta, iphi, HcalDetId(hotCell).depth());
             std::vector<std::pair<double, int>> ehdeptho, ehdepthoAux, ehdepthoRaw;
             spr::energyHCALCell(oppCell,
                                 hbhe,
                                 ehdeptho,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 0,
                                 depth16HE(-ieta, iphi),
                                 false);
             spr::energyHCALCell(oppCell,
                                 hbhe,
                                 ehdepthoAux,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 1,
                                 depth16HE(-ieta, iphi),
                                 false);
             spr::energyHCALCell(oppCell,
                                 hbhe,
                                 ehdepthoRaw,
                                 maxDepth_,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -100.0,
                                 -500.0,
                                 500.0,
                                 2,
                                 depth16HE(-ieta, iphi),
                                 false);
             for (unsigned int i = 0; i < ehdeptho.size(); ++i) {
               HcalSubdetector subdet0 =
                   (hborhe) ? ((ehdeptho[i].second >= depth16HE(-ieta, iphi)) ? HcalEndcap : HcalBarrel) : subdet;
               HcalDetId hcid0(subdet0, -ieta, iphi, ehdeptho[i].second);
               double ene = ehdeptho[i].first;
               if (ene > 0.0) {
                 if (!(theHBHETopology_->validHcal(hcid0))) {
                   edm::LogWarning("HBHEMuon") << "(3) Invalid ID " << hcid0 << " with E = " << ene;
                   edm::LogWarning("HBHEMuon") << oppCell << " with " << ehdeptho.size() << " depths:";
                   for (const auto& ehd : ehdeptho)
                     edm::LogWarning("HBHEMuon") << " " << ehd.second << ":" << ehd.first;
                 } else {
                   double chg(ene);
                   double corr = respCorr(DetId(hcid0));
                   if (corr != 0)
                     ene /= corr;
 #ifdef EDM_ML_DEBUG
                   HcalDetId id = (isItPlan1_ && isItPreRecHit_) ? hdc_->mergedDepthDetId(hcid0) : hcid0;
                   edm::LogVerbatim("HBHEMuon")
                       << hcid0 << ":" << id << " Corr " << corr << " E " << ene << ":" << ehdeptho[i].first;
 #endif
                   double gain = gainFactor(conditions, hcid0);
                   if (gain != 0)
                     chg /= gain;
 #ifdef EDM_ML_DEBUG
                   edm::LogVerbatim("HBHEMuon") << hcid0 << " Gain " << gain << " C " << chg;
 #endif
                   int depth = ehdeptho[i].second - 1;
                   if (collapseDepth_) {
                     HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                     depth = id.depth() - 1;
                   }
                   cHcalDepthHotBG[depth] += chg;
 #ifdef EDM_ML_DEBUG
                   if ((verbosity_ % 10) > 0)
                     edm::LogVerbatim("HBHEMuon") << hcid0 << " Depth " << depth << " E " << ene << " C " << chg;
 #endif
                 }
               }
               double eneAux = ehdepthoAux[i].first;
               if (eneAux > 0.0) {
                 if (theHBHETopology_->validHcal(hcid0)) {
                   double chgAux(eneAux);
                   double corr = respCorr(DetId(hcid0));
                   if (corr != 0)
                     eneAux /= corr;
                   double gain = gainFactor(conditions, hcid0);
                   if (gain != 0)
                     chgAux /= gain;
                   int depth = ehdepthoAux[i].second - 1;
                   if (collapseDepth_) {
                     HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                     depth = id.depth() - 1;
                   }
                   cHcalDepthHotBGAux[depth] += chgAux;
 #ifdef EDM_ML_DEBUG
                   if ((verbosity_ % 10) > 0)
                     edm::LogVerbatim("HBHEMuon") << hcid0 << " Depth " << depth << " E " << eneAux << " C " << chgAux;
 #endif
                 }
               }
               double eneRaw = ehdepthoRaw[i].first;
               if (eneRaw > 0.0) {
                 if (theHBHETopology_->validHcal(hcid0)) {
                   double chgRaw(eneRaw);
                   double corr = respCorr(DetId(hcid0));
                   if (corr != 0)
                     eneRaw /= corr;
                   double gain = gainFactor(conditions, hcid0);
                   if (gain != 0)
                     chgRaw /= gain;
                   int depth = ehdepthoRaw[i].second - 1;
                   if (collapseDepth_) {
                     HcalDetId id = hdc_->mergedDepthDetId(hcid0);
                     depth = id.depth() - 1;
                   }
                   cHcalDepthHotBGRaw[depth] += chgRaw;
 #ifdef EDM_ML_DEBUG
                   if ((verbosity_ % 10) > 0)
                     edm::LogVerbatim("HBHEMuon") << hcid0 << " Depth " << depth << " E " << eneRaw << " C " << chgRaw;
 #endif
                 }
               }
             }
           }
         }
 #ifdef EDM_ML_DEBUG
         edm::LogVerbatim("HBHEMuon") << "Propagate Track to HCAL: " << trackID.okHCAL << " Match "
                                      << hbheMuon.matchedId_ << " Hot " << isHot << " Energy " << eHcal;
 #endif
         hbheMuon.hcalIeta_ = ieta;
         hbheMuon.hcalIphi_ = iphi;
         for (int i = 0; i < depthMax_; ++i) {
           hbheMuon.hcalDepthEnergy_.push_back(eHcalDepth[i]);
           hbheMuon.hcalDepthActiveLength_.push_back(activeL[i]);
           hbheMuon.hcalDepthEnergyHot_.push_back(eHcalDepthHot[i]);
           hbheMuon.hcalDepthActiveLengthHot_.push_back(activeHotL[i]);
           hbheMuon.hcalDepthEnergyCorr_.push_back(eHcalDepthC[i]);
           hbheMuon.hcalDepthEnergyHotCorr_.push_back(eHcalDepthHotC[i]);
           hbheMuon.hcalDepthChargeHot_.push_back(cHcalDepthHot[i]);
           hbheMuon.hcalDepthChargeHotBG_.push_back(cHcalDepthHotBG[i]);
           hbheMuon.hcalDepthMatch_.push_back(matchDepth[i]);
           hbheMuon.hcalDepthMatchHot_.push_back(matchDepthHot[i]);
           hbheMuon.hcalDepthEnergyAux_.push_back(eHcalDepthAux[i]);
           hbheMuon.hcalDepthEnergyHotAux_.push_back(eHcalDepthHotAux[i]);
           hbheMuon.hcalDepthEnergyCorrAux_.push_back(eHcalDepthCAux[i]);
           hbheMuon.hcalDepthEnergyHotCorrAux_.push_back(eHcalDepthHotCAux[i]);
           hbheMuon.hcalDepthChargeHotAux_.push_back(cHcalDepthHotAux[i]);
           hbheMuon.hcalDepthChargeHotBGAux_.push_back(cHcalDepthHotBGAux[i]);
           hbheMuon.hcalDepthEnergyRaw_.push_back(eHcalDepthRaw[i]);
           hbheMuon.hcalDepthEnergyHotRaw_.push_back(eHcalDepthHotRaw[i]);
           hbheMuon.hcalDepthEnergyCorrRaw_.push_back(eHcalDepthCRaw[i]);
           hbheMuon.hcalDepthEnergyHotCorrRaw_.push_back(eHcalDepthHotCRaw[i]);
           hbheMuon.hcalDepthChargeHotRaw_.push_back(cHcalDepthHotRaw[i]);
           hbheMuon.hcalDepthChargeHotBGRaw_.push_back(cHcalDepthHotBGRaw[i]);
         }
         hbheMuon.hcalActiveLength_ = activeLengthTot;
         hbheMuon.hcalHot_ = isHot;
         hbheMuon.hcalActiveLengthHot_ = activeLengthHotTot;
 
         if ((recMuon->p() > 10.0) && (trackID.okHCAL))
           outputHcalHBHEMuonColl->emplace_back(hbheMuon);
       }
     }
   }
   if (!outputHcalHBHEMuonColl->empty())
     ++nGood_;
   iEvent.put(std::move(outputHcalHBHEMuonColl), labelHBHEMuon_);
 }

double AlCaHcalHBHEMuonProducer::respCorr ( const DetId & id )

private

Definition at line 1083 of file AlCaHcalHBHEMuonProducer.cc.

References corrValue_, reco::JetExtendedAssociation::getValue(), HcalCondObjectContainer< Item >::getValues(), respCorrs_, and useMyCorr_.

Referenced by produce().

                                                          {
   double cfac(1.0);
   if (useMyCorr_) {
     auto itr = corrValue_.find(id);
     if (itr != corrValue_.end())
       cfac = itr->second;
   } else if (respCorrs_ != nullptr) {
     cfac = (respCorrs_->getValues(id))->getValue();
   }
   return cfac;
 }