#include <CalibCalorimetry/CaloRecalibTools.src/HcalRecHitRecalib.cc>

Inheritance diagram for HcalRecHitRecalib:

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

	HcalRecHitRecalib (const edm::ParameterSet &)

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

	~HcalRecHitRecalib () override

Public Member Functions inherited from edm::stream::EDProducer<>
	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

Private Attributes
std::string	hcalfile_

const std::string	hcalfileinpath_

CaloMiscalibMapHcal	mapHcal_

const std::string	recalibHBHEHits_

const std::string	recalibHFHits_

const std::string	recalibHOHits_

const double	refactor_

const double	refactor_mean_

const edm::EDGetTokenT< HBHERecHitCollection >	tok_hbhe_

const edm::EDGetTokenT< HFRecHitCollection >	tok_hf_

const edm::EDGetTokenT< HORecHitCollection >	tok_ho_

const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	topologyToken_

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

Description: Producer to miscalibrate (calibrated) Hcal RecHit

Implementation: <Notes on="" implementation>="">

Definition at line 37 of file HcalRecHitRecalib.h.

Constructor & Destructor Documentation

◆ HcalRecHitRecalib()

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

explicit

Definition at line 10 of file HcalRecHitRecalib.cc.

References hcalfile_, hcalfileinpath_, recalibHBHEHits_, recalibHFHits_, and recalibHOHits_.

     : tok_hbhe_(consumes<HBHERecHitCollection>(iConfig.getParameter<edm::InputTag>("hbheInput"))),
       tok_ho_(consumes<HORecHitCollection>(iConfig.getParameter<edm::InputTag>("hoInput"))),
       tok_hf_(consumes<HFRecHitCollection>(iConfig.getParameter<edm::InputTag>("hfInput"))),
       topologyToken_(esConsumes<edm::Transition::BeginRun>()),
       recalibHBHEHits_(iConfig.getParameter<std::string>("RecalibHBHEHitCollection")),
       recalibHFHits_(iConfig.getParameter<std::string>("RecalibHFHitCollection")),
       recalibHOHits_(iConfig.getParameter<std::string>("RecalibHOHitCollection")),
       hcalfileinpath_(iConfig.getUntrackedParameter<std::string>("fileNameHcal", "")),
       refactor_(iConfig.getUntrackedParameter<double>("Refactor", (double)1)),
       refactor_mean_(iConfig.getUntrackedParameter<double>("Refactor_mean", (double)1)) {
   //register your products
   produces<HBHERecHitCollection>(recalibHBHEHits_);
   produces<HFRecHitCollection>(recalibHFHits_);
   produces<HORecHitCollection>(recalibHOHits_);
 
   // here read them from xml (particular to HCAL)
   edm::FileInPath hcalfiletmp("CalibCalorimetry/CaloMiscalibTools/data/" + hcalfileinpath_);
   hcalfile_ = hcalfiletmp.fullPath();
 }

◆ ~HcalRecHitRecalib()

HcalRecHitRecalib::~HcalRecHitRecalib ( )

override

Definition at line 31 of file HcalRecHitRecalib.cc.

31 {}

Member Function Documentation

◆ beginRun()

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

override

Definition at line 33 of file HcalRecHitRecalib.cc.

References edm::EventSetup::getData(), hcalfile_, mapHcal_, MiscalibReaderFromXML::parseXMLMiscalibFile(), CaloMiscalibMapHcal::prefillMap(), CaloMiscalibMapHcal::print(), HLT_2024v14_cff::topology, and topologyToken_.

                                                                            {
   const HcalTopology& topology = iSetup.getData(topologyToken_);
 
   mapHcal_.prefillMap(topology);
 
   MiscalibReaderFromXMLHcal hcalreader_(mapHcal_);
   if (!hcalfile_.empty())
     hcalreader_.parseXMLMiscalibFile(hcalfile_);
   mapHcal_.print();
 }

◆ produce()

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

override

