#include <EcalRecHitWorkerSimple.h>

Inheritance diagram for EcalRecHitWorkerSimple:

Public Member Functions
	EcalRecHitWorkerSimple (const edm::ParameterSet &, edm::ConsumesCollector &c)

bool	run (const edm::Event &evt, const EcalUncalibratedRecHit &uncalibRH, EcalRecHitCollection &result) override

void	set (const edm::EventSetup &es) override

	~EcalRecHitWorkerSimple () override

Public Member Functions inherited from EcalRecHitWorkerBaseClass
	EcalRecHitWorkerBaseClass (const edm::ParameterSet &, edm::ConsumesCollector &c)

	EcalRecHitWorkerBaseClass (const edm::ParameterSet &)

virtual	~EcalRecHitWorkerBaseClass ()

Protected Member Functions
uint32_t	setFlagBits (const std::vector< std::vector< uint32_t > > &map, const uint32_t &status)

Protected Attributes
edm::ESHandle< EcalADCToGeVConstant >	agc

edm::ESGetToken< EcalADCToGeVConstant, EcalADCToGeVConstantRcd >	agcToken_

edm::ESHandle< EcalChannelStatus >	chStatus

edm::ESGetToken< EcalChannelStatus, EcalChannelStatusRcd >	chStatusToken_

double	EBLaserMAX_

double	EBLaserMIN_

double	EELaserMAX_

double	EELaserMIN_

uint32_t	flagmask_

edm::ESHandle< EcalIntercalibConstants >	ical

edm::ESGetToken< EcalIntercalibConstants, EcalIntercalibConstantsRcd >	icalToken_

edm::ESHandle< EcalTimeCalibConstants >	itime

edm::ESGetToken< EcalTimeCalibConstants, EcalTimeCalibConstantsRcd >	itimeToken_

bool	killDeadChannels_

edm::ESHandle< EcalLaserDbService >	laser

bool	laserCorrection_

edm::ESGetToken< EcalLaserDbService, EcalLaserDbRecord >	laserToken_

edm::ESHandle< EcalTimeOffsetConstant >	offtime

edm::ESGetToken< EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd >	offtimeToken_

EcalRecHitSimpleAlgo *	rechitMaker_

bool	skipTimeCalib_

std::vector< int >	v_chstatus_

std::vector< std::vector< uint32_t > >	v_DB_reco_flags_

Additional Inherited Members
Public Types inherited from EcalRecHitWorkerBaseClass
enum	RecoveryFlags { EB_single, EE_single, EB_VFE, EE_VFE, EB_FE, EE_FE }

Detailed Description

Definition at line 30 of file EcalRecHitWorkerSimple.h.

Constructor & Destructor Documentation

◆ EcalRecHitWorkerSimple()

EcalRecHitWorkerSimple::EcalRecHitWorkerSimple	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &	c
	)

Definition at line 8 of file EcalRecHitWorkerSimple.cc.

