EcalRecHitRecalib Class Reference

#include <CalibCalorimetry/CaloMiscalibTools.src/EcalRecHitRecalib.cc>

Inheritance diagram for EcalRecHitRecalib:

Public Member Functions
	EcalRecHitRecalib (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~EcalRecHitRecalib () 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
const std::string	barrelHits_
const edm::EDPutTokenT< EBRecHitCollection >	barrelHitsToken_
const edm::EDGetTokenT< EBRecHitCollection >	ebRecHitToken_
const std::string	ecalHitsProducer_
const edm::EDGetTokenT< EERecHitCollection >	eeRecHitToken_
const std::string	endcapHits_
const edm::EDPutTokenT< EERecHitCollection >	endcapHitsToken_
const edm::ESGetToken< EcalIntercalibConstants, EcalIntercalibConstantsRcd >	intercalibConstsToken_
const std::string	recalibBarrelHits_
const std::string	recalibEndcapHits_
const double	refactor_
const double	refactor_mean_

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) Ecal RecHit

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

Definition at line 40 of file EcalRecHitRecalib.h.

Constructor & Destructor Documentation

EcalRecHitRecalib()

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

explicit

Definition at line 9 of file EcalRecHitRecalib.cc.

    : ecalHitsProducer_(iConfig.getParameter<std::string>("ecalRecHitsProducer")),
      barrelHits_(iConfig.getParameter<std::string>("barrelHitCollection")),
      endcapHits_(iConfig.getParameter<std::string>("endcapHitCollection")),
      recalibBarrelHits_(iConfig.getParameter<std::string>("RecalibBarrelHitCollection")),
      recalibEndcapHits_(iConfig.getParameter<std::string>("RecalibEndcapHitCollection")),
      refactor_(iConfig.getUntrackedParameter<double>("Refactor", (double)1)),
      refactor_mean_(iConfig.getUntrackedParameter<double>("Refactor_mean", (double)1)),
      ebRecHitToken_(consumes<EBRecHitCollection>(edm::InputTag(ecalHitsProducer_, barrelHits_))),
      eeRecHitToken_(consumes<EERecHitCollection>(edm::InputTag(ecalHitsProducer_, endcapHits_))),
      intercalibConstsToken_(esConsumes()),
      barrelHitsToken_(produces<EBRecHitCollection>(recalibBarrelHits_)),
      endcapHitsToken_(produces<EERecHitCollection>(recalibEndcapHits_)) {}

~EcalRecHitRecalib()

EcalRecHitRecalib::~EcalRecHitRecalib ( )

override

Definition at line 23 of file EcalRecHitRecalib.cc.

{}

Member Function Documentation

produce()

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

override

Definition at line 26 of file EcalRecHitRecalib.cc.