Definition at line 45 of file HcalRecHitRecalib.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), CaloMiscalibMapHcal::get(), egHLT::errCodes::HBHERecHits, egHLT::errCodes::HFRecHits, iEvent, edm::HandleBase::isValid(), LogDebug, mapHcal_, eostools::move(), edm::Handle< T >::product(), recalibHBHEHits_, recalibHFHits_, recalibHOHits_, refactor_, refactor_mean_, tok_hbhe_, tok_hf_, and tok_ho_.

                                                                              {
   using namespace edm;
   using namespace std;
 
   Handle<HBHERecHitCollection> HBHERecHitsHandle;
   Handle<HFRecHitCollection> HFRecHitsHandle;
   Handle<HORecHitCollection> HORecHitsHandle;
 
   const HBHERecHitCollection* HBHERecHits = nullptr;
   const HFRecHitCollection* HFRecHits = nullptr;
   const HORecHitCollection* HORecHits = nullptr;
 
   iEvent.getByToken(tok_hbhe_, HBHERecHitsHandle);
   if (!HBHERecHitsHandle.isValid()) {
     LogDebug("") << "HcalREcHitRecalib: Error! can't get product!" << std::endl;
   } else {
     HBHERecHits = HBHERecHitsHandle.product();  // get a ptr to the product
   }
 
   iEvent.getByToken(tok_ho_, HORecHitsHandle);
   if (!HORecHitsHandle.isValid()) {
     LogDebug("") << "HcalREcHitRecalib: Error! can't get product!" << std::endl;
   } else {
     HORecHits = HORecHitsHandle.product();  // get a ptr to the product
   }
 
   iEvent.getByToken(tok_hf_, HFRecHitsHandle);
   if (!HFRecHitsHandle.isValid()) {
     LogDebug("") << "HcalREcHitRecalib: Error! can't get product!" << std::endl;
   } else {
     HFRecHits = HFRecHitsHandle.product();  // get a ptr to the product
   }
 
   //Create empty output collections
   auto RecalibHBHERecHitCollection = std::make_unique<HBHERecHitCollection>();
   auto RecalibHFRecHitCollection = std::make_unique<HFRecHitCollection>();
   auto RecalibHORecHitCollection = std::make_unique<HORecHitCollection>();
 
   if (HBHERecHits) {
     HBHERecHitCollection::const_iterator itHBHE;
     for (itHBHE = HBHERecHits->begin(); itHBHE != HBHERecHits->end(); ++itHBHE) {
       // make the rechit with rescaled energy and put in the output collection
       float icalconst = (mapHcal_.get().find(itHBHE->id().rawId()))->second;
       icalconst = refactor_mean_ +
                   (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
       HBHERecHit aHit(itHBHE->id(), itHBHE->energy() * icalconst, itHBHE->time());
 
       RecalibHBHERecHitCollection->push_back(aHit);
     }
   }
 
   if (HFRecHits) {
     HFRecHitCollection::const_iterator itHF;
     for (itHF = HFRecHits->begin(); itHF != HFRecHits->end(); ++itHF) {
       // make the rechit with rescaled energy and put in the output collection
       float icalconst = (mapHcal_.get().find(itHF->id().rawId()))->second;
       icalconst = refactor_mean_ +
                   (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
       HFRecHit aHit(itHF->id(), itHF->energy() * icalconst, itHF->time());
 
       RecalibHFRecHitCollection->push_back(aHit);
     }
   }
 
   if (HORecHits) {
     HORecHitCollection::const_iterator itHO;
     for (itHO = HORecHits->begin(); itHO != HORecHits->end(); ++itHO) {
       // make the rechit with rescaled energy and put in the output collection
       float icalconst = (mapHcal_.get().find(itHO->id().rawId()))->second;
       icalconst = refactor_mean_ +
                   (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
       HORecHit aHit(itHO->id(), itHO->energy() * icalconst, itHO->time());
 
       RecalibHORecHitCollection->push_back(aHit);
     }
   }
 
   //Put Recalibrated rechit in the event
   iEvent.put(std::move(RecalibHBHERecHitCollection), recalibHBHEHits_);
   iEvent.put(std::move(RecalibHFRecHitCollection), recalibHFHits_);
   iEvent.put(std::move(RecalibHORecHitCollection), recalibHOHits_);
 }

Member Data Documentation

◆ hcalfile_

std::string HcalRecHitRecalib::hcalfile_

private

Definition at line 54 of file HcalRecHitRecalib.h.

Referenced by beginRun(), and HcalRecHitRecalib().

◆ hcalfileinpath_

const std::string HcalRecHitRecalib::hcalfileinpath_

private

Definition at line 55 of file HcalRecHitRecalib.h.

Referenced by HcalRecHitRecalib().

◆ mapHcal_

CaloMiscalibMapHcal HcalRecHitRecalib::mapHcal_

private

Definition at line 57 of file HcalRecHitRecalib.h.

Referenced by beginRun(), and produce().

◆ recalibHBHEHits_

const std::string HcalRecHitRecalib::recalibHBHEHits_

private

Definition at line 50 of file HcalRecHitRecalib.h.

Referenced by HcalRecHitRecalib(), and produce().

◆ recalibHFHits_

const std::string HcalRecHitRecalib::recalibHFHits_

private

Definition at line 51 of file HcalRecHitRecalib.h.

Referenced by HcalRecHitRecalib(), and produce().

◆ recalibHOHits_

const std::string HcalRecHitRecalib::recalibHOHits_

private

Definition at line 52 of file HcalRecHitRecalib.h.

Referenced by HcalRecHitRecalib(), and produce().

◆ refactor_

const double HcalRecHitRecalib::refactor_

private

Definition at line 58 of file HcalRecHitRecalib.h.

Referenced by produce().

◆ refactor_mean_

const double HcalRecHitRecalib::refactor_mean_

private

Definition at line 59 of file HcalRecHitRecalib.h.

Referenced by produce().

◆ tok_hbhe_

const edm::EDGetTokenT<HBHERecHitCollection> HcalRecHitRecalib::tok_hbhe_

private

Definition at line 46 of file HcalRecHitRecalib.h.

Referenced by produce().

◆ tok_hf_

const edm::EDGetTokenT<HFRecHitCollection> HcalRecHitRecalib::tok_hf_

private

Definition at line 48 of file HcalRecHitRecalib.h.

Referenced by produce().

◆ tok_ho_

const edm::EDGetTokenT<HORecHitCollection> HcalRecHitRecalib::tok_ho_

private

Definition at line 47 of file HcalRecHitRecalib.h.

Referenced by produce().

◆ topologyToken_

const edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> HcalRecHitRecalib::topologyToken_

private

Definition at line 49 of file HcalRecHitRecalib.h.

Referenced by beginRun().

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ HcalRecHitRecalib()

◆ ~HcalRecHitRecalib()

Member Function Documentation

◆ beginRun()

◆ produce()

Member Data Documentation

◆ hcalfile_

◆ hcalfileinpath_

◆ mapHcal_

◆ recalibHBHEHits_

◆ recalibHFHits_

◆ recalibHOHits_

◆ refactor_

◆ refactor_mean_

◆ tok_hbhe_

◆ tok_hf_

◆ tok_ho_

◆ topologyToken_