#include <EcalRecHitWorkerSimple.h>

Inheritance diagram for EcalRecHitWorkerSimple:

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

	EcalRecHitWorkerSimple (const edm::ParameterSet &)

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

void	set (const edm::EventSetup &es)

virtual	~EcalRecHitWorkerSimple ()

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::ESHandle< EcalChannelStatus >	chStatus

double	EBLaserMAX_

double	EBLaserMIN_

double	EELaserMAX_

double	EELaserMIN_

uint32_t	flagmask_

edm::ESHandle < EcalIntercalibConstants >	ical

edm::ESHandle < EcalTimeCalibConstants >	itime

bool	killDeadChannels_

edm::ESHandle< EcalLaserDbService >	laser

bool	laserCorrection_

edm::ESHandle < EcalTimeOffsetConstant >	offtime

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 23 of file EcalRecHitWorkerSimple.h.

Constructor & Destructor Documentation

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

Definition at line 15 of file EcalRecHitWorkerSimple.cc.

References EBLaserMAX_, EBLaserMIN_, EELaserMAX_, EELaserMIN_, flagmask_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), i, j, EcalRecHit::kDead, killDeadChannels_, EcalRecHit::kKilled, EcalRecHit::kL1SpikeFlag, EcalRecHit::kNeighboursRecovered, EcalRecHit::kTowerRecovered, EcalRecHit::kTPSaturated, laserCorrection_, 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");
 
     // 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 ( const edm::ParameterSet & )

EcalRecHitWorkerSimple::~EcalRecHitWorkerSimple ( )

virtual

Definition at line 170 of file EcalRecHitWorkerSimple.cc.

References rechitMaker_.

                                                {
 
   delete rechitMaker_;
 }

Member Function Documentation

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

virtual

Implements EcalRecHitWorkerBaseClass.

Definition at line 76 of file EcalRecHitWorkerSimple.cc.

References agc, chStatus, EBLaserMAX_, EcalBarrel, EcalEndcap, EELaserMAX_, EcalCondObjectContainer< T >::end(), spr::find(), EcalCondObjectContainer< T >::find(), flagmask_, ical, EcalUncalibratedRecHit::id(), itime, killDeadChannels_, EcalRecHit::kPoorCalib, laser, laserCorrection_, EcalRecHitSimpleAlgo::makeRecHit(), offtime, edm::SortedCollection< T, SORT >::push_back(), DetId::rawId(), rechitMaker_, 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_.size() > 0) {
         
         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;
 }

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

virtual

Implements EcalRecHitWorkerBaseClass.

Definition at line 60 of file EcalRecHitWorkerSimple.cc.

References agc, chStatus, edm::EventSetup::get(), ical, itime, laser, laserCorrection_, offtime, and skipTimeCalib_.

 {
         es.get<EcalIntercalibConstantsRcd>().get(ical);
 
         if (!skipTimeCalib_){
             es.get<EcalTimeCalibConstantsRcd>().get(itime);
             es.get<EcalTimeOffsetConstantRcd>().get(offtime);
         }
 
         es.get<EcalADCToGeVConstantRcd>().get(agc);
         es.get<EcalChannelStatusRcd>().get(chStatus);
         if ( laserCorrection_ ) es.get<EcalLaserDbRecord>().get(laser);
 }

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

protected

Definition at line 158 of file EcalRecHitWorkerSimple.cc.

References begin, end, spr::find(), and i.

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;
 }