EcalRecProducers/plugins/EcalRecHitWorkerSimple.cc

0001 /** \class EcalRecHitSimpleAlgo
0002   *  Simple algoritm to make rechits from uncalibrated rechits
0003   *
0004   *  \author Shahram Rahatlou, University of Rome & INFN, March 2006
0005   */
0006
0007 #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbRecord.h"
0008 #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h"
0009 #include "CommonTools/Utils/interface/StringToEnumValue.h"
0010 #include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
0011 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
0012 #include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
0013 #include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
0014 #include "CondFormats/DataRecord/interface/EcalTimeOffsetConstantRcd.h"
0015 #include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h"
0016 #include "CondFormats/EcalObjects/interface/EcalChannelStatus.h"
0017 #include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h"
0018 #include "CondFormats/EcalObjects/interface/EcalTimeCalibConstants.h"
0019 #include "CondFormats/EcalObjects/interface/EcalTimeOffsetConstant.h"
0020 #include "FWCore/Framework/interface/ESHandle.h"
0021 #include "FWCore/Framework/interface/Event.h"
0022 #include "FWCore/Framework/interface/EventSetup.h"
0023 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0024 #include "FWCore/Utilities/interface/ESGetToken.h"
0025 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitSimpleAlgo.h"
0026 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgo.h"
0027 #include "RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerBaseClass.h"
0028
0029 class EcalRecHitWorkerSimple : public EcalRecHitWorkerBaseClass {
0030 public:
0031   EcalRecHitWorkerSimple(const edm::ParameterSet&, edm::ConsumesCollector& c);
0032   ~EcalRecHitWorkerSimple() override;
0033
0034   void set(const edm::EventSetup& es) override;
0035   bool run(const edm::Event& evt, const EcalUncalibratedRecHit& uncalibRH, EcalRecHitCollection& result) override;
0036
0037 protected:
0038   double EBLaserMIN_;
0039   double EELaserMIN_;
0040   double EBLaserMAX_;
0041   double EELaserMAX_;
0042
0043   edm::ESHandle<EcalIntercalibConstants> ical;
0044   edm::ESHandle<EcalTimeCalibConstants> itime;
0045   edm::ESHandle<EcalTimeOffsetConstant> offtime;
0046   edm::ESHandle<EcalADCToGeVConstant> agc;
0047   edm::ESHandle<EcalChannelStatus> chStatus;
0048   std::vector<int> v_chstatus_;
0049   edm::ESHandle<EcalLaserDbService> laser;
0050   edm::ESGetToken<EcalIntercalibConstants, EcalIntercalibConstantsRcd> icalToken_;
0051   edm::ESGetToken<EcalTimeCalibConstants, EcalTimeCalibConstantsRcd> itimeToken_;
0052   edm::ESGetToken<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd> offtimeToken_;
0053   edm::ESGetToken<EcalADCToGeVConstant, EcalADCToGeVConstantRcd> agcToken_;
0054   edm::ESGetToken<EcalChannelStatus, EcalChannelStatusRcd> chStatusToken_;
0055   edm::ESGetToken<EcalLaserDbService, EcalLaserDbRecord> laserToken_;
0056
0057   // Associate reco flagbit ( outer vector) to many db status flags (inner vector)
0058   std::vector<std::vector<uint32_t> > v_DB_reco_flags_;
0059
0060   uint32_t setFlagBits(const std::vector<std::vector<uint32_t> >& map, const uint32_t& status);
0061
0062   uint32_t flagmask_;  // do not propagate channels with these flags on
0063
0064   bool killDeadChannels_;
0065   bool laserCorrection_;
0066   bool skipTimeCalib_;
0067
0068   EcalRecHitSimpleAlgo* rechitMaker_;
0069 };
0070
0071 EcalRecHitWorkerSimple::EcalRecHitWorkerSimple(const edm::ParameterSet& ps, edm::ConsumesCollector& c)
0072     : EcalRecHitWorkerBaseClass(ps, c) {
0073   rechitMaker_ = new EcalRecHitSimpleAlgo();
0074   v_chstatus_ = StringToEnumValue<EcalChannelStatusCode::Code>(
0075       ps.getParameter<std::vector<std::string> >("ChannelStatusToBeExcluded"));
0076   killDeadChannels_ = ps.getParameter<bool>("killDeadChannels");
0077   laserCorrection_ = ps.getParameter<bool>("laserCorrection");
0078   EBLaserMIN_ = ps.getParameter<double>("EBLaserMIN");
0079   EELaserMIN_ = ps.getParameter<double>("EELaserMIN");
0080   EBLaserMAX_ = ps.getParameter<double>("EBLaserMAX");
0081   EELaserMAX_ = ps.getParameter<double>("EELaserMAX");
0082
0083   skipTimeCalib_ = ps.getParameter<bool>("skipTimeCalib");
0084
0085   icalToken_ = c.esConsumes<EcalIntercalibConstants, EcalIntercalibConstantsRcd>();
0086   if (!skipTimeCalib_) {
0087     itimeToken_ = c.esConsumes<EcalTimeCalibConstants, EcalTimeCalibConstantsRcd>();
0088     offtimeToken_ = c.esConsumes<EcalTimeOffsetConstant, EcalTimeOffsetConstantRcd>();
0089   }
0090   agcToken_ = c.esConsumes<EcalADCToGeVConstant, EcalADCToGeVConstantRcd>();
0091   chStatusToken_ = c.esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
0092   if (laserCorrection_)
0093     laserToken_ = c.esConsumes<EcalLaserDbService, EcalLaserDbRecord>();
0094
0095   // Traslate string representation of flagsMapDBReco into enum values
0096   const edm::ParameterSet& p = ps.getParameter<edm::ParameterSet>("flagsMapDBReco");
0097   std::vector<std::string> recoflagbitsStrings = p.getParameterNames();
0098   v_DB_reco_flags_.resize(32);
0099
0100   for (unsigned int i = 0; i != recoflagbitsStrings.size(); ++i) {
0101     EcalRecHit::Flags recoflagbit = (EcalRecHit::Flags)StringToEnumValue<EcalRecHit::Flags>(recoflagbitsStrings[i]);
0102     std::vector<std::string> dbstatus_s = p.getParameter<std::vector<std::string> >(recoflagbitsStrings[i]);
0103     std::vector<uint32_t> dbstatuses;
0104     for (unsigned int j = 0; j != dbstatus_s.size(); ++j) {
0105       EcalChannelStatusCode::Code dbstatus =
0106           (EcalChannelStatusCode::Code)StringToEnumValue<EcalChannelStatusCode::Code>(dbstatus_s[j]);
0107       dbstatuses.push_back(dbstatus);
0108     }
0109
0110     v_DB_reco_flags_[recoflagbit] = dbstatuses;
0111   }
0112
0113   flagmask_ = 0;
0114   flagmask_ |= 0x1 << EcalRecHit::kNeighboursRecovered;
0115   flagmask_ |= 0x1 << EcalRecHit::kTowerRecovered;
0116   flagmask_ |= 0x1 << EcalRecHit::kDead;
0117   flagmask_ |= 0x1 << EcalRecHit::kKilled;
0118   flagmask_ |= 0x1 << EcalRecHit::kTPSaturated;
0119   flagmask_ |= 0x1 << EcalRecHit::kL1SpikeFlag;
0120 }
0121
0122 void EcalRecHitWorkerSimple::set(const edm::EventSetup& es) {
0123   ical = es.getHandle(icalToken_);
0124
0125   if (!skipTimeCalib_) {
0126     itime = es.getHandle(itimeToken_);
0127     offtime = es.getHandle(offtimeToken_);
0128   }
0129
0130   agc = es.getHandle(agcToken_);
0131   chStatus = es.getHandle(chStatusToken_);
0132   if (laserCorrection_)
0133     laser = es.getHandle(laserToken_);
0134 }
0135
0136 bool EcalRecHitWorkerSimple::run(const edm::Event& evt,
0137                                  const EcalUncalibratedRecHit& uncalibRH,
0138                                  EcalRecHitCollection& result) {
0139   DetId detid = uncalibRH.id();
0140
0141   EcalChannelStatusMap::const_iterator chit = chStatus->find(detid);
0142   EcalChannelStatusCode::Code dbstatus = chit->getStatusCode();
0143
0144   // check for channels to be excluded from reconstruction
0145   if (!v_chstatus_.empty()) {
0146     std::vector<int>::const_iterator res = std::find(v_chstatus_.begin(), v_chstatus_.end(), dbstatus);
0147     if (res != v_chstatus_.end())
0148       return false;
0149   }
0150
0151   uint32_t flagBits = setFlagBits(v_DB_reco_flags_, dbstatus);
0152
0153   float offsetTime = 0;  // the global time phase
0154   const EcalIntercalibConstantMap& icalMap = ical->getMap();
0155   if (detid.subdetId() == EcalEndcap) {
0156     rechitMaker_->setADCToGeVConstant(float(agc->getEEValue()));
0157     if (!skipTimeCalib_)
0158       offsetTime = offtime->getEEValue();
0159   } else {
0160     rechitMaker_->setADCToGeVConstant(float(agc->getEBValue()));
0161     if (!skipTimeCalib_)
0162       offsetTime = offtime->getEBValue();
0163   }
0164
0165   // first intercalibration constants
0166   EcalIntercalibConstantMap::const_iterator icalit = icalMap.find(detid);
0167   EcalIntercalibConstant icalconst = 1;
0168   if (icalit != icalMap.end()) {
0169     icalconst = (*icalit);
0170   } else {
0171     edm::LogError("EcalRecHitError") << "No intercalib const found for xtal " << detid.rawId()
0172                                      << "! something wrong with EcalIntercalibConstants in your DB? ";
0173   }
0174
0175   // get laser coefficient
0176   float lasercalib = 1.;
0177   if (laserCorrection_)
0178     lasercalib = laser->getLaserCorrection(detid, evt.time());
0179
0180   // get time calibration coefficient
0181   EcalTimeCalibConstant itimeconst = 0;
0182
0183   if (!skipTimeCalib_) {
0184     const EcalTimeCalibConstantMap& itimeMap = itime->getMap();
0185     EcalTimeCalibConstantMap::const_iterator itime = itimeMap.find(detid);
0186
0187     if (itime != itimeMap.end()) {
0188       itimeconst = (*itime);
0189     } else {
0190       edm::LogError("EcalRecHitError") << "No time calib const found for xtal " << detid.rawId()
0191                                        << "! something wrong with EcalTimeCalibConstants in your DB? ";
0192     }
0193   }
0194
0195   // make the rechit and put in the output collection, unless recovery has to take care of it
0196   if (!(flagmask_ & flagBits) || !killDeadChannels_) {
0197     EcalRecHit myrechit(rechitMaker_->makeRecHit(uncalibRH,
0198                                                  icalconst * lasercalib,
0199                                                  (itimeconst + offsetTime),
0200                                                  /*recoflags_ 0*/
0201                                                  flagBits));
0202
0203     if (detid.subdetId() == EcalBarrel && (lasercalib < EBLaserMIN_ || lasercalib > EBLaserMAX_))
0204       myrechit.setFlag(EcalRecHit::kPoorCalib);
0205     if (detid.subdetId() == EcalEndcap && (lasercalib < EELaserMIN_ || lasercalib > EELaserMAX_))
0206       myrechit.setFlag(EcalRecHit::kPoorCalib);
0207     result.push_back(myrechit);
0208   }
0209
0210   return true;
0211 }
0212
0213 // Take our association map of dbstatuses-> recHit flagbits and return the apporpriate flagbit word
0214 uint32_t EcalRecHitWorkerSimple::setFlagBits(const std::vector<std::vector<uint32_t> >& map, const uint32_t& status) {
0215   for (unsigned int i = 0; i != map.size(); ++i) {
0216     if (std::find(map[i].begin(), map[i].end(), status) != map[i].end())
0217       return 0x1 << i;
0218   }
0219
0220   return 0;
0221 }
0222
0223 EcalRecHitWorkerSimple::~EcalRecHitWorkerSimple() { delete rechitMaker_; }
0224
0225 #include "FWCore/Framework/interface/MakerMacros.h"
0226 #include "RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerFactory.h"
0227 DEFINE_EDM_PLUGIN(EcalRecHitWorkerFactory, EcalRecHitWorkerSimple, "EcalRecHitWorkerSimple");