References barrelHitsToken_, filterRecHits_cfi::EBRecHits, ebRecHitToken_, filterRecHits_cfi::EERecHits, eeRecHitToken_, endcapHitsToken_, edm::EventSetup::getData(), iEvent, intercalibConstsToken_, edm::HandleBase::isValid(), LogDebug, eostools::move(), edm::Handle< T >::product(), refactor_, and refactor_mean_.

                                                                             {
  using namespace edm;
  using namespace std;

  Handle<EBRecHitCollection> barrelRecHitsHandle;
  Handle<EERecHitCollection> endcapRecHitsHandle;

  const EBRecHitCollection* EBRecHits = nullptr;
  const EERecHitCollection* EERecHits = nullptr;

  iEvent.getByToken(ebRecHitToken_, barrelRecHitsHandle);
  if (!barrelRecHitsHandle.isValid()) {
    LogDebug("") << "EcalREcHitMiscalib: Error! can't get product!" << std::endl;
  } else {
    EBRecHits = barrelRecHitsHandle.product();  // get a ptr to the product
  }

  iEvent.getByToken(eeRecHitToken_, endcapRecHitsHandle);
  if (!endcapRecHitsHandle.isValid()) {
    LogDebug("") << "EcalREcHitMiscalib: Error! can't get product!" << std::endl;
  } else {
    EERecHits = endcapRecHitsHandle.product();  // get a ptr to the product
  }

  //Create empty output collections
  auto RecalibEBRecHitCollection = std::make_unique<EBRecHitCollection>();
  auto RecalibEERecHitCollection = std::make_unique<EERecHitCollection>();

  // Intercalib constants
  const EcalIntercalibConstants& ical = iSetup.getData(intercalibConstsToken_);

  if (EBRecHits) {
    //loop on all EcalRecHits (barrel)
    EBRecHitCollection::const_iterator itb;
    for (itb = EBRecHits->begin(); itb != EBRecHits->end(); ++itb) {
      // find intercalib constant for this xtal
      EcalIntercalibConstantMap::const_iterator icalit = ical.getMap().find(itb->id().rawId());
      EcalIntercalibConstant icalconst = -1;

      if (icalit != ical.getMap().end()) {
        icalconst = (*icalit);

      } else {
        edm::LogError("EcalRecHitRecalib") << "No intercalib const found for xtal " << EBDetId(itb->id())
                                           << "! something wrong with EcalIntercalibConstants in your DB? ";
      }

      // make the rechit with rescaled energy and put in the output collection
      icalconst = refactor_mean_ +
                  (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
      EcalRecHit aHit(itb->id(), itb->energy() * icalconst, itb->time());

      RecalibEBRecHitCollection->push_back(aHit);
    }
  }

  if (EERecHits) {
    //loop on all EcalRecHits (barrel)
    EERecHitCollection::const_iterator ite;
    for (ite = EERecHits->begin(); ite != EERecHits->end(); ++ite) {
      // find intercalib constant for this xtal
      EcalIntercalibConstantMap::const_iterator icalit = ical.getMap().find(ite->id().rawId());
      EcalIntercalibConstant icalconst = -1;

      if (icalit != ical.getMap().end()) {
        icalconst = (*icalit);
      } else {
        edm::LogError("EcalRecHitRecalib") << "No intercalib const found for xtal " << EEDetId(ite->id())
                                           << "! something wrong with EcalIntercalibConstants in your DB? ";
      }

      // make the rechit with rescaled energy and put in the output collection

      icalconst = refactor_mean_ +
                  (icalconst - refactor_mean_) * refactor_;  //apply additional scaling factor (works if gaussian)
      EcalRecHit aHit(ite->id(), ite->energy() * icalconst, ite->time());

      RecalibEERecHitCollection->push_back(aHit);
    }
  }

  //Put Recalibrated rechit in the event
  iEvent.put(barrelHitsToken_, std::move(RecalibEBRecHitCollection));
  iEvent.put(endcapHitsToken_, std::move(RecalibEERecHitCollection));
}

Member Data Documentation

barrelHits_

const std::string EcalRecHitRecalib::barrelHits_

private

Definition at line 51 of file EcalRecHitRecalib.h.

barrelHitsToken_

const edm::EDPutTokenT<EBRecHitCollection> EcalRecHitRecalib::barrelHitsToken_

private

Definition at line 61 of file EcalRecHitRecalib.h.

Referenced by produce().

ebRecHitToken_

const edm::EDGetTokenT<EBRecHitCollection> EcalRecHitRecalib::ebRecHitToken_

private

Definition at line 58 of file EcalRecHitRecalib.h.

Referenced by produce().

ecalHitsProducer_

const std::string EcalRecHitRecalib::ecalHitsProducer_

private

Definition at line 50 of file EcalRecHitRecalib.h.

eeRecHitToken_

const edm::EDGetTokenT<EERecHitCollection> EcalRecHitRecalib::eeRecHitToken_

private

Definition at line 59 of file EcalRecHitRecalib.h.

Referenced by produce().

endcapHits_

const std::string EcalRecHitRecalib::endcapHits_

private

Definition at line 52 of file EcalRecHitRecalib.h.

endcapHitsToken_

const edm::EDPutTokenT<EERecHitCollection> EcalRecHitRecalib::endcapHitsToken_

private

Definition at line 62 of file EcalRecHitRecalib.h.

Referenced by produce().

intercalibConstsToken_

const edm::ESGetToken<EcalIntercalibConstants, EcalIntercalibConstantsRcd> EcalRecHitRecalib::intercalibConstsToken_

private

Definition at line 60 of file EcalRecHitRecalib.h.

Referenced by produce().

recalibBarrelHits_

const std::string EcalRecHitRecalib::recalibBarrelHits_

private

Definition at line 53 of file EcalRecHitRecalib.h.

recalibEndcapHits_

const std::string EcalRecHitRecalib::recalibEndcapHits_

private

Definition at line 54 of file EcalRecHitRecalib.h.

refactor_

const double EcalRecHitRecalib::refactor_

private

Definition at line 55 of file EcalRecHitRecalib.h.

Referenced by produce().

refactor_mean_

const double EcalRecHitRecalib::refactor_mean_

private

Definition at line 56 of file EcalRecHitRecalib.h.

Referenced by produce().