#include <EcalRecalibRecHitProducer.h>

Inheritance diagram for EcalRecalibRecHitProducer:

Public Member Functions
	EcalRecalibRecHitProducer (const edm::ParameterSet &ps)

void	produce (edm::StreamID sid, edm::Event &evt, const edm::EventSetup &es) const override

Public Member Functions inherited from edm::global::EDProducer<>
	EDProducer ()=default

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () 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)

virtual	~ProducerBase () noexcept(false)

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)

Private Attributes
const bool	doEnergyScale_

const bool	doEnergyScaleInverse_

const bool	doIntercalib_

const bool	doIntercalibInverse_

const bool	doLaserCorrections_

const bool	doLaserCorrectionsInverse_

const std::string	EBRecalibRecHitCollection_

const edm::InputTag	EBRecHitCollection_

const edm::EDGetTokenT< EBRecHitCollection >	EBRecHitToken_

const std::string	EERecalibRecHitCollection_

const edm::InputTag	EERecHitCollection_

const edm::EDGetTokenT< EERecHitCollection >	EERecHitToken_

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

Static Public Member Functions inherited from edm::global::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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)

Detailed Description

produce ECAL rechits from uncalibrated rechits

Author: Federico Ferri, University of Milano Bicocca and INFN

Definition at line 20 of file EcalRecalibRecHitProducer.h.

Constructor & Destructor Documentation

EcalRecalibRecHitProducer::EcalRecalibRecHitProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 34 of file EcalRecalibRecHitProducer.cc.

References EBRecalibRecHitCollection_, and EERecalibRecHitCollection_.

                                                                               :
    EBRecHitCollection_(        ps.getParameter<edm::InputTag>("EBRecHitCollection") ),
    EERecHitCollection_(        ps.getParameter<edm::InputTag>("EERecHitCollection") ),
    EBRecHitToken_(             (not EBRecHitCollection_.label().empty()) ? consumes<EBRecHitCollection>(EBRecHitCollection_) : edm::EDGetTokenT<EBRecHitCollection>() ),
    EERecHitToken_(             (not EERecHitCollection_.label().empty()) ? consumes<EERecHitCollection>(EERecHitCollection_) : edm::EDGetTokenT<EERecHitCollection>() ),
    EBRecalibRecHitCollection_( ps.getParameter<std::string>("EBRecalibRecHitCollection") ),
    EERecalibRecHitCollection_( ps.getParameter<std::string>("EERecalibRecHitCollection") ),
    doEnergyScale_(             ps.getParameter<bool>("doEnergyScale") ),
    doIntercalib_(              ps.getParameter<bool>("doIntercalib") ),
    doLaserCorrections_(        ps.getParameter<bool>("doLaserCorrections") ),
 
    doEnergyScaleInverse_(      ps.getParameter<bool>("doEnergyScaleInverse") ),
    doIntercalibInverse_(       ps.getParameter<bool>("doIntercalibInverse") ),
    doLaserCorrectionsInverse_( ps.getParameter<bool>("doLaserCorrectionsInverse") )
 {
    produces< EBRecHitCollection >(EBRecalibRecHitCollection_);
    produces< EERecHitCollection >(EERecalibRecHitCollection_);
 }

Member Function Documentation

void EcalRecalibRecHitProducer::produce	(	edm::StreamID	sid,
		edm::Event &	evt,
		const edm::EventSetup &	es
	)		const

override

Definition at line 53 of file EcalRecalibRecHitProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), DEFINE_FWK_MODULE, doEnergyScale_, doEnergyScaleInverse_, doIntercalib_, doIntercalibInverse_, doLaserCorrections_, doLaserCorrectionsInverse_, EBRecalibRecHitCollection_, EBRecHitCollection_, egHLT::errCodes::EBRecHits, EBRecHitToken_, EERecalibRecHitCollection_, EERecHitCollection_, egHLT::errCodes::EERecHits, EERecHitToken_, EcalCondObjectContainer< T >::end(), edm::SortedCollection< T, SORT >::end(), EcalCondObjectContainer< T >::find(), objects.autophobj::float, edm::EventSetup::get(), edm::Event::getByToken(), EcalADCToGeVConstant::getEBValue(), EcalADCToGeVConstant::getEEValue(), EcalLaserDbService::getLaserCorrection(), EcalCondObjectContainer< T >::getMap(), edm::InputTag::label(), eostools::move(), edm::Handle< T >::product(), edm::Event::put(), and edm::EventBase::time().

 {
         using namespace edm;
         Handle< EBRecHitCollection > pEBRecHits;
         Handle< EERecHitCollection > pEERecHits;
 
         const EBRecHitCollection*  EBRecHits = nullptr;
         const EERecHitCollection*  EERecHits = nullptr; 
 
     if (not EBRecHitCollection_.label().empty()) {
       evt.getByToken( EBRecHitToken_, pEBRecHits);
       EBRecHits = pEBRecHits.product(); // get a ptr to the product
     }
     if (not EERecHitCollection_.label().empty()) { 
       evt.getByToken( EERecHitToken_, pEERecHits);
       EERecHits = pEERecHits.product(); // get a ptr to the product
     }
 
         // collection of rechits to put in the event
         auto EBRecalibRecHits = std::make_unique<EBRecHitCollection>();
         auto EERecalibRecHits = std::make_unique<EERecHitCollection>();
 
         // now fetch all conditions we need to make rechits
         // ADC to GeV constant
         edm::ESHandle<EcalADCToGeVConstant> pAgc;
         const EcalADCToGeVConstant *agc = nullptr;
         float agc_eb = 1.;
         float agc_ee = 1.;
         if (doEnergyScale_) {
                 es.get<EcalADCToGeVConstantRcd>().get(pAgc);
                 agc = pAgc.product();
                 // use this value in the algorithm
                 agc_eb = float(agc->getEBValue());
                 agc_ee = float(agc->getEEValue());
         }
         // Intercalib constants
         edm::ESHandle<EcalIntercalibConstants> pIcal;
         const EcalIntercalibConstants *ical = nullptr;
         if (doIntercalib_) {
                 es.get<EcalIntercalibConstantsRcd>().get(pIcal);
                 ical = pIcal.product();
         }
         // Laser corrections
         edm::ESHandle<EcalLaserDbService> pLaser;
         es.get<EcalLaserDbRecord>().get( pLaser );
 
     
     if(doEnergyScaleInverse_){
       agc_eb = 1.0/agc_eb;
       agc_ee = 1.0/agc_ee;
     }
 
 
         if (EBRecHits) {
                 // loop over uncalibrated rechits to make calibrated ones
                 for(EBRecHitCollection::const_iterator it  = EBRecHits->begin(); it != EBRecHits->end(); ++it) {
 
                         EcalIntercalibConstant icalconst = 1.;
                         if (doIntercalib_) {
                                 // find intercalib constant for this xtal
                                 const EcalIntercalibConstantMap &icalMap = ical->getMap();
                                 EcalIntercalibConstantMap::const_iterator icalit = icalMap.find(it->id());
                                 if( icalit!=icalMap.end() ){
                                         icalconst = (*icalit);
                                 } else {
                                         edm::LogError("EcalRecHitError") << "No intercalib const found for xtal " << EBDetId(it->id()) << "! something wrong with EcalIntercalibConstants in your DB? "
                                                 ;
                                 }
                         }
                         // get laser coefficient
                         float lasercalib = 1;
                         if (doLaserCorrections_) {
                                 lasercalib = pLaser->getLaserCorrection( EBDetId(it->id()), evt.time() );
                         }
 
                         // make the rechit and put in the output collection
                         // must implement op= for EcalRecHit
             
             if(doIntercalibInverse_){
               icalconst = 1.0/icalconst;
             }
             if (doLaserCorrectionsInverse_){
               lasercalib = 1.0/lasercalib;
             }
 
                         EcalRecHit aHit( (*it).id(), (*it).energy() * agc_eb * icalconst * lasercalib, (*it).time() );
                         EBRecalibRecHits->push_back( aHit );
                 }
         }
 
         if (EERecHits)
         {
                 // loop over uncalibrated rechits to make calibrated ones
                 for(EERecHitCollection::const_iterator it  = EERecHits->begin();
                                 it != EERecHits->end(); ++it) {
 
                         // find intercalib constant for this xtal
                         EcalIntercalibConstant icalconst = 1.;
                         if (doIntercalib_) {
                                 const EcalIntercalibConstantMap &icalMap = ical->getMap();
                                 EcalIntercalibConstantMap::const_iterator icalit=icalMap.find(it->id());
                                 if( icalit!=icalMap.end() ) {
                                         icalconst = (*icalit);
                                 } else {
                                         edm::LogError("EcalRecHitError") << "No intercalib const found for xtal " << EEDetId(it->id()) << "! something wrong with EcalIntercalibConstants in your DB? ";
                                 }
                         }
                         // get laser coefficient
                         float lasercalib = 1;
                         if (doLaserCorrections_) {
                                 lasercalib = pLaser->getLaserCorrection( EEDetId(it->id()), evt.time() );
                         }
 
             if(doIntercalibInverse_){
               icalconst = 1.0/icalconst;
             }
             if (doLaserCorrectionsInverse_){
               lasercalib = 1.0/lasercalib;
             }
             
                         // make the rechit and put in the output collection
                         EcalRecHit aHit( (*it).id(), (*it).energy() * agc_ee * icalconst * lasercalib, (*it).time() );
                         EERecalibRecHits->push_back( aHit );
                 }
         }
         // put the collection of recunstructed hits in the event   
         LogInfo("EcalRecalibRecHitInfo") << "total # EB re-calibrated rechits: " << EBRecalibRecHits->size();
         LogInfo("EcalRecalibRecHitInfo") << "total # EE re-calibrated rechits: " << EERecalibRecHits->size();
 
         evt.put(std::move(EBRecalibRecHits), EBRecalibRecHitCollection_);
         evt.put(std::move(EERecalibRecHits), EERecalibRecHitCollection_);
 }