References agcToken_, c, chStatusToken_, EBLaserMAX_, EBLaserMIN_, ecal_dqm_sourceclient-live_cfg::EcalLaserDbService, EELaserMAX_, EELaserMIN_, flagmask_, edm::ParameterSet::getParameter(), mps_fire::i, icalToken_, itimeToken_, dqmiolumiharvest::j, EcalRecHit::kDead, killDeadChannels_, EcalRecHit::kKilled, EcalRecHit::kL1SpikeFlag, EcalRecHit::kNeighboursRecovered, EcalRecHit::kTowerRecovered, EcalRecHit::kTPSaturated, laserCorrection_, laserToken_, offtimeToken_, AlCaHLTBitMon_ParallelJobs::p, rechitMaker_, skipTimeCalib_, v_chstatus_, and v_DB_reco_flags_.

     : EcalRecHitWorkerBaseClass(ps, c) {
   rechitMaker_ = new EcalRecHitSimpleAlgo();
   v_chstatus_ = StringToEnumValue<EcalChannelStatusCode::Code>(
       ps.getParameter<std::vector<std::string> >("ChannelStatusToBeExcluded"));
   killDeadChannels_ = ps.getParameter<bool>("killDeadChannels");
   laserCorrection_ = ps.getParameter<bool>("laserCorrection");
   EBLaserMIN_ = ps.getParameter<double>("EBLaserMIN");
   EELaserMIN_ = ps.getParameter<double>("EELaserMIN");
   EBLaserMAX_ = ps.getParameter<double>("EBLaserMAX");
   EELaserMAX_ = ps.getParameter<double>("EELaserMAX");
 
   skipTimeCalib_ = ps.getParameter<bool>("skipTimeCalib");
 
   icalToken_ = c.esConsumes<EcalIntercalibConstants, EcalIntercalibConstantsRcd>();
   if (!skipTimeCalib_) {
     itimeToken_ = c.esConsumes<EcalTimeCalibConstants, EcalTimeCalibConstantsRcd>();
     offtimeToken_ = c.esConsumes<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd>();
   }
   agcToken_ = c.esConsumes<EcalADCToGeVConstant, EcalADCToGeVConstantRcd>();
   chStatusToken_ = c.esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
   if (laserCorrection_)
     laserToken_ = c.esConsumes<EcalLaserDbService, EcalLaserDbRecord>();
 
   // Traslate string representation of flagsMapDBReco into enum values
   const edm::ParameterSet& p = ps.getParameter<edm::ParameterSet>("flagsMapDBReco");
   std::vector<std::string> recoflagbitsStrings = p.getParameterNames();
   v_DB_reco_flags_.resize(32);
 
   for (unsigned int i = 0; i != recoflagbitsStrings.size(); ++i) {
     EcalRecHit::Flags recoflagbit = (EcalRecHit::Flags)StringToEnumValue<EcalRecHit::Flags>(recoflagbitsStrings[i]);
     std::vector<std::string> dbstatus_s = p.getParameter<std::vector<std::string> >(recoflagbitsStrings[i]);
     std::vector<uint32_t> dbstatuses;
     for (unsigned int j = 0; j != dbstatus_s.size(); ++j) {
       EcalChannelStatusCode::Code dbstatus =
           (EcalChannelStatusCode::Code)StringToEnumValue<EcalChannelStatusCode::Code>(dbstatus_s[j]);
       dbstatuses.push_back(dbstatus);
     }
 
     v_DB_reco_flags_[recoflagbit] = dbstatuses;
   }
 
   flagmask_ = 0;
   flagmask_ |= 0x1 << EcalRecHit::kNeighboursRecovered;
   flagmask_ |= 0x1 << EcalRecHit::kTowerRecovered;
   flagmask_ |= 0x1 << EcalRecHit::kDead;
   flagmask_ |= 0x1 << EcalRecHit::kKilled;
   flagmask_ |= 0x1 << EcalRecHit::kTPSaturated;
   flagmask_ |= 0x1 << EcalRecHit::kL1SpikeFlag;
 }

◆ ~EcalRecHitWorkerSimple()

EcalRecHitWorkerSimple::~EcalRecHitWorkerSimple ( )

override

Definition at line 160 of file EcalRecHitWorkerSimple.cc.

References rechitMaker_.

160 { delete rechitMaker_; }

EcalRecHitWorkerSimple::rechitMaker_

EcalRecHitSimpleAlgo * rechitMaker_

Definition: EcalRecHitWorkerSimple.h:69

Member Function Documentation

◆ run()

bool EcalRecHitWorkerSimple::run	(	const edm::Event &	evt,
		const EcalUncalibratedRecHit &	uncalibRH,
		EcalRecHitCollection &	result
	)

overridevirtual

Implements EcalRecHitWorkerBaseClass.

Definition at line 73 of file EcalRecHitWorkerSimple.cc.

References agc, chStatus, EBLaserMAX_, EcalBarrel, EcalEndcap, EELaserMAX_, EcalCondObjectContainer< T >::end(), spr::find(), EcalCondObjectContainer< T >::find(), flagmask_, EcalADCToGeVConstant::getEBValue(), EcalTimeOffsetConstant::getEBValue(), EcalADCToGeVConstant::getEEValue(), EcalTimeOffsetConstant::getEEValue(), EcalLaserDbService::getLaserCorrection(), ical, EcalUncalibratedRecHit::id(), itime, killDeadChannels_, EcalRecHit::kPoorCalib, laser, laserCorrection_, EcalRecHitSimpleAlgo::makeRecHit(), offtime, DetId::rawId(), rechitMaker_, mps_fire::result, EcalRecHitSimpleAlgo::setADCToGeVConstant(), EcalRecHit::setFlag(), setFlagBits(), skipTimeCalib_, DetId::subdetId(), edm::EventBase::time(), v_chstatus_, and v_DB_reco_flags_.

                                                                {
   DetId detid = uncalibRH.id();
 
   EcalChannelStatusMap::const_iterator chit = chStatus->find(detid);
   EcalChannelStatusCode::Code dbstatus = chit->getStatusCode();
 
   // check for channels to be excluded from reconstruction
   if (!v_chstatus_.empty()) {
     std::vector<int>::const_iterator res = std::find(v_chstatus_.begin(), v_chstatus_.end(), dbstatus);
     if (res != v_chstatus_.end())
       return false;
   }
 
   uint32_t flagBits = setFlagBits(v_DB_reco_flags_, dbstatus);
 
   float offsetTime = 0;  // the global time phase
   const EcalIntercalibConstantMap& icalMap = ical->getMap();
   if (detid.subdetId() == EcalEndcap) {
     rechitMaker_->setADCToGeVConstant(float(agc->getEEValue()));
     if (!skipTimeCalib_)
       offsetTime = offtime->getEEValue();
   } else {
     rechitMaker_->setADCToGeVConstant(float(agc->getEBValue()));
     if (!skipTimeCalib_)
       offsetTime = offtime->getEBValue();
   }
 
   // first intercalibration constants
   EcalIntercalibConstantMap::const_iterator icalit = icalMap.find(detid);
   EcalIntercalibConstant icalconst = 1;
   if (icalit != icalMap.end()) {
     icalconst = (*icalit);
   } else {
     edm::LogError("EcalRecHitError") << "No intercalib const found for xtal " << detid.rawId()
                                      << "! something wrong with EcalIntercalibConstants in your DB? ";
   }
 
   // get laser coefficient
   float lasercalib = 1.;
   if (laserCorrection_)
     lasercalib = laser->getLaserCorrection(detid, evt.time());
 
   // get time calibration coefficient
   EcalTimeCalibConstant itimeconst = 0;
 
   if (!skipTimeCalib_) {
     const EcalTimeCalibConstantMap& itimeMap = itime->getMap();
     EcalTimeCalibConstantMap::const_iterator itime = itimeMap.find(detid);
 
     if (itime != itimeMap.end()) {
       itimeconst = (*itime);
     } else {
       edm::LogError("EcalRecHitError") << "No time calib const found for xtal " << detid.rawId()
                                        << "! something wrong with EcalTimeCalibConstants in your DB? ";
     }
   }
 
   // make the rechit and put in the output collection, unless recovery has to take care of it
   if (!(flagmask_ & flagBits) || !killDeadChannels_) {
     EcalRecHit myrechit(rechitMaker_->makeRecHit(uncalibRH,
                                                  icalconst * lasercalib,
                                                  (itimeconst + offsetTime),
                                                  /*recoflags_ 0*/
                                                  flagBits));
 
     if (detid.subdetId() == EcalBarrel && (lasercalib < EBLaserMIN_ || lasercalib > EBLaserMAX_))
       myrechit.setFlag(EcalRecHit::kPoorCalib);
     if (detid.subdetId() == EcalEndcap && (lasercalib < EELaserMIN_ || lasercalib > EELaserMAX_))
       myrechit.setFlag(EcalRecHit::kPoorCalib);
     result.push_back(myrechit);
   }
 
   return true;
 }

◆ set()

void EcalRecHitWorkerSimple::set ( const edm::EventSetup & es )

overridevirtual

Implements EcalRecHitWorkerBaseClass.

Definition at line 59 of file EcalRecHitWorkerSimple.cc.

References agc, agcToken_, chStatus, chStatusToken_, edm::EventSetup::getHandle(), ical, icalToken_, itime, itimeToken_, laser, laserCorrection_, laserToken_, offtime, offtimeToken_, and skipTimeCalib_.

                                                         {
   ical = es.getHandle(icalToken_);
 
   if (!skipTimeCalib_) {
     itime = es.getHandle(itimeToken_);
     offtime = es.getHandle(offtimeToken_);
   }
 
   agc = es.getHandle(agcToken_);
   chStatus = es.getHandle(chStatusToken_);
   if (laserCorrection_)
     laser = es.getHandle(laserToken_);
 }

◆ setFlagBits()

uint32_t EcalRecHitWorkerSimple::setFlagBits	(	const std::vector< std::vector< uint32_t > > &	map,
		const uint32_t &	status
	)

protected

Definition at line 151 of file EcalRecHitWorkerSimple.cc.

References mps_fire::end, spr::find(), mps_fire::i, genParticles_cff::map, mps_update::status, and testProducerWithPsetDescEmpty_cfi::x1.

Referenced by run().

                                                                                                                {
   for (unsigned int i = 0; i != map.size(); ++i) {
     if (std::find(map[i].begin(), map[i].end(), status) != map[i].end())
       return 0x1 << i;
   }
 
   return 0;
 }