CaloTowersCreator/src/CaloTowersCreator.cc

0001 /** \class CaloTowersCreator
0002   *
0003   * Original author: J. Mans - Minnesota
0004   */
0005
0006 // Now we allow for the creation of towers from
0007 // rejected hists as well: requested by the MET group
0008 // for studies of the effect of noise clean up.
0009 #include "CaloTowersCreationAlgo.h"
0010 #include "EScales.h"
0011
0012 #include "CommonTools/Utils/interface/StringToEnumValue.h"
0013 #include "DataFormats/Common/interface/Handle.h"
0014 #include "FWCore/Framework/interface/ESHandle.h"
0015 #include "FWCore/Framework/interface/ESWatcher.h"
0016 #include "FWCore/Framework/interface/Event.h"
0017 #include "FWCore/Framework/interface/EventSetup.h"
0018 #include "FWCore/Framework/interface/stream/EDProducer.h"
0019 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0020 #include "FWCore/Utilities/interface/ESGetToken.h"
0021 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
0022 #include "Geometry/CaloTopology/interface/CaloTowerTopology.h"
0023 #include "Geometry/CaloTopology/interface/HcalTopology.h"
0024 #include "Geometry/Records/interface/CaloGeometryRecord.h"
0025 #include "Geometry/Records/interface/IdealGeometryRecord.h"
0026 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalSeverityLevelAlgoRcd.h"
0027 #include "CondFormats/DataRecord/interface/HcalPFCutsRcd.h"
0028 #include "CondTools/Hcal/interface/HcalPFCutsHandler.h"
0029 #include "CondFormats/EcalObjects/interface/EcalPFRecHitThresholds.h"
0030 #include "CondFormats/DataRecord/interface/EcalPFRecHitThresholdsRcd.h"
0031
0032 class CaloTowersCreator : public edm::stream::EDProducer<> {
0033 public:
0034   explicit CaloTowersCreator(const edm::ParameterSet& ps);
0035   ~CaloTowersCreator() override {}
0036   void produce(edm::Event& e, const edm::EventSetup& c) override;
0037   void beginRun(edm::Run const&, edm::EventSetup const&) override;
0038   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0039   double EBEScale, EEEScale, HBEScale, HESEScale;
0040   double HEDEScale, HOEScale, HF1EScale, HF2EScale;
0041
0042 private:
0043   static const std::vector<double>& getGridValues();
0044
0045   CaloTowersCreationAlgo algo_;
0046   edm::EDGetTokenT<HBHERecHitCollection> tok_hbhe_;
0047   edm::EDGetTokenT<HORecHitCollection> tok_ho_;
0048   edm::EDGetTokenT<HFRecHitCollection> tok_hf_;
0049   std::vector<edm::InputTag> ecalLabels_;
0050   std::vector<edm::EDGetTokenT<EcalRecHitCollection> > toks_ecal_;
0051   bool allowMissingInputs_;
0052
0053   edm::ESGetToken<CaloGeometry, CaloGeometryRecord> tok_geom_;
0054   edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> tok_topo_;
0055   edm::ESGetToken<CaloTowerTopology, HcalRecNumberingRecord> tok_cttopo_;
0056   edm::ESGetToken<CaloTowerConstituentsMap, CaloGeometryRecord> tok_ctmap_;
0057   edm::ESGetToken<EcalChannelStatus, EcalChannelStatusRcd> tok_ecalChStatus_;
0058   edm::ESGetToken<HcalChannelQuality, HcalChannelQualityRcd> tok_hcalChStatus_;
0059   edm::ESGetToken<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd> tok_hcalSevComputer_;
0060   edm::ESGetToken<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd> tok_ecalSevAlgo_;
0061
0062   // more compact flags: all HCAL are combined
0063
0064   unsigned int theHcalAcceptSeverityLevel_;
0065   std::vector<int> theEcalSeveritiesToBeExcluded_;
0066
0067   // flag to use recovered hits
0068   bool theRecoveredHcalHitsAreUsed_;
0069   bool theRecoveredEcalHitsAreUsed_;
0070
0071   // paramaters for creating towers from rejected hits
0072
0073   bool useRejectedHitsOnly_;
0074   unsigned int theHcalAcceptSeverityLevelForRejectedHit_;
0075   //  for ECAL we have a list of problem flags
0076   std::vector<int> theEcalSeveritiesToBeUsedInBadTowers_;
0077
0078   // Flags wheteher to use recovered hits for production of
0079   // "bad towers".
0080   // If the recoverd hits were already used for good towers,
0081   // these flags have no effect.
0082   // Note: These flags have no effect on the default tower reconstruction.
0083   bool useRejectedRecoveredHcalHits_;
0084   bool useRejectedRecoveredEcalHits_;
0085
0086   edm::ESWatcher<HcalSeverityLevelComputerRcd> hcalSevLevelWatcher_;
0087   edm::ESWatcher<HcalChannelQualityRcd> hcalChStatusWatcher_;
0088   edm::ESWatcher<IdealGeometryRecord> caloTowerConstituentsWatcher_;
0089   edm::ESWatcher<EcalSeverityLevelAlgoRcd> ecalSevLevelWatcher_;
0090   EScales eScales_;
0091
0092   edm::ESGetToken<HcalPFCuts, HcalPFCutsRcd> hcalCutsToken_;
0093   bool cutsFromDB;
0094   HcalPFCuts const* paramPF = nullptr;
0095
0096   // Ecal noise thresholds
0097   edm::ESGetToken<EcalPFRecHitThresholds, EcalPFRecHitThresholdsRcd> ecalPFRechitThresholdsToken_;
0098   bool ecalRecHitThresh_;
0099   EcalPFRecHitThresholds const* ecalThresholds = nullptr;
0100 };
0101
0102 #include "FWCore/Framework/interface/MakerMacros.h"
0103 DEFINE_FWK_MODULE(CaloTowersCreator);
0104
0105 CaloTowersCreator::CaloTowersCreator(const edm::ParameterSet& conf)
0106     : algo_(conf.getParameter<double>("EBThreshold"),
0107             conf.getParameter<double>("EEThreshold"),
0108
0109             conf.getParameter<bool>("UseEtEBTreshold"),
0110             conf.getParameter<bool>("UseEtEETreshold"),
0111             conf.getParameter<bool>("UseSymEBTreshold"),
0112             conf.getParameter<bool>("UseSymEETreshold"),
0113
0114             conf.getParameter<double>("HcalThreshold"),
0115             conf.getParameter<double>("HBThreshold"),
0116             conf.getParameter<double>("HBThreshold1"),
0117             conf.getParameter<double>("HBThreshold2"),
0118             conf.getParameter<double>("HESThreshold"),
0119             conf.getParameter<double>("HESThreshold1"),
0120             conf.getParameter<double>("HEDThreshold"),
0121             conf.getParameter<double>("HEDThreshold1"),
0122             conf.getParameter<double>("HOThreshold0"),
0123             conf.getParameter<double>("HOThresholdPlus1"),
0124             conf.getParameter<double>("HOThresholdMinus1"),
0125             conf.getParameter<double>("HOThresholdPlus2"),
0126             conf.getParameter<double>("HOThresholdMinus2"),
0127             conf.getParameter<double>("HF1Threshold"),
0128             conf.getParameter<double>("HF2Threshold"),
0129             conf.getParameter<std::vector<double> >("EBGrid"),
0130             conf.getParameter<std::vector<double> >("EBWeights"),
0131             conf.getParameter<std::vector<double> >("EEGrid"),
0132             conf.getParameter<std::vector<double> >("EEWeights"),
0133             conf.getParameter<std::vector<double> >("HBGrid"),
0134             conf.getParameter<std::vector<double> >("HBWeights"),
0135             conf.getParameter<std::vector<double> >("HESGrid"),
0136             conf.getParameter<std::vector<double> >("HESWeights"),
0137             conf.getParameter<std::vector<double> >("HEDGrid"),
0138             conf.getParameter<std::vector<double> >("HEDWeights"),
0139             conf.getParameter<std::vector<double> >("HOGrid"),
0140             conf.getParameter<std::vector<double> >("HOWeights"),
0141             conf.getParameter<std::vector<double> >("HF1Grid"),
0142             conf.getParameter<std::vector<double> >("HF1Weights"),
0143             conf.getParameter<std::vector<double> >("HF2Grid"),
0144             conf.getParameter<std::vector<double> >("HF2Weights"),
0145             conf.getParameter<double>("EBWeight"),
0146             conf.getParameter<double>("EEWeight"),
0147             conf.getParameter<double>("HBWeight"),
0148             conf.getParameter<double>("HESWeight"),
0149             conf.getParameter<double>("HEDWeight"),
0150             conf.getParameter<double>("HOWeight"),
0151             conf.getParameter<double>("HF1Weight"),
0152             conf.getParameter<double>("HF2Weight"),
0153             conf.getParameter<double>("EcutTower"),
0154             conf.getParameter<double>("EBSumThreshold"),
0155             conf.getParameter<double>("EESumThreshold"),
0156             conf.getParameter<bool>("UseHO"),
0157             // (for momentum reconstruction algorithm)
0158             conf.getParameter<int>("MomConstrMethod"),
0159             conf.getParameter<double>("MomHBDepth"),
0160             conf.getParameter<double>("MomHEDepth"),
0161             conf.getParameter<double>("MomEBDepth"),
0162             conf.getParameter<double>("MomEEDepth"),
0163             conf.getParameter<int>("HcalPhase")),
0164
0165       ecalLabels_(conf.getParameter<std::vector<edm::InputTag> >("ecalInputs")),
0166       allowMissingInputs_(conf.getParameter<bool>("AllowMissingInputs")),
0167
0168       theHcalAcceptSeverityLevel_(conf.getParameter<unsigned int>("HcalAcceptSeverityLevel")),
0169
0170       theRecoveredHcalHitsAreUsed_(conf.getParameter<bool>("UseHcalRecoveredHits")),
0171       theRecoveredEcalHitsAreUsed_(conf.getParameter<bool>("UseEcalRecoveredHits")),
0172
0173       // paramaters controlling the use of rejected hits
0174
0175       useRejectedHitsOnly_(conf.getParameter<bool>("UseRejectedHitsOnly")),
0176
0177       theHcalAcceptSeverityLevelForRejectedHit_(
0178           conf.getParameter<unsigned int>("HcalAcceptSeverityLevelForRejectedHit")),
0179
0180       useRejectedRecoveredHcalHits_(conf.getParameter<bool>("UseRejectedRecoveredHcalHits")),
0181       useRejectedRecoveredEcalHits_(conf.getParameter<bool>("UseRejectedRecoveredEcalHits")),
0182       cutsFromDB(conf.getParameter<bool>("usePFThresholdsFromDB")),
0183       ecalRecHitThresh_(conf.getParameter<bool>("EcalRecHitThresh")) {
0184   algo_.setMissingHcalRescaleFactorForEcal(conf.getParameter<double>("missingHcalRescaleFactorForEcal"));
0185
0186   // register for data access
0187   tok_hbhe_ = consumes<HBHERecHitCollection>(conf.getParameter<edm::InputTag>("hbheInput"));
0188   tok_ho_ = consumes<HORecHitCollection>(conf.getParameter<edm::InputTag>("hoInput"));
0189   tok_hf_ = consumes<HFRecHitCollection>(conf.getParameter<edm::InputTag>("hfInput"));
0190   tok_geom_ = esConsumes<CaloGeometry, CaloGeometryRecord>();
0191   tok_topo_ = esConsumes<HcalTopology, HcalRecNumberingRecord>();
0192   tok_cttopo_ = esConsumes<CaloTowerTopology, HcalRecNumberingRecord>();
0193   tok_ctmap_ = esConsumes<CaloTowerConstituentsMap, CaloGeometryRecord>();
0194   tok_ecalChStatus_ = esConsumes<EcalChannelStatus, EcalChannelStatusRcd>();
0195   tok_hcalChStatus_ = esConsumes<HcalChannelQuality, HcalChannelQualityRcd>(edm::ESInputTag("", "withTopo"));
0196   tok_hcalSevComputer_ = esConsumes<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd>();
0197   tok_ecalSevAlgo_ = esConsumes<EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd>();
0198
0199   if (cutsFromDB) {
0200     hcalCutsToken_ = esConsumes<HcalPFCuts, HcalPFCutsRcd, edm::Transition::BeginRun>(edm::ESInputTag("", "withTopo"));
0201   }
0202
0203   if (ecalRecHitThresh_) {
0204     ecalPFRechitThresholdsToken_ =
0205         esConsumes<EcalPFRecHitThresholds, EcalPFRecHitThresholdsRcd, edm::Transition::BeginRun>();
0206   }
0207
0208   const unsigned nLabels = ecalLabels_.size();
0209   for (unsigned i = 0; i != nLabels; i++)
0210     toks_ecal_.push_back(consumes<EcalRecHitCollection>(ecalLabels_[i]));
0211
0212   EBEScale = eScales_.EBScale;
0213   EEEScale = eScales_.EEScale;
0214   HBEScale = eScales_.HBScale;
0215   HESEScale = eScales_.HESScale;
0216   HEDEScale = eScales_.HEDScale;
0217   HOEScale = eScales_.HOScale;
0218   HF1EScale = eScales_.HF1Scale;
0219   HF2EScale = eScales_.HF2Scale;
0220
0221   // get the Ecal severities to be excluded
0222   const std::vector<std::string> severitynames =
0223       conf.getParameter<std::vector<std::string> >("EcalRecHitSeveritiesToBeExcluded");
0224
0225   theEcalSeveritiesToBeExcluded_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynames);
0226
0227   // get the Ecal severities to be used for bad towers
0228   theEcalSeveritiesToBeUsedInBadTowers_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(
0229       conf.getParameter<std::vector<std::string> >("EcalSeveritiesToBeUsedInBadTowers"));
0230
0231   if (eScales_.instanceLabel.empty())
0232     produces<CaloTowerCollection>();
0233   else
0234     produces<CaloTowerCollection>(eScales_.instanceLabel);
0235
0236 #ifdef EDM_ML_DEBUG
0237   std::cout << "VI Producer " << (useRejectedHitsOnly_ ? "use rejectOnly " : " ")
0238             << (allowMissingInputs_ ? "allowMissing " : " ") << nLabels << ' ' << severitynames.size() << std::endl;
0239 #endif
0240 }
0241
0242 void CaloTowersCreator::beginRun(const edm::Run& run, const edm::EventSetup& es) {
0243   if (cutsFromDB) {
0244     paramPF = &es.getData(hcalCutsToken_);
0245   }
0246
0247   if (ecalRecHitThresh_) {
0248     ecalThresholds = &es.getData(ecalPFRechitThresholdsToken_);
0249   }
0250
0251   algo_.setThresFromDB(ecalThresholds, paramPF);
0252 }
0253
0254 void CaloTowersCreator::produce(edm::Event& e, const edm::EventSetup& c) {
0255   // get the necessary event setup objects...
0256   edm::ESHandle<CaloGeometry> pG = c.getHandle(tok_geom_);
0257   edm::ESHandle<HcalTopology> htopo = c.getHandle(tok_topo_);
0258   edm::ESHandle<CaloTowerTopology> cttopo = c.getHandle(tok_cttopo_);
0259   edm::ESHandle<CaloTowerConstituentsMap> ctmap = c.getHandle(tok_ctmap_);
0260
0261   // ECAL channel status map ****************************************
0262   edm::ESHandle<EcalChannelStatus> ecalChStatus = c.getHandle(tok_ecalChStatus_);
0263   const EcalChannelStatus* dbEcalChStatus = ecalChStatus.product();
0264
0265   // HCAL channel status map ****************************************
0266   edm::ESHandle<HcalChannelQuality> hcalChStatus = c.getHandle(tok_hcalChStatus_);
0267
0268   const HcalChannelQuality* dbHcalChStatus = hcalChStatus.product();
0269
0270   // Assignment of severity levels **********************************
0271   edm::ESHandle<HcalSeverityLevelComputer> hcalSevLvlComputerHndl = c.getHandle(tok_hcalSevComputer_);
0272   const HcalSeverityLevelComputer* hcalSevLvlComputer = hcalSevLvlComputerHndl.product();
0273
0274   edm::ESHandle<EcalSeverityLevelAlgo> ecalSevLvlAlgoHndl = c.getHandle(tok_ecalSevAlgo_);
0275   const EcalSeverityLevelAlgo* ecalSevLvlAlgo = ecalSevLvlAlgoHndl.product();
0276
0277   algo_.setEBEScale(EBEScale);
0278   algo_.setEEEScale(EEEScale);
0279   algo_.setHBEScale(HBEScale);
0280   algo_.setHESEScale(HESEScale);
0281   algo_.setHEDEScale(HEDEScale);
0282   algo_.setHOEScale(HOEScale);
0283   algo_.setHF1EScale(HF1EScale);
0284   algo_.setHF2EScale(HF2EScale);
0285   algo_.setGeometry(cttopo.product(), ctmap.product(), htopo.product(), pG.product());
0286
0287   // for treatment of problematic and anomalous cells
0288
0289   algo_.setHcalChStatusFromDB(dbHcalChStatus);
0290   algo_.setEcalChStatusFromDB(dbEcalChStatus);
0291
0292   algo_.setHcalAcceptSeverityLevel(theHcalAcceptSeverityLevel_);
0293   algo_.setEcalSeveritiesToBeExcluded(theEcalSeveritiesToBeExcluded_);
0294
0295   algo_.setRecoveredHcalHitsAreUsed(theRecoveredHcalHitsAreUsed_);
0296   algo_.setRecoveredEcalHitsAreUsed(theRecoveredEcalHitsAreUsed_);
0297
0298   algo_.setHcalSevLvlComputer(hcalSevLvlComputer);
0299   algo_.setEcalSevLvlAlgo(ecalSevLvlAlgo);
0300
0301   algo_.setUseRejectedHitsOnly(useRejectedHitsOnly_);
0302
0303   algo_.setHcalAcceptSeverityLevelForRejectedHit(theHcalAcceptSeverityLevelForRejectedHit_);
0304   algo_.SetEcalSeveritiesToBeUsedInBadTowers(theEcalSeveritiesToBeUsedInBadTowers_);
0305
0306   algo_.setUseRejectedRecoveredHcalHits(useRejectedRecoveredHcalHits_);
0307   algo_.setUseRejectedRecoveredEcalHits(useRejectedRecoveredEcalHits_);
0308
0309 #ifdef EDM_ML_DEBUG
0310   std::cout << "VI Produce: " << (useRejectedHitsOnly_ ? "use rejectOnly " : " ")
0311             << (allowMissingInputs_ ? "allowMissing " : " ")
0312             << (theRecoveredEcalHitsAreUsed_ ? "use RecoveredEcal " : " ") << toks_ecal_.size() << ' '
0313             << theEcalSeveritiesToBeExcluded_.size() << ' ' << theEcalSeveritiesToBeUsedInBadTowers_.size()
0314             << std::endl;
0315 #endif
0316
0317   algo_.begin();  // clear the internal buffer
0318
0319   // can't chain these in a big OR statement, or else it'll
0320   // get triggered for each of the first three events
0321   bool check1 = hcalSevLevelWatcher_.check(c);
0322   bool check2 = hcalChStatusWatcher_.check(c);
0323   bool check3 = caloTowerConstituentsWatcher_.check(c);
0324   if (check1 || check2 || check3) {
0325     algo_.makeHcalDropChMap();
0326   }
0327
0328   // check ecal SevLev
0329   if (ecalSevLevelWatcher_.check(c))
0330     algo_.makeEcalBadChs();
0331
0332   // ----------------------------------------------------------
0333   // For ecal error handling need to
0334   // have access to the EB and EE collections at the end of
0335   // tower reconstruction.
0336
0337   edm::Handle<EcalRecHitCollection> ebHandle;
0338   edm::Handle<EcalRecHitCollection> eeHandle;
0339
0340   for (std::vector<edm::EDGetTokenT<EcalRecHitCollection> >::const_iterator i = toks_ecal_.begin();
0341        i != toks_ecal_.end();
0342        i++) {
0343     edm::Handle<EcalRecHitCollection> ec_tmp;
0344
0345     if (!e.getByToken(*i, ec_tmp))
0346       continue;
0347     if (ec_tmp->empty())
0348       continue;
0349
0350     // check if this is EB or EE
0351     if ((ec_tmp->begin()->detid()).subdetId() == EcalBarrel) {
0352       ebHandle = ec_tmp;
0353     } else if ((ec_tmp->begin()->detid()).subdetId() == EcalEndcap) {
0354       eeHandle = ec_tmp;
0355     }
0356   }
0357
0358   algo_.setEbHandle(ebHandle);
0359   algo_.setEeHandle(eeHandle);
0360
0361   //-----------------------------------------------------------
0362
0363   bool present;
0364
0365   // Step A/C: Get Inputs and process (repeatedly)
0366   edm::Handle<HBHERecHitCollection> hbhe;
0367   present = e.getByToken(tok_hbhe_, hbhe);
0368   if (present || !allowMissingInputs_)
0369     algo_.process(*hbhe);
0370
0371   edm::Handle<HORecHitCollection> ho;
0372   present = e.getByToken(tok_ho_, ho);
0373   if (present || !allowMissingInputs_)
0374     algo_.process(*ho);
0375
0376   edm::Handle<HFRecHitCollection> hf;
0377   present = e.getByToken(tok_hf_, hf);
0378   if (present || !allowMissingInputs_)
0379     algo_.process(*hf);
0380
0381   std::vector<edm::EDGetTokenT<EcalRecHitCollection> >::const_iterator i;
0382   for (i = toks_ecal_.begin(); i != toks_ecal_.end(); i++) {
0383     edm::Handle<EcalRecHitCollection> ec;
0384     present = e.getByToken(*i, ec);
0385     if (present || !allowMissingInputs_)
0386       algo_.process(*ec);
0387   }
0388
0389   // Step B: Create empty output
0390   auto prod = std::make_unique<CaloTowerCollection>();
0391
0392   // Step C: Process
0393   algo_.finish(*prod);
0394
0395 #ifdef EDM_ML_DEBUG
0396   int totc = 0;
0397   float totE = 0;
0398   reco::LeafCandidate::LorentzVector totP4;
0399   for (auto const& tw : (*prod)) {
0400     totc += tw.constituents().size();
0401     totE += tw.energy();
0402     totP4 += tw.p4();
0403     std::cout << "CaloTowerCreator: " << tw.id() << " with E " << tw.energy() << " and " << tw.constituents().size()
0404               << " constituents\n";
0405   }
0406   std::cout << "VI " << (*prod).size() << " " << totc << " " << totE << " " << totP4 << std::endl;
0407 #endif
0408
0409   // Step D: Put into the event
0410   if (eScales_.instanceLabel.empty())
0411     e.put(std::move(prod));
0412   else
0413     e.put(std::move(prod), eScales_.instanceLabel);
0414 }
0415
0416 void CaloTowersCreator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0417   edm::ParameterSetDescription desc;
0418   desc.add<double>("EBSumThreshold", 0.2);
0419   desc.add<double>("HF2Weight", 1.0);
0420   desc.add<double>("EBWeight", 1.0);
0421   desc.add<double>("EESumThreshold", 0.45);
0422   desc.add<double>("HOThreshold0", 1.1);
0423   desc.add<double>("HOThresholdPlus1", 3.5);
0424   desc.add<double>("HOThresholdMinus1", 3.5);
0425   desc.add<double>("HOThresholdPlus2", 3.5);
0426   desc.add<double>("HOThresholdMinus2", 3.5);
0427   desc.add<double>("HBThreshold", 0.7);
0428   desc.add<double>("HBThreshold1", 0.7);
0429   desc.add<double>("HBThreshold2", 0.7);
0430   desc.add<double>("HF1Threshold", 0.5);
0431   desc.add<double>("HEDWeight", 1.0);
0432   desc.add<double>("EEWeight", 1.0);
0433   desc.add<double>("HESWeight", 1.0);
0434   desc.add<double>("HF1Weight", 1.0);
0435   desc.add<double>("HOWeight", 1.0);
0436   desc.add<double>("EBThreshold", 0.07);
0437   desc.add<double>("EEThreshold", 0.3);
0438   desc.add<double>("HcalThreshold", -1000.0);
0439   desc.add<double>("HF2Threshold", 0.85);
0440   desc.add<double>("HESThreshold", 0.8);
0441   desc.add<double>("HESThreshold1", 0.8);
0442   desc.add<double>("HEDThreshold", 0.8);
0443   desc.add<double>("HEDThreshold1", 0.8);
0444   desc.add<double>("EcutTower", -1000.0);
0445   desc.add<double>("HBWeight", 1.0);
0446   desc.add<double>("MomHBDepth", 0.2);
0447   desc.add<double>("MomHEDepth", 0.4);
0448   desc.add<double>("MomEBDepth", 0.3);
0449   desc.add<double>("MomEEDepth", 0.0);
0450   desc.add<bool>("UseHO", true);
0451   desc.add<bool>("UseEtEBTreshold", false);
0452   desc.add<bool>("UseSymEBTreshold", true);
0453   desc.add<bool>("UseEtEETreshold", false);
0454   desc.add<bool>("UseSymEETreshold", true);
0455   desc.add<bool>("UseHcalRecoveredHits", true);
0456   desc.add<bool>("UseEcalRecoveredHits", false);
0457   desc.add<bool>("UseRejectedHitsOnly", false);
0458   desc.add<bool>("UseRejectedRecoveredHcalHits", true);
0459   desc.add<bool>("UseRejectedRecoveredEcalHits", false);
0460   desc.add<double>("missingHcalRescaleFactorForEcal", 0.0);
0461   desc.add<bool>("AllowMissingInputs", false);
0462   desc.add<std::vector<double> >("HBGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0463   desc.add<std::vector<double> >("EEWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
0464   desc.add<std::vector<double> >("HF2Weights", {1.0, 1.0, 1.0, 1.0, 1.0});
0465   desc.add<std::vector<double> >("HOWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
0466   desc.add<std::vector<double> >("EEGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0467   desc.add<std::vector<double> >("HBWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
0468   desc.add<std::vector<double> >("HF2Grid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0469   desc.add<std::vector<double> >("HEDWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
0470   desc.add<std::vector<double> >("HF1Grid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0471   desc.add<std::vector<double> >("EBWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
0472   desc.add<std::vector<double> >("HF1Weights", {1.0, 1.0, 1.0, 1.0, 1.0});
0473   desc.add<std::vector<double> >("HESGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0474   desc.add<std::vector<double> >("HESWeights", {1.0, 1.0, 1.0, 1.0, 1.0});
0475   desc.add<std::vector<double> >("HEDGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0476   desc.add<std::vector<double> >("HOGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0477   desc.add<std::vector<double> >("EBGrid", {-1.0, 1.0, 10.0, 100.0, 1000.0});
0478   desc.add<edm::InputTag>("hfInput", edm::InputTag("hfreco"));
0479   desc.add<edm::InputTag>("hbheInput", edm::InputTag("hbhereco"));
0480   desc.add<edm::InputTag>("hoInput", edm::InputTag("horeco"));
0481   desc.add<std::vector<edm::InputTag> >(
0482       "ecalInputs", {edm::InputTag("ecalRecHit", "EcalRecHitsEB"), edm::InputTag("ecalRecHit", "EcalRecHitsEE")});
0483   desc.add<int>("MomConstrMethod", 1);
0484   desc.add<unsigned int>("HcalAcceptSeverityLevel", 9);
0485   desc.add<std::vector<std::string> >("EcalRecHitSeveritiesToBeExcluded", {"kTime", "kWeird", "kBad"});
0486   desc.add<unsigned int>("HcalAcceptSeverityLevelForRejectedHit", 9999);
0487   desc.add<std::vector<std::string> >("EcalSeveritiesToBeUsedInBadTowers", {});
0488   desc.add<int>("HcalPhase", 0);
0489   desc.add<bool>("usePFThresholdsFromDB", true);
0490   desc.add<bool>("EcalRecHitThresh", false);
0491   descriptions.addDefault(desc);
0492 }