#include <EcalRecalibRecHitProducer.h>

Inheritance diagram for EcalRecalibRecHitProducer:

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

virtual void	produce (edm::Event &evt, const edm::EventSetup &es)

	~EcalRecalibRecHitProducer ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Attributes
bool	doEnergyScale_

bool	doEnergyScaleInverse_

bool	doIntercalib_

bool	doIntercalibInverse_

bool	doLaserCorrections_

bool	doLaserCorrectionsInverse_

EcalRecHitAbsAlgo *	EBalgo_

std::string	EBRecalibRecHitCollection_

edm::InputTag	EBRecHitCollection_

edm::EDGetTokenT < EBRecHitCollection >	EBRecHitToken_

EcalRecHitAbsAlgo *	EEalgo_

std::string	EERecalibRecHitCollection_

edm::InputTag	EERecHitCollection_

edm::EDGetTokenT < EERecHitCollection >	EERecHitToken_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

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 doEnergyScale_, doEnergyScaleInverse_, doIntercalib_, doIntercalibInverse_, doLaserCorrections_, doLaserCorrectionsInverse_, EBalgo_, EBRecalibRecHitCollection_, EBRecHitCollection_, EBRecHitToken_, EEalgo_, EERecalibRecHitCollection_, EERecHitCollection_, EERecHitToken_, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                               {
 
    EBRecHitCollection_ = ps.getParameter<edm::InputTag>("EBRecHitCollection");
    EERecHitCollection_ = ps.getParameter<edm::InputTag>("EERecHitCollection");
    EBRecHitToken_ = consumes<EBRecHitCollection>(EBRecHitCollection_);
    EERecHitToken_ = consumes<EBRecHitCollection>(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");
 
    EBalgo_ = new EcalRecHitSimpleAlgo();
    EEalgo_ = new EcalRecHitSimpleAlgo();
 
    produces< EBRecHitCollection >(EBRecalibRecHitCollection_);
    produces< EERecHitCollection >(EERecalibRecHitCollection_);
 }

EcalRecalibRecHitProducer::~EcalRecalibRecHitProducer ( )

Definition at line 57 of file EcalRecalibRecHitProducer.cc.

References EBalgo_, and EEalgo_.

                                                       {
 
   if (EBalgo_) delete EBalgo_;
   if (EEalgo_) delete EEalgo_;
 
 }

Member Function Documentation

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

virtual

Implements edm::EDProducer.

Definition at line 64 of file EcalRecalibRecHitProducer.cc.

References doEnergyScale_, doEnergyScaleInverse_, doIntercalib_, doIntercalibInverse_, doLaserCorrections_, doLaserCorrectionsInverse_, EBRecalibRecHitCollection_, EBRecHitCollection_, egHLT::errCodes::EBRecHits, EBRecHitToken_, EERecalibRecHitCollection_, EERecHitCollection_, egHLT::errCodes::EERecHits, EERecHitToken_, EcalCondObjectContainer< T >::end(), EcalCondObjectContainer< T >::find(), edm::EventSetup::get(), edm::Event::getByToken(), EcalCondObjectContainer< T >::getMap(), edm::InputTag::label(), edm::Event::put(), and edm::EventBase::time().

 {
         using namespace edm;
         Handle< EBRecHitCollection > pEBRecHits;
         Handle< EERecHitCollection > pEERecHits;
 
         const EBRecHitCollection*  EBRecHits = 0;
         const EERecHitCollection*  EERecHits = 0; 
 
     if ( EBRecHitCollection_.label() != "" ) {
       evt.getByToken( EBRecHitToken_, pEBRecHits);
       EBRecHits = pEBRecHits.product(); // get a ptr to the product
     }
     if ( EERecHitCollection_.label() != "" ) { 
       evt.getByToken( EERecHitToken_, pEERecHits);
       EERecHits = pEERecHits.product(); // get a ptr to the product
     }
 
         // collection of rechits to put in the event
         std::auto_ptr< EBRecHitCollection > EBRecalibRecHits( new EBRecHitCollection );
         std::auto_ptr< EERecHitCollection > EERecalibRecHits( new EERecHitCollection );
 
         // now fetch all conditions we need to make rechits
         // ADC to GeV constant
         edm::ESHandle<EcalADCToGeVConstant> pAgc;
         const EcalADCToGeVConstant *agc = 0;
         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 = 0;
         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() );
                         }
 
                         // make the rechit and put in the output collection
                         // must implement op= for EcalRecHit
                         //EcalRecHit aHit( EEalgo_->makeRecHit(*it, icalconst * lasercalib) );
 
             if(doIntercalibInverse_){
               icalconst = 1.0/icalconst;
             }
             if (doLaserCorrectionsInverse_){
               lasercalib = 1.0/lasercalib;
             }
             
                         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( EBRecalibRecHits, EBRecalibRecHitCollection_ );
         evt.put( EERecalibRecHits, EERecalibRecHitCollection_ );
 }