EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc

0001 /** \class EcalUncalibRecHitRecRatioAlgo
0002   *  Template used to compute amplitude, pedestal, time jitter, chi2 of a pulse
0003   *  using a weights method
0004   *
0005   *  \author A. Ledovskoy (Design) - M. Balazs (Implementation)
0006   */
0007
0008 #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
0009 #include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
0010 #include "CondFormats/DataRecord/interface/EcalSampleMaskRcd.h"
0011 #include "CondFormats/EcalObjects/interface/EcalGainRatios.h"
0012 #include "CondFormats/EcalObjects/interface/EcalPedestals.h"
0013 #include "CondFormats/EcalObjects/interface/EcalSampleMask.h"
0014 #include "FWCore/Framework/interface/ESHandle.h"
0015 #include "FWCore/Framework/interface/Event.h"
0016 #include "FWCore/Framework/interface/EventSetup.h"
0017 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0018 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0019 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0020 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0021 #include "FWCore/Utilities/interface/ESGetToken.h"
0022 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitRatioMethodAlgo.h"
0023 #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerRunOneDigiBase.h"
0024
0025 class EcalUncalibRecHitWorkerRatio : public EcalUncalibRecHitWorkerRunOneDigiBase {
0026 public:
0027   EcalUncalibRecHitWorkerRatio(const edm::ParameterSet&, edm::ConsumesCollector& c);
0028   EcalUncalibRecHitWorkerRatio() {}
0029
0030   void set(const edm::EventSetup& es) override;
0031   bool run(const edm::Event& evt,
0032            const EcalDigiCollection::const_iterator& digi,
0033            EcalUncalibratedRecHitCollection& result) override;
0034
0035   edm::ParameterSetDescription getAlgoDescription() override;
0036
0037 protected:
0038   // determie which of the samples must actually be used by ECAL local reco
0039   edm::ESHandle<EcalSampleMask> sampleMaskHand_;
0040   edm::ESGetToken<EcalSampleMask, EcalSampleMaskRcd> sampleMaskToken_;
0041
0042   edm::ESHandle<EcalPedestals> peds;
0043   edm::ESGetToken<EcalPedestals, EcalPedestalsRcd> pedsToken_;
0044   edm::ESHandle<EcalGainRatios> gains;
0045   edm::ESGetToken<EcalGainRatios, EcalGainRatiosRcd> gainsToken_;
0046
0047   double pedVec[3];
0048   double pedRMSVec[3];
0049   double gainRatios[3];
0050
0051   std::vector<double> EBtimeFitParameters_;
0052   std::vector<double> EEtimeFitParameters_;
0053
0054   std::vector<double> EBamplitudeFitParameters_;
0055   std::vector<double> EEamplitudeFitParameters_;
0056
0057   std::pair<double, double> EBtimeFitLimits_;
0058   std::pair<double, double> EEtimeFitLimits_;
0059
0060   double EBtimeConstantTerm_;
0061   double EEtimeConstantTerm_;
0062
0063   EcalUncalibRecHitRatioMethodAlgo<EBDataFrame> uncalibMaker_barrel_;
0064   EcalUncalibRecHitRatioMethodAlgo<EEDataFrame> uncalibMaker_endcap_;
0065 };
0066
0067 EcalUncalibRecHitWorkerRatio::EcalUncalibRecHitWorkerRatio(const edm::ParameterSet& ps, edm::ConsumesCollector& c)
0068     : EcalUncalibRecHitWorkerRunOneDigiBase(ps, c) {
0069   EBtimeFitParameters_ = ps.getParameter<std::vector<double>>("EBtimeFitParameters");
0070   EEtimeFitParameters_ = ps.getParameter<std::vector<double>>("EEtimeFitParameters");
0071
0072   EBamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EBamplitudeFitParameters");
0073   EEamplitudeFitParameters_ = ps.getParameter<std::vector<double>>("EEamplitudeFitParameters");
0074
0075   EBtimeFitLimits_.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
0076   EBtimeFitLimits_.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
0077
0078   EEtimeFitLimits_.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
0079   EEtimeFitLimits_.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
0080
0081   EBtimeConstantTerm_ = ps.getParameter<double>("EBtimeConstantTerm");
0082   EEtimeConstantTerm_ = ps.getParameter<double>("EEtimeConstantTerm");
0083
0084   pedsToken_ = c.esConsumes<EcalPedestals, EcalPedestalsRcd>();
0085   gainsToken_ = c.esConsumes<EcalGainRatios, EcalGainRatiosRcd>();
0086   sampleMaskToken_ = c.esConsumes<EcalSampleMask, EcalSampleMaskRcd>();
0087 }
0088
0089 void EcalUncalibRecHitWorkerRatio::set(const edm::EventSetup& es) {
0090   // which of the samples need be used
0091   sampleMaskHand_ = es.getHandle(sampleMaskToken_);
0092
0093   gains = es.getHandle(gainsToken_);
0094   peds = es.getHandle(pedsToken_);
0095 }
0096
0097 bool EcalUncalibRecHitWorkerRatio::run(const edm::Event& evt,
0098                                        const EcalDigiCollection::const_iterator& itdg,
0099                                        EcalUncalibratedRecHitCollection& result) {
0100   DetId detid(itdg->id());
0101
0102   const EcalSampleMask* sampleMask_ = sampleMaskHand_.product();
0103
0104   const EcalPedestals::Item* aped = nullptr;
0105   const EcalMGPAGainRatio* aGain = nullptr;
0106
0107   if (detid.subdetId() == EcalEndcap) {
0108     unsigned int hashedIndex = EEDetId(detid).hashedIndex();
0109     aped = &peds->endcap(hashedIndex);
0110     aGain = &gains->endcap(hashedIndex);
0111   } else {
0112     unsigned int hashedIndex = EBDetId(detid).hashedIndex();
0113     aped = &peds->barrel(hashedIndex);
0114     aGain = &gains->barrel(hashedIndex);
0115   }
0116
0117   pedVec[0] = aped->mean_x12;
0118   pedVec[1] = aped->mean_x6;
0119   pedVec[2] = aped->mean_x1;
0120   pedRMSVec[0] = aped->rms_x12;
0121   pedRMSVec[1] = aped->rms_x6;
0122   pedRMSVec[2] = aped->rms_x1;
0123   gainRatios[0] = 1.;
0124   gainRatios[1] = aGain->gain12Over6();
0125   gainRatios[2] = aGain->gain6Over1() * aGain->gain12Over6();
0126
0127   float clockToNsConstant = 25.;
0128   EcalUncalibratedRecHit uncalibRecHit;
0129
0130   if (detid.subdetId() == EcalEndcap) {
0131     uncalibRecHit = uncalibMaker_endcap_.makeRecHit(*itdg,
0132                                                     *sampleMask_,
0133                                                     pedVec,
0134                                                     pedRMSVec,
0135                                                     gainRatios,
0136                                                     EEtimeFitParameters_,
0137                                                     EEamplitudeFitParameters_,
0138                                                     EEtimeFitLimits_);  //GF pass mask here
0139
0140     EcalUncalibRecHitRatioMethodAlgo<EEDataFrame>::CalculatedRecHit crh = uncalibMaker_endcap_.getCalculatedRecHit();
0141     uncalibRecHit.setAmplitude(crh.amplitudeMax);
0142     uncalibRecHit.setJitter(crh.timeMax - 5);
0143     uncalibRecHit.setJitterError(
0144         std::sqrt(pow(crh.timeError, 2) + std::pow(EEtimeConstantTerm_, 2) / std::pow(clockToNsConstant, 2)));
0145
0146   } else {
0147     bool gainSwitch = uncalibMaker_barrel_.fixMGPAslew(*itdg);
0148
0149     uncalibRecHit = uncalibMaker_barrel_.makeRecHit(*itdg,
0150                                                     *sampleMask_,
0151                                                     pedVec,
0152                                                     pedRMSVec,
0153                                                     gainRatios,
0154                                                     EBtimeFitParameters_,
0155                                                     EBamplitudeFitParameters_,
0156                                                     EBtimeFitLimits_);  //GF pass mask here
0157
0158     EcalUncalibRecHitRatioMethodAlgo<EBDataFrame>::CalculatedRecHit crh = uncalibMaker_barrel_.getCalculatedRecHit();
0159
0160     uncalibRecHit.setAmplitude(crh.amplitudeMax);
0161     if (gainSwitch) {
0162       // introduce additional 1ns shift
0163       uncalibRecHit.setJitter(crh.timeMax - 5 - 0.04);
0164     } else {
0165       uncalibRecHit.setJitter(crh.timeMax - 5);
0166     }
0167     uncalibRecHit.setJitterError(
0168         std::sqrt(pow(crh.timeError, 2) + std::pow(EBtimeConstantTerm_, 2) / std::pow(clockToNsConstant, 2)));
0169   }
0170   result.push_back(uncalibRecHit);
0171
0172   return true;
0173 }
0174
0175 edm::ParameterSetDescription EcalUncalibRecHitWorkerRatio::getAlgoDescription() {
0176   edm::ParameterSetDescription psd;
0177   std::vector<double> dSet1 = {-2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277};
0178   std::vector<double> dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621};
0179
0180   psd.addNode(edm::ParameterDescription<double>("EEtimeFitLimits_Upper", 1.4, true) and
0181               edm::ParameterDescription<double>("EEtimeConstantTerm", 0.18, true) and
0182               edm::ParameterDescription<double>("EBtimeFitLimits_Lower", 0.2, true) and
0183               edm::ParameterDescription<double>("EBtimeConstantTerm", 0.26, true) and
0184               edm::ParameterDescription<double>("EEtimeFitLimits_Lower", 0.2, true) and
0185               edm::ParameterDescription<std::vector<double>>("EEtimeFitParameters", dSet1, true) and
0186               edm::ParameterDescription<std::vector<double>>("EEamplitudeFitParameters", {1.89, 1.4}, true) and
0187               edm::ParameterDescription<double>("EBtimeFitLimits_Upper", 1.4, true) and
0188               edm::ParameterDescription<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652}, true) and
0189               edm::ParameterDescription<std::vector<double>>("EBtimeFitParameters", dSet2, true));
0190
0191   return psd;
0192 }
0193
0194 #include "FWCore/Framework/interface/MakerMacros.h"
0195 #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h"
0196 DEFINE_EDM_PLUGIN(EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerRatio, "EcalUncalibRecHitWorkerRatio");
0197 #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h"
0198 DEFINE_EDM_PLUGIN(EcalUncalibRecHitFillDescriptionWorkerFactory,
0199                   EcalUncalibRecHitWorkerRatio,
0200                   "EcalUncalibRecHitWorkerRatio");