diff --git a/Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalMinBias_cff.py b/Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalMinBias_cff.py index d787fb5195847..cb0585830e0b0 100644 --- a/Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalMinBias_cff.py +++ b/Calibration/HcalAlCaRecoProducers/python/ALCARECOHcalCalMinBias_cff.py @@ -107,6 +107,13 @@ ), ) +## remove uneeded paraemters sets because setNoiseFlags is False +for param in ['PETstat', 'S8S1stat', 'S9S1stat']: + if hasattr(_phase1_hfrecoNoise, param): + delattr(_phase1_hfrecoNoise, param) + if hasattr(_phase1_hfrecoMBNZS, param): + delattr(_phase1_hfrecoMBNZS, param) + _phase1_seqALCARECOHcalCalMinBias = seqALCARECOHcalCalMinBias.copy() _phase1_seqALCARECOHcalCalMinBias.insert(0,hfprerecoMBNZS) _phase1_seqALCARECOHcalCalMinBias.insert(0,hfprerecoNoise) diff --git a/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.cc b/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.cc index 50d3fa5136cf8..9a988ab8797cd 100644 --- a/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.cc +++ b/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.cc @@ -161,3 +161,23 @@ namespace sistrip { void RawToDigiModule::endStream() { rawToDigi_->printWarningSummary(); } } // namespace sistrip + +void sistrip::RawToDigiModule::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("ProductLabel", edm::InputTag("rawDataCollector")); + desc.add("AppendedBytes", 0); + desc.add("TriggerFedId", 0); + desc.add("LegacyUnpacker", false); + desc.add("UseDaqRegister", false); + desc.add("UseFedKey", false); + desc.add("UnpackBadChannels", false); + desc.add("MarkModulesOnMissingFeds", true); + desc.addUntracked("FedBufferDumpFreq", 0); + desc.addUntracked("FedEventDumpFreq", 0); + desc.addUntracked("Quiet", true); + desc.add("UnpackCommonModeValues", false); + desc.add("DoAllCorruptBufferChecks", false); + desc.add("DoAPVEmulatorCheck", false); + desc.add("ErrorThreshold", 7174); + descriptions.addWithDefaultLabel(desc); +} diff --git a/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.h b/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.h index 8a387c21b6baf..682cc98348618 100644 --- a/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.h +++ b/EventFilter/SiStripRawToDigi/plugins/SiStripRawToDigiModule.h @@ -1,14 +1,17 @@ #ifndef EventFilter_SiStripRawToDigi_SiStripRawToDigiModule_H #define EventFilter_SiStripRawToDigi_SiStripRawToDigiModule_H -#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "CondFormats/DataRecord/interface/SiStripFedCablingRcd.h" +#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h" +#include "FWCore/Framework/interface/ESWatcher.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/Framework/interface/ESWatcher.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/Utilities/interface/Visibility.h" -#include "CondFormats/DataRecord/interface/SiStripFedCablingRcd.h" + #include #include @@ -39,6 +42,8 @@ namespace sistrip { void produce(edm::Event&, const edm::EventSetup&) override; void endStream() override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: void updateCabling(const edm::EventSetup&); diff --git a/EventFilter/SiStripRawToDigi/python/SiStripDigis_cfi.py b/EventFilter/SiStripRawToDigi/python/SiStripDigis_cfi.py index 4e4e9b6e547c7..2ed96269214d8 100644 --- a/EventFilter/SiStripRawToDigi/python/SiStripDigis_cfi.py +++ b/EventFilter/SiStripRawToDigi/python/SiStripDigis_cfi.py @@ -1,21 +1,4 @@ import FWCore.ParameterSet.Config as cms -siStripDigis = cms.EDProducer( - "SiStripRawToDigiModule", - ProductLabel = cms.InputTag('rawDataCollector'), - LegacyUnpacker = cms.bool(False), - AppendedBytes = cms.int32(0), - UseDaqRegister = cms.bool(False), - UseFedKey = cms.bool(False), - UnpackBadChannels = cms.bool(False), - MarkModulesOnMissingFeds = cms.bool(True), - TriggerFedId = cms.int32(0), - #FedEventDumpFreq = cms.untracked.int32(0), - #FedBufferDumpFreq = cms.untracked.int32(0), - UnpackCommonModeValues = cms.bool(False), - DoAllCorruptBufferChecks = cms.bool(False), - DoAPVEmulatorCheck = cms.bool(False), - ErrorThreshold = cms.uint32(7174) - ) - - +from EventFilter.SiStripRawToDigi.siStripRawToDigiModule_cfi import siStripRawToDigiModule +siStripDigis = siStripRawToDigiModule.clone() diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltHfreco_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltHfreco_cfi.py index 34fd6bbf0454c..20ef308b6af8b 100644 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltHfreco_cfi.py +++ b/HLTrigger/Configuration/python/HLT_75e33/modules/hltHfreco_cfi.py @@ -1,17 +1,6 @@ import FWCore.ParameterSet.Config as cms hltHfreco = cms.EDProducer("HFPhase1Reconstructor", - HFStripFilter = cms.PSet( - gap = cms.int32(2), - lstrips = cms.int32(2), - maxStripTime = cms.double(10.0), - maxThreshold = cms.double(100.0), - seedHitIetaMax = cms.int32(35), - stripThreshold = cms.double(40.0), - timeMax = cms.double(6.0), - verboseLevel = cms.untracked.int32(10), - wedgeCut = cms.double(0.05) - ), PETstat = cms.PSet( HcalAcceptSeverityLevel = cms.int32(9), longETParams = cms.vdouble( diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltHoreco_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltHoreco_cfi.py index 8c39bfa3e8420..1d4803197d7f5 100644 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltHoreco_cfi.py +++ b/HLTrigger/Configuration/python/HLT_75e33/modules/hltHoreco_cfi.py @@ -1,18 +1,6 @@ import FWCore.ParameterSet.Config as cms hltHoreco = cms.EDProducer("HcalHitReconstructor", - HFInWindowStat = cms.PSet( - - ), - PETstat = cms.PSet( - - ), - S8S1stat = cms.PSet( - - ), - S9S1stat = cms.PSet( - - ), Subdetector = cms.string('HO'), correctForPhaseContainment = cms.bool(True), correctForTimeslew = cms.bool(True), @@ -21,27 +9,15 @@ dataOOTCorrectionCategory = cms.string('Data'), dataOOTCorrectionName = cms.string(''), digiLabel = cms.InputTag("hltHcalDigis"), - digiTimeFromDB = cms.bool(True), - digistat = cms.PSet( - - ), dropZSmarkedPassed = cms.bool(True), firstAuxTS = cms.int32(4), firstSample = cms.int32(4), - hfTimingTrustParameters = cms.PSet( - - ), mcOOTCorrectionCategory = cms.string('MC'), mcOOTCorrectionName = cms.string(''), recoParamsFromDB = cms.bool(True), samplesToAdd = cms.int32(4), - saturationParameters = cms.PSet( - maxADCvalue = cms.int32(127) - ), - setHSCPFlags = cms.bool(False), setNegativeFlags = cms.bool(False), setNoiseFlags = cms.bool(False), - setPulseShapeFlags = cms.bool(False), setSaturationFlags = cms.bool(False), setTimingTrustFlags = cms.bool(False), tsFromDB = cms.bool(True), diff --git a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py index 044f25fb963ef..dd28b63d73517 100644 --- a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py +++ b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py @@ -84,6 +84,49 @@ def customizeHLTfor47017(process): return process + +def customizeHLTfor47079(process): + """Remove unneeded parameters from the HLT menu""" + for filt in filters_by_type(process, 'PrimaryVertexObjectFilter'): + if hasattr(filt, 'filterParams') and hasattr(filt.filterParams, 'pvSrc'): + del filt.filterParams.pvSrc # Remove the pvSrc parameter + + for prod in producers_by_type(process, 'HcalHitReconstructor'): + # Remove "digiTimeFromDB" if "Subdetector" is not "HF" + if hasattr(prod, 'Subdetector') and getattr(prod, 'Subdetector') != "HF": + if hasattr(prod, 'digiTimeFromDB'): + delattr(prod, 'digiTimeFromDB') + + # Remove "saturationParameters" if "setSaturationFlags" is false + if hasattr(prod, 'setSaturationFlags') and not getattr(prod, 'setSaturationFlags'): + if hasattr(prod, 'saturationParameters'): + delattr(prod, 'saturationParameters') + + # Remove "hfTimingTrustParameters" if "setTimingTrustFlags" is false + if hasattr(prod, 'setTimingTrustFlags') and not getattr(prod, 'setTimingTrustFlags'): + if hasattr(prod, 'hfTimingTrustParameters'): + delattr(prod, 'hfTimingTrustParameters') + + # Remove 'PETstat', 'S8S1stat', 'S9S1stat', 'digistat' and 'HFInWindowStat' if "setNoiseFlags" is false + if hasattr(prod, 'setNoiseFlags') and not getattr(prod, 'setNoiseFlags'): + for param in ['PETstat', 'S8S1stat', 'S9S1stat', 'digistat', 'HFInWindowStat']: + if hasattr(prod, param): + delattr(prod, param) + + # Remove useless parameters + if hasattr(prod,'setHSCPFlags'): + delattr(prod,'setHSCPFlags') + + if hasattr(prod,'setPulseShapeFlags'): + delattr(prod,'setPulseShapeFlags') + + for prod in producers_by_type(process, 'HFPhase1Reconstructor'): + # Remove 'HFStripFilter' if "runHFStripFilter" is false + if hasattr(prod, 'runHFStripFilter') and not getattr(prod, 'runHFStripFilter'): + delattr(prod,'HFStripFilter') + + return process + # CMSSW version specific customizations def customizeHLTforCMSSW(process, menuType="GRun"): @@ -94,6 +137,7 @@ def customizeHLTforCMSSW(process, menuType="GRun"): process = customizeHLTfor46935(process) process = customizeHLTfor47017(process) - + process = customizeHLTfor47079(process) + return process diff --git a/PhysicsTools/SelectorUtils/interface/JetIDSelectionFunctor.h b/PhysicsTools/SelectorUtils/interface/JetIDSelectionFunctor.h index d68e885137c1e..45c8613f4e271 100644 --- a/PhysicsTools/SelectorUtils/interface/JetIDSelectionFunctor.h +++ b/PhysicsTools/SelectorUtils/interface/JetIDSelectionFunctor.h @@ -18,11 +18,13 @@ #ifndef __GCCXML__ #include "FWCore/Framework/interface/ConsumesCollector.h" #endif + #include "DataFormats/PatCandidates/interface/Jet.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" - -#include "PhysicsTools/SelectorUtils/interface/Selector.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "PhysicsTools/SelectorUtils/interface/Selector.h" #include class JetIDSelectionFunctor : public Selector { @@ -65,6 +67,13 @@ class JetIDSelectionFunctor : public Selector { } } + static edm::ParameterSetDescription getDescription() { + edm::ParameterSetDescription desc; + desc.add("version", std::string("")); + desc.add("quality", std::string("")); + return desc; + } + JetIDSelectionFunctor(Version_t version, Quality_t quality) { initialize(version, quality); } void initialize(Version_t version, Quality_t quality) { diff --git a/PhysicsTools/SelectorUtils/interface/PVObjectSelector.h b/PhysicsTools/SelectorUtils/interface/PVObjectSelector.h index 473abcd6dc06f..f4b6f925d9b3e 100644 --- a/PhysicsTools/SelectorUtils/interface/PVObjectSelector.h +++ b/PhysicsTools/SelectorUtils/interface/PVObjectSelector.h @@ -10,6 +10,9 @@ #include "PhysicsTools/SelectorUtils/interface/Selector.h" #include "DataFormats/VertexReco/interface/Vertex.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + #include #include @@ -34,8 +37,9 @@ class PVObjectSelector : public Selector { indexZ_ = index_type(&bits_, "PV Z"); indexRho_ = index_type(&bits_, "PV RHO"); - if (params.exists("cutsToIgnore")) - setIgnoredCuts(params.getParameter >("cutsToIgnore")); + const auto& cutsToIgnore{params.getParameter >("cutsToIgnore")}; + if (!cutsToIgnore.empty()) + setIgnoredCuts(cutsToIgnore); retInternal_ = getBitTemplate(); } @@ -59,6 +63,15 @@ class PVObjectSelector : public Selector { return (bool)ret; } + static edm::ParameterSetDescription getDescription() { + edm::ParameterSetDescription desc; + desc.add("minNdof", 4.0); + desc.add("maxZ", 24.0); + desc.add("maxRho", 2.0); + desc.add >("cutsToIgnore", {}); + return desc; + } + using Selector::operator(); private: diff --git a/PhysicsTools/SelectorUtils/interface/PVSelector.h b/PhysicsTools/SelectorUtils/interface/PVSelector.h index 0d1a902c0918a..8776bba8e7df9 100644 --- a/PhysicsTools/SelectorUtils/interface/PVSelector.h +++ b/PhysicsTools/SelectorUtils/interface/PVSelector.h @@ -10,6 +10,9 @@ #include "PhysicsTools/SelectorUtils/interface/EventSelector.h" #include "PhysicsTools/SelectorUtils/interface/PVObjectSelector.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + // make a selector for this selection class PVSelector : public Selector { public: @@ -28,6 +31,13 @@ class PVSelector : public Selector { } #endif + static edm::ParameterSetDescription getDescription() { + edm::ParameterSetDescription desc = PVObjectSelector::getDescription(); + desc.add("pvSrc", edm::InputTag("")); + desc.add("NPV", 1); + return desc; + } + bool operator()(edm::EventBase const& event, pat::strbitset& ret) override { ret.set(false); event.getByLabel(pvSrc_, h_primVtx); diff --git a/PhysicsTools/UtilAlgos/interface/EDFilterObjectWrapper.h b/PhysicsTools/UtilAlgos/interface/EDFilterObjectWrapper.h index 648817bede047..b197af5c2f61d 100644 --- a/PhysicsTools/UtilAlgos/interface/EDFilterObjectWrapper.h +++ b/PhysicsTools/UtilAlgos/interface/EDFilterObjectWrapper.h @@ -39,7 +39,9 @@ #include "FWCore/Framework/interface/stream/EDFilter.h" #include "FWCore/Common/interface/EventBase.h" #include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" namespace edm { @@ -51,17 +53,14 @@ namespace edm { typename C::const_iterator const_iterator; /// default contructor. Declares the output (type "C") and the filter (of type T, operates on C::value_type) - FilterObjectWrapper(const edm::ParameterSet& cfg) : src_(consumes(cfg.getParameter("src"))) { + FilterObjectWrapper(const edm::ParameterSet& cfg) + : src_(consumes(cfg.getParameter("src"))), doFilter_(cfg.getParameter("filter")) { filter_ = std::shared_ptr(new T(cfg.getParameter("filterParams"))); - if (cfg.exists("filter")) { - doFilter_ = cfg.getParameter("filter"); - } else { - doFilter_ = false; - } produces(); } /// default destructor - ~FilterObjectWrapper() override {} + ~FilterObjectWrapper() override = default; + /// everything which has to be done during the event loop. NOTE: We can't use the eventSetup in FWLite so ignore it bool filter(edm::Event& event, const edm::EventSetup& eventSetup) override { // create a collection of the objects to put into the event @@ -84,13 +83,21 @@ namespace edm { return true; } + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag(""))->setComment("input collection"); + desc.add("filterParams", T::getDescription()); + desc.add("filter", false); + descriptions.addWithDefaultLabel(desc); + } + protected: /// InputTag of the input source - edm::EDGetTokenT src_; + const edm::EDGetTokenT src_; + /// whether or not to filter based on size + const bool doFilter_; /// shared pointer to analysis class of type BasicAnalyzer std::shared_ptr filter_; - /// whether or not to filter based on size - bool doFilter_; }; } // namespace edm diff --git a/PhysicsTools/UtilAlgos/interface/EDFilterWrapper.h b/PhysicsTools/UtilAlgos/interface/EDFilterWrapper.h index 969c7f4fa6ada..fad43d0a7dc0c 100644 --- a/PhysicsTools/UtilAlgos/interface/EDFilterWrapper.h +++ b/PhysicsTools/UtilAlgos/interface/EDFilterWrapper.h @@ -37,6 +37,9 @@ #include "CommonTools/UtilAlgos/interface/TFileService.h" #include "FWCore/Common/interface/EventBase.h" #include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" namespace edm { @@ -54,6 +57,11 @@ namespace edm { return (*filter_)(eventBaseConst); } + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc = T::getDescription(); + descriptions.addWithDefaultLabel(desc); + } + protected: /// shared pointer to analysis class of type BasicAnalyzer std::shared_ptr filter_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecalibRecHitProducer.cc index ee866d58aa147..33ccac45708dc 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalRecalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalRecalibRecHitProducer.cc @@ -26,6 +26,7 @@ #include "FWCore/Utilities/interface/ESGetToken.h" #include "RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitAbsAlgo.h" #include "RecoLocalCalo/EcalRecAlgos/interface/EcalRecHitSimpleAlgo.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include #include @@ -36,6 +37,8 @@ class EcalRecalibRecHitProducer : public edm::global::EDProducer<> { explicit EcalRecalibRecHitProducer(const edm::ParameterSet& ps); void produce(edm::StreamID sid, edm::Event& evt, const edm::EventSetup& es) const override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: const edm::InputTag EBRecHitCollection_; const edm::InputTag EERecHitCollection_; @@ -210,5 +213,20 @@ void EcalRecalibRecHitProducer::produce(edm::StreamID sid, edm::Event& evt, cons evt.put(std::move(EERecalibRecHits), EERecalibRecHitCollection_); } +void EcalRecalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("EBRecHitCollection", edm::InputTag("ecalRecHit", "EcalRecHitsEB")); + desc.add("EERecHitCollection", edm::InputTag("ecalRecHit", "EcalRecHitsEE")); + desc.add("EBRecalibRecHitCollection", "EcalRecHitsEB"); + desc.add("EERecalibRecHitCollection", "EcalRecHitsEE"); + desc.add("doEnergyScale", false); + desc.add("doIntercalib", false); + desc.add("doLaserCorrections", false); + desc.add("doEnergyScaleInverse", false); + desc.add("doIntercalibInverse", false); + desc.add("doLaserCorrectionsInverse", false); + descriptions.addWithDefaultLabel(desc); +} + #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(EcalRecalibRecHitProducer); diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalRecalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalRecalibRecHit_cfi.py index 31aeee702e32c..749ac80a20608 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalRecalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalRecalibRecHit_cfi.py @@ -1,15 +1,5 @@ import FWCore.ParameterSet.Config as cms # re-calibrated rechit producer -ecalRecHit = cms.EDProducer("EcalRecalibRecHitProducer", - doEnergyScale = cms.bool(False), - doEnergyScaleInverse = cms.bool(False), - doIntercalib = cms.bool(False), - doIntercalibInverse = cms.bool(False), - EERecHitCollection = cms.InputTag("ecalRecHit","EcalRecHitsEE"), - EBRecHitCollection = cms.InputTag("ecalRecHit","EcalRecHitsEB"), - doLaserCorrections = cms.bool(False), - doLaserCorrectionsInverse = cms.bool(False), - EBRecalibRecHitCollection = cms.string('EcalRecHitsEB'), - EERecalibRecHitCollection = cms.string('EcalRecHitsEE') -) +from RecoLocalCalo.EcalRecProducers.ecalRecalibRecHitProducer_cfi import ecalRecalibRecHitProducer +ecalRecHit = ecalRecalibRecHitProducer.clone() diff --git a/RecoLocalCalo/HcalRecAlgos/interface/HcalHFStatusBitFromDigis.h b/RecoLocalCalo/HcalRecAlgos/interface/HcalHFStatusBitFromDigis.h index 53f684a2e6c58..76e942081b34b 100644 --- a/RecoLocalCalo/HcalRecAlgos/interface/HcalHFStatusBitFromDigis.h +++ b/RecoLocalCalo/HcalRecAlgos/interface/HcalHFStatusBitFromDigis.h @@ -1,12 +1,14 @@ #ifndef HCALHFSTATUSFROMDIGIS_H #define HCALHFSTATUSFROMDIGIS_H 1 +#include "CalibFormats/HcalObjects/interface/HcalCalibrations.h" +#include "CalibFormats/HcalObjects/interface/HcalCoderDb.h" #include "DataFormats/HcalDigi/interface/HFDataFrame.h" #include "DataFormats/HcalRecHit/interface/HFRecHit.h" #include "DataFormats/METReco/interface/HcalCaloFlagLabels.h" -#include "CalibFormats/HcalObjects/interface/HcalCalibrations.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "CalibFormats/HcalObjects/interface/HcalCoderDb.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" /** \class HcalHFStatusBitFromDigis @@ -29,6 +31,9 @@ class HcalHFStatusBitFromDigis { int firstSample, int samplesToAdd, int expectedPeak, double minthreshold, const std::vector& coef); void resetFlagTimeSamples(int firstSample, int samplesToAdd, int expectedPeak); + static void fillHFDigiTimeParamsDesc(edm::ParameterSetDescription& desc); + static void fillHFTimeInWindowParamsDesc(edm::ParameterSetDescription& desc); + private: // variables for cfg files diff --git a/RecoLocalCalo/HcalRecAlgos/src/HcalHFStatusBitFromDigis.cc b/RecoLocalCalo/HcalRecAlgos/src/HcalHFStatusBitFromDigis.cc index b6dca0a15a77f..fb15744461eee 100644 --- a/RecoLocalCalo/HcalRecAlgos/src/HcalHFStatusBitFromDigis.cc +++ b/RecoLocalCalo/HcalRecAlgos/src/HcalHFStatusBitFromDigis.cc @@ -50,6 +50,23 @@ HcalHFStatusBitFromDigis::HcalHFStatusBitFromDigis(const edm::ParameterSet& HFDi HFshortwindowEthresh_ = HFTimeInWindowParams.getParameter("hfshortEthresh"); } +void HcalHFStatusBitFromDigis::fillHFDigiTimeParamsDesc(edm::ParameterSetDescription& desc) { + desc.add("HFdigiflagFirstSample", 1); + desc.add("HFdigiflagSamplesToAdd", 1); + desc.add("HFdigiflagExpectedPeak", 2); + desc.add("HFdigiflagMinEthreshold", {40}); + desc.add >("HFdigiflagCoef", {0.93, -0.38275, -0.012667}); +} + +void HcalHFStatusBitFromDigis::fillHFTimeInWindowParamsDesc(edm::ParameterSetDescription& desc) { + desc.add >("hflongMinWindowTime", {-10.}); + desc.add >("hflongMaxWindowTime", {10.}); + desc.add("hflongEthresh", 40.); + desc.add >("hfshortMinWindowTime", {-12.}); + desc.add >("hfshortMaxWindowTime", {10.}); + desc.add("hfshortEthresh", 40.); +} + HcalHFStatusBitFromDigis::~HcalHFStatusBitFromDigis() {} void HcalHFStatusBitFromDigis::resetParamsFromDB( diff --git a/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_hf_cfi.py b/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_hf_cfi.py index dfb16aa17f538..1e4c3beaf74f8 100644 --- a/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_hf_cfi.py +++ b/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_hf_cfi.py @@ -25,10 +25,8 @@ # Tags for calculating status flags setNoiseFlags = cms.bool(True), digiTimeFromDB = cms.bool(True), # turn on to read parameters from DB - setHSCPFlags = cms.bool( False ), setSaturationFlags = cms.bool(True), setTimingTrustFlags = cms.bool(True), - setPulseShapeFlags = cms.bool(False), # not yet defined for HF setNegativeFlags = cms.bool(False), # only in HBHE digistat= cms.PSet(HFdigiflagFirstSample = cms.int32(1), # These may be different from samples used for reconstruction diff --git a/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_ho_cfi.py b/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_ho_cfi.py index 41e7188f6b66d..5a92ea3824ee5 100644 --- a/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_ho_cfi.py +++ b/RecoLocalCalo/HcalRecProducers/python/HcalHitReconstructor_ho_cfi.py @@ -24,11 +24,9 @@ #Tags for calculating status flags correctTiming = cms.bool(True), - setNoiseFlags = cms.bool(True), - setHSCPFlags = cms.bool(True), # HSCP not implemented for horeco; this boolean does nothing + setNoiseFlags = cms.bool(False), # noise flags only implemented for HF setSaturationFlags = cms.bool(True), setTimingTrustFlags = cms.bool(False), # timing flags currently only implemented for HF - setPulseShapeFlags = cms.bool(False), # not yet defined for HO setNegativeFlags = cms.bool(False), # only in HBHE saturationParameters= cms.PSet(maxADCvalue=cms.int32(127)) ) # horeco diff --git a/RecoLocalCalo/HcalRecProducers/python/hfprereco_cfi.py b/RecoLocalCalo/HcalRecProducers/python/hfprereco_cfi.py index f47a308d3bc8c..46d8757fae382 100644 --- a/RecoLocalCalo/HcalRecProducers/python/hfprereco_cfi.py +++ b/RecoLocalCalo/HcalRecProducers/python/hfprereco_cfi.py @@ -31,11 +31,13 @@ # to "True". In this case the SOI configuration is ignored, and the energy # is accumulated using all time slices in the data frame. # -hfprereco = cms.EDProducer("HFPreReconstructor", - digiLabel = cms.InputTag("hcalDigis"), - dropZSmarkedPassed = cms.bool(False), - tsFromDB = cms.bool(False), - sumAllTimeSlices = cms.bool(False), - forceSOI = cms.int32(-1), - soiShift = cms.int32(0) + +from RecoLocalCalo.HcalRecProducers.hfPreReconstructor_cfi import hfPreReconstructor +hfprereco = hfPreReconstructor.clone( + digiLabel = "hcalDigis", + dropZSmarkedPassed = False, + tsFromDB = False, + sumAllTimeSlices = False, + forceSOI = -1, + soiShift = 0 ) diff --git a/RecoLocalCalo/HcalRecProducers/src/HFPhase1Reconstructor.cc b/RecoLocalCalo/HcalRecProducers/src/HFPhase1Reconstructor.cc index 2b44c1e4ad372..2d3f3ce12fb71 100644 --- a/RecoLocalCalo/HcalRecProducers/src/HFPhase1Reconstructor.cc +++ b/RecoLocalCalo/HcalRecProducers/src/HFPhase1Reconstructor.cc @@ -19,11 +19,12 @@ // system include files // user include files +#include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/EmptyGroupDescription.h" #include "FWCore/Utilities/interface/ESGetToken.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/Utilities/interface/Exception.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" @@ -53,7 +54,7 @@ class HFPhase1Reconstructor : public edm::stream::EDProducer<> { public: explicit HFPhase1Reconstructor(const edm::ParameterSet&); - ~HFPhase1Reconstructor() override; + ~HFPhase1Reconstructor() override = default; static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); @@ -112,35 +113,35 @@ HFPhase1Reconstructor::HFPhase1Reconstructor(const edm::ParameterSet& conf) // Configure the noise cleanup algorithms if (setNoiseFlags_) { const edm::ParameterSet& psS9S1 = conf.getParameter("S9S1stat"); - hfS9S1_ = std::make_unique(psS9S1.getParameter >("short_optimumSlope"), - psS9S1.getParameter >("shortEnergyParams"), - psS9S1.getParameter >("shortETParams"), - psS9S1.getParameter >("long_optimumSlope"), - psS9S1.getParameter >("longEnergyParams"), - psS9S1.getParameter >("longETParams"), + hfS9S1_ = std::make_unique(psS9S1.getParameter>("short_optimumSlope"), + psS9S1.getParameter>("shortEnergyParams"), + psS9S1.getParameter>("shortETParams"), + psS9S1.getParameter>("long_optimumSlope"), + psS9S1.getParameter>("longEnergyParams"), + psS9S1.getParameter>("longETParams"), psS9S1.getParameter("HcalAcceptSeverityLevel"), psS9S1.getParameter("isS8S1")); const edm::ParameterSet& psS8S1 = conf.getParameter("S8S1stat"); - hfS8S1_ = std::make_unique(psS8S1.getParameter >("short_optimumSlope"), - psS8S1.getParameter >("shortEnergyParams"), - psS8S1.getParameter >("shortETParams"), - psS8S1.getParameter >("long_optimumSlope"), - psS8S1.getParameter >("longEnergyParams"), - psS8S1.getParameter >("longETParams"), + hfS8S1_ = std::make_unique(psS8S1.getParameter>("short_optimumSlope"), + psS8S1.getParameter>("shortEnergyParams"), + psS8S1.getParameter>("shortETParams"), + psS8S1.getParameter>("long_optimumSlope"), + psS8S1.getParameter>("longEnergyParams"), + psS8S1.getParameter>("longETParams"), psS8S1.getParameter("HcalAcceptSeverityLevel"), psS8S1.getParameter("isS8S1")); const edm::ParameterSet& psPET = conf.getParameter("PETstat"); - hfPET_ = std::make_unique(psPET.getParameter >("short_R"), - psPET.getParameter >("shortEnergyParams"), - psPET.getParameter >("shortETParams"), - psPET.getParameter >("long_R"), - psPET.getParameter >("longEnergyParams"), - psPET.getParameter >("longETParams"), + hfPET_ = std::make_unique(psPET.getParameter>("short_R"), + psPET.getParameter>("shortEnergyParams"), + psPET.getParameter>("shortETParams"), + psPET.getParameter>("long_R"), + psPET.getParameter>("longEnergyParams"), + psPET.getParameter>("longETParams"), psPET.getParameter("HcalAcceptSeverityLevel"), - psPET.getParameter >("short_R_29"), - psPET.getParameter >("long_R_29")); + psPET.getParameter>("short_R_29"), + psPET.getParameter>("long_R_29")); // Configure HFStripFilter if (runHFStripFilter_) { @@ -161,11 +162,6 @@ HFPhase1Reconstructor::HFPhase1Reconstructor(const edm::ParameterSet& conf) sevToken_ = esConsumes(); } -HFPhase1Reconstructor::~HFPhase1Reconstructor() { - // do anything here that needs to be done at destruction time - // (e.g. close files, deallocate resources etc.) -} - void HFPhase1Reconstructor::beginRun(const edm::Run& r, const edm::EventSetup& es) { if (reco_->isConfigurable()) { recoConfig_ = std::make_unique(es.getData(recoConfigToken_)); @@ -271,29 +267,100 @@ void HFPhase1Reconstructor::produce(edm::Event& e, const edm::EventSetup& eventS e.put(std::move(rec)); } -#define add_param_set(name) /**/ \ - edm::ParameterSetDescription name; \ - name.setAllowAnything(); \ - desc.add(#name, name) - // ------------ method fills 'descriptions' with the allowed parameters for the module ------------ void HFPhase1Reconstructor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("inputLabel"); - desc.add("algoConfigClass"); - desc.add("setNoiseFlags"); - desc.add("runHFStripFilter", false); - desc.add("useChannelQualityFromDB"); - desc.add("checkChannelQualityForDepth3and4"); - desc.add("algorithm", fillDescriptionForParseHFPhase1AlgoDescription()); - desc.add("HFStripFilter", HFStripFilter::fillDescription()); + desc.add("inputLabel", edm::InputTag("hfprereco")) + ->setComment("Label for the input HFPreRecHitCollection"); + desc.add("algoConfigClass", "HFPhase1PMTParams") + ->setComment("reconstruction algorithm data to fetch from DB, if any"); + desc.add("useChannelQualityFromDB", true) + ->setComment("change the following to True in order to use the channel status from the DB"); + desc.add("checkChannelQualityForDepth3and4", true); + desc.add("algorithm", fillDescriptionForParseHFPhase1AlgoDescription()) + ->setComment("configure the reconstruction algorithm"); + + desc.ifValue( + edm::ParameterDescription("runHFStripFilter", true, true), + false >> edm::EmptyGroupDescription() or true >> edm::ParameterDescription( + "HFStripFilter", HFStripFilter::fillDescription(), true)); + + { + // Define common vectors + std::vector slopes_S9S1_run1 = {-99999, + 0.0164905, + 0.0238698, + 0.0321383, + 0.041296, + 0.0513428, + 0.0622789, + 0.0741041, + 0.0868186, + 0.100422, + 0.135313, + 0.136289, + 0.0589927}; + std::vector coeffs = {1.0, 2.5, 2.2, 2.0, 1.8, 1.6, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0}; + std::vector slopes_S9S1_run2(slopes_S9S1_run1.size()); + for (size_t i = 0; i < slopes_S9S1_run1.size(); ++i) { + slopes_S9S1_run2[i] = slopes_S9S1_run1[i] * coeffs[i]; + } - add_param_set(S9S1stat); - add_param_set(S8S1stat); - add_param_set(PETstat); + // S9S1stat configuration + edm::ParameterSetDescription S9S1statDesc; + S9S1statDesc.add>("short_optimumSlope", slopes_S9S1_run2); + S9S1statDesc.add>( + "shortEnergyParams", + {35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093}); + S9S1statDesc.add>("shortETParams", std::vector(13, 0)); + S9S1statDesc.add>("long_optimumSlope", slopes_S9S1_run2); + S9S1statDesc.add>( + "longEnergyParams", {43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62}); + S9S1statDesc.add>("longETParams", std::vector(13, 0)); + S9S1statDesc.add("HcalAcceptSeverityLevel", 9); + S9S1statDesc.add("isS8S1", false); + + // S8S1stat configuration + edm::ParameterSetDescription S8S1statDesc; + S8S1statDesc.add>( + "short_optimumSlope", {0.30, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10}); + S8S1statDesc.add>("shortEnergyParams", + {40, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100}); + S8S1statDesc.add>("shortETParams", std::vector(13, 0)); + S8S1statDesc.add>( + "long_optimumSlope", {0.30, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10}); + S8S1statDesc.add>("longEnergyParams", + {40, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100}); + S8S1statDesc.add>("longETParams", std::vector(13, 0)); + S8S1statDesc.add("HcalAcceptSeverityLevel", 9); + S8S1statDesc.add("isS8S1", true); + + // PETstat configuration + edm::ParameterSetDescription PETstatDesc; + PETstatDesc.add>("short_R", {0.8}); + PETstatDesc.add>( + "shortEnergyParams", + {35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093}); + PETstatDesc.add>("shortETParams", std::vector(13, 0)); + PETstatDesc.add>("long_R", {0.98}); + PETstatDesc.add>( + "longEnergyParams", {43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62}); + PETstatDesc.add>("longETParams", std::vector(13, 0)); + PETstatDesc.add>("short_R_29", {0.8}); + PETstatDesc.add>("long_R_29", {0.8}); + PETstatDesc.add("HcalAcceptSeverityLevel", 9); + + // Conditionally add S9S1stat if setNoiseFlags is true + desc.ifValue( + edm::ParameterDescription("setNoiseFlags", true, true), + false >> edm::EmptyGroupDescription() or + true >> (edm::ParameterDescription("S9S1stat", S9S1statDesc, true) and + edm::ParameterDescription("S8S1stat", S8S1statDesc, true) and + edm::ParameterDescription("PETstat", PETstatDesc, true))); + } - descriptions.addDefault(desc); + descriptions.addWithDefaultLabel(desc); } //define this as a plug-in diff --git a/RecoLocalCalo/HcalRecProducers/src/HFPreReconstructor.cc b/RecoLocalCalo/HcalRecProducers/src/HFPreReconstructor.cc index ff751d2e830e5..c0d644e84e0ad 100644 --- a/RecoLocalCalo/HcalRecProducers/src/HFPreReconstructor.cc +++ b/RecoLocalCalo/HcalRecProducers/src/HFPreReconstructor.cc @@ -265,14 +265,14 @@ void HFPreReconstructor::produce(edm::Event& e, const edm::EventSetup& eventSetu void HFPreReconstructor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("digiLabel"); + desc.add("digiLabel", edm::InputTag("hcalDigis")); desc.add("forceSOI", -1); desc.add("soiShift", 0); - desc.add("dropZSmarkedPassed"); - desc.add("tsFromDB"); - desc.add("sumAllTimeSlices"); + desc.add("dropZSmarkedPassed", false); + desc.add("tsFromDB", false); + desc.add("sumAllTimeSlices", false); - descriptions.addDefault(desc); + descriptions.addWithDefaultLabel(desc); } //define this as a plug-in diff --git a/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.cc b/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.cc index dcceefd8ffcf2..858e0a023d320 100644 --- a/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.cc +++ b/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.cc @@ -4,6 +4,7 @@ #include "DataFormats/Common/interface/Handle.h" #include "FWCore/Framework/interface/ConsumesCollector.h" #include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/ParameterSet/interface/EmptyGroupDescription.h" #include "CalibFormats/HcalObjects/interface/HcalCoderDb.h" #include "CalibFormats/HcalObjects/interface/HcalDbRecord.h" #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSeverityLevelComputer.h" @@ -32,11 +33,9 @@ HcalHitReconstructor::HcalHitReconstructor(edm::ParameterSet const& conf) inputLabel_(conf.getParameter("digiLabel")), correctTiming_(conf.getParameter("correctTiming")), setNoiseFlags_(conf.getParameter("setNoiseFlags")), - setHSCPFlags_(conf.getParameter("setHSCPFlags")), setSaturationFlags_(conf.getParameter("setSaturationFlags")), setTimingTrustFlags_(conf.getParameter("setTimingTrustFlags")), - setPulseShapeFlags_(conf.getParameter("setPulseShapeFlags")), - setNegativeFlags_(false), + setNegativeFlags_(conf.getParameter("setNegativeFlags")), dropZSmarkedPassed_(conf.getParameter("dropZSmarkedPassed")), firstAuxTS_(conf.getParameter("firstAuxTS")), firstSample_(conf.getParameter("firstSample")), @@ -64,9 +63,6 @@ HcalHitReconstructor::HcalHitReconstructor(edm::ParameterSet const& conf) // std::cout<<" HcalHitReconstructor recoParamsFromDB_ "<("setNegativeFlags")) - setNegativeFlags_ = conf.getParameter("setNegativeFlags"); - hfdigibit_ = nullptr; hfS9S1_ = nullptr; @@ -104,35 +100,35 @@ HcalHitReconstructor::HcalHitReconstructor(edm::ParameterSet const& conf) hfdigibit_ = new HcalHFStatusBitFromDigis(psdigi, psTimeWin); const edm::ParameterSet& psS9S1 = conf.getParameter("S9S1stat"); - hfS9S1_ = new HcalHF_S9S1algorithm(psS9S1.getParameter >("short_optimumSlope"), - psS9S1.getParameter >("shortEnergyParams"), - psS9S1.getParameter >("shortETParams"), - psS9S1.getParameter >("long_optimumSlope"), - psS9S1.getParameter >("longEnergyParams"), - psS9S1.getParameter >("longETParams"), + hfS9S1_ = new HcalHF_S9S1algorithm(psS9S1.getParameter>("short_optimumSlope"), + psS9S1.getParameter>("shortEnergyParams"), + psS9S1.getParameter>("shortETParams"), + psS9S1.getParameter>("long_optimumSlope"), + psS9S1.getParameter>("longEnergyParams"), + psS9S1.getParameter>("longETParams"), psS9S1.getParameter("HcalAcceptSeverityLevel"), psS9S1.getParameter("isS8S1")); const edm::ParameterSet& psS8S1 = conf.getParameter("S8S1stat"); - hfS8S1_ = new HcalHF_S9S1algorithm(psS8S1.getParameter >("short_optimumSlope"), - psS8S1.getParameter >("shortEnergyParams"), - psS8S1.getParameter >("shortETParams"), - psS8S1.getParameter >("long_optimumSlope"), - psS8S1.getParameter >("longEnergyParams"), - psS8S1.getParameter >("longETParams"), + hfS8S1_ = new HcalHF_S9S1algorithm(psS8S1.getParameter>("short_optimumSlope"), + psS8S1.getParameter>("shortEnergyParams"), + psS8S1.getParameter>("shortETParams"), + psS8S1.getParameter>("long_optimumSlope"), + psS8S1.getParameter>("longEnergyParams"), + psS8S1.getParameter>("longETParams"), psS8S1.getParameter("HcalAcceptSeverityLevel"), psS8S1.getParameter("isS8S1")); const edm::ParameterSet& psPET = conf.getParameter("PETstat"); - hfPET_ = new HcalHF_PETalgorithm(psPET.getParameter >("short_R"), - psPET.getParameter >("shortEnergyParams"), - psPET.getParameter >("shortETParams"), - psPET.getParameter >("long_R"), - psPET.getParameter >("longEnergyParams"), - psPET.getParameter >("longETParams"), + hfPET_ = new HcalHF_PETalgorithm(psPET.getParameter>("short_R"), + psPET.getParameter>("shortEnergyParams"), + psPET.getParameter>("shortETParams"), + psPET.getParameter>("long_R"), + psPET.getParameter>("longEnergyParams"), + psPET.getParameter>("longETParams"), psPET.getParameter("HcalAcceptSeverityLevel"), - psPET.getParameter >("short_R_29"), - psPET.getParameter >("long_R_29")); + psPET.getParameter>("short_R_29"), + psPET.getParameter>("long_R_29")); } produces(); } else if (!strcasecmp(subd.c_str(), "ZDC")) { @@ -150,14 +146,10 @@ HcalHitReconstructor::HcalHitReconstructor(edm::ParameterSet const& conf) // If no valid OOT pileup correction name specified, // disable the correction - if (conf.existsAs("dataOOTCorrectionName")) - dataOOTCorrectionName_ = conf.getParameter("dataOOTCorrectionName"); - if (conf.existsAs("dataOOTCorrectionCategory")) - dataOOTCorrectionCategory_ = conf.getParameter("dataOOTCorrectionCategory"); - if (conf.existsAs("mcOOTCorrectionName")) - mcOOTCorrectionName_ = conf.getParameter("mcOOTCorrectionName"); - if (conf.existsAs("mcOOTCorrectionCategory")) - mcOOTCorrectionCategory_ = conf.getParameter("mcOOTCorrectionCategory"); + dataOOTCorrectionName_ = conf.getParameter("dataOOTCorrectionName"); + dataOOTCorrectionCategory_ = conf.getParameter("dataOOTCorrectionCategory"); + mcOOTCorrectionName_ = conf.getParameter("mcOOTCorrectionName"); + mcOOTCorrectionCategory_ = conf.getParameter("mcOOTCorrectionCategory"); if (dataOOTCorrectionName_.empty() && mcOOTCorrectionName_.empty()) setPileupCorrection_ = nullptr; @@ -518,3 +510,137 @@ void HcalHitReconstructor::produce(edm::Event& e, const edm::EventSetup& eventSe } //DL delete myqual; } // void HcalHitReconstructor::produce(...) + +void HcalHitReconstructor::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("correctForTimeslew", false); + desc.add("correctForPhaseContainment", false); + desc.add("correctionPhaseNS", 13.0); + desc.add("digiLabel", edm::InputTag("hcalDigis")); + desc.add("correctTiming", true); + desc.add("dropZSmarkedPassed", true); + desc.add("firstAuxTS", 1); + desc.add("firstSample", 2); + desc.add("samplesToAdd", 1); + desc.add("tsFromDB", true); + desc.add("useLeakCorrection", false); + desc.add("recoParamsFromDB", true); + desc.add("setNegativeFlags", false); + + edm::ParameterSetDescription saturationParametersDesc; + saturationParametersDesc.add("maxADCvalue", 127); + + // Conditionally add saturationParameters if setSaturationFlags is true + desc.ifValue( + edm::ParameterDescription("setSaturationFlags", true, true), + false >> edm::EmptyGroupDescription() or true >> edm::ParameterDescription( + "saturationParameters", saturationParametersDesc, true)); + + // Add digiTimeFromDB conditionally based on Subdetector being "HF" + desc.ifValue(edm::ParameterDescription("Subdetector", "HF", true), + "HF" >> edm::ParameterDescription("digiTimeFromDB", false, true) or + "HO" >> edm::EmptyGroupDescription() // Default case: do nothing + ); + + edm::ParameterSetDescription hfTimingTrustParametersDesc; + hfTimingTrustParametersDesc.add("hfTimingTrustLevel1", 1); + hfTimingTrustParametersDesc.add("hfTimingTrustLevel2", 4); + + // Conditionally add hfTimingTrustParameters if setTimingTrustFlags is true + desc.ifValue(edm::ParameterDescription("setTimingTrustFlags", true, true), + false >> edm::EmptyGroupDescription() or + true >> edm::ParameterDescription( + "hfTimingTrustParameters", hfTimingTrustParametersDesc, true)); + + { + edm::ParameterSetDescription digiStatDesc; + HcalHFStatusBitFromDigis::fillHFDigiTimeParamsDesc(digiStatDesc); + + edm::ParameterSetDescription hfInWindowStatDesc; + HcalHFStatusBitFromDigis::fillHFTimeInWindowParamsDesc(hfInWindowStatDesc); + + edm::ParameterSetDescription s9s1StatDesc; + s9s1StatDesc.add>("short_optimumSlope", + {-99999, + 0.0164905, + 0.0238698, + 0.0321383, + 0.041296, + 0.0513428, + 0.0622789, + 0.0741041, + 0.0868186, + 0.100422, + 0.135313, + 0.136289, + 0.0589927}); + s9s1StatDesc.add>( + "shortEnergyParams", + {35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093}); + s9s1StatDesc.add>("shortETParams", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); + s9s1StatDesc.add>("long_optimumSlope", + {-99999, + 0.0164905, + 0.0238698, + 0.0321383, + 0.041296, + 0.0513428, + 0.0622789, + 0.0741041, + 0.0868186, + 0.100422, + 0.135313, + 0.136289, + 0.0589927}); + s9s1StatDesc.add>( + "longEnergyParams", {43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62}); + s9s1StatDesc.add>("longETParams", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); + s9s1StatDesc.add("HcalAcceptSeverityLevel", 9); + s9s1StatDesc.add("isS8S1", false); + + edm::ParameterSetDescription s8s1StatDesc; + s8s1StatDesc.add>( + "short_optimumSlope", {0.30, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10}); + s8s1StatDesc.add>("shortEnergyParams", + {40, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100}); + s8s1StatDesc.add>("shortETParams", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); + s8s1StatDesc.add>( + "long_optimumSlope", {0.30, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10}); + s8s1StatDesc.add>("longEnergyParams", + {40, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100}); + s8s1StatDesc.add>("longETParams", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); + s8s1StatDesc.add("HcalAcceptSeverityLevel", 9); + s8s1StatDesc.add("isS8S1", true); + + edm::ParameterSetDescription petStatDesc; + petStatDesc.add>("short_R", {0.8}); + petStatDesc.add>( + "shortEnergyParams", + {35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093}); + petStatDesc.add>("shortETParams", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); + petStatDesc.add>("long_R", {0.98}); + petStatDesc.add>( + "longEnergyParams", {43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62}); + petStatDesc.add>("longETParams", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}); + petStatDesc.add>("short_R_29", {0.8}); + petStatDesc.add>("long_R_29", {0.8}); + petStatDesc.add("HcalAcceptSeverityLevel", 9); + + // Conditionally add S9S1stat if setNoiseFlags is true + desc.ifValue( + edm::ParameterDescription("setNoiseFlags", true, true), + false >> edm::EmptyGroupDescription() or + true >> + (edm::ParameterDescription("digistat", digiStatDesc, true) and + edm::ParameterDescription("HFInWindowStat", hfInWindowStatDesc, true) and + edm::ParameterDescription("S9S1stat", s9s1StatDesc, true) and + edm::ParameterDescription("S8S1stat", s8s1StatDesc, true) and + edm::ParameterDescription("PETstat", petStatDesc, true))); + } + + desc.add("dataOOTCorrectionName", std::string("")); + desc.add("dataOOTCorrectionCategory", "Data"); + desc.add("mcOOTCorrectionName", ""); + desc.add("mcOOTCorrectionCategory", "MC"); + descriptions.addWithDefaultLabel(desc); +} diff --git a/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.h b/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.h index 8aba780f38c24..9d5687997f5a7 100644 --- a/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.h +++ b/RecoLocalCalo/HcalRecProducers/src/HcalHitReconstructor.h @@ -10,6 +10,8 @@ #include "FWCore/Framework/interface/EventSetup.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "RecoLocalCalo/HcalRecAlgos/interface/HcalSimpleRecAlgo.h" #include "RecoLocalCalo/HcalRecAlgos/interface/HcalHFStatusBitFromRecHits.h" @@ -56,6 +58,8 @@ class HcalHitReconstructor : public edm::stream::EDProducer<> { void endRun(edm::Run const& r, edm::EventSetup const& es) final; void produce(edm::Event& e, const edm::EventSetup& c) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: typedef void (HcalSimpleRecAlgo::*SetCorrectionFcn)(std::shared_ptr); @@ -70,17 +74,15 @@ class HcalHitReconstructor : public edm::stream::EDProducer<> { DetId::Detector det_; int subdet_; HcalOtherSubdetector subdetOther_; - edm::InputTag inputLabel_; + const edm::InputTag inputLabel_; edm::EDGetTokenT tok_ho_; edm::EDGetTokenT tok_hf_; edm::EDGetTokenT tok_calib_; //std::vector channelStatusToDrop_; bool correctTiming_; // turn on/off Ken Rossato's algorithm to fix timing bool setNoiseFlags_; // turn on/off basic noise flags - bool setHSCPFlags_; // turn on/off HSCP noise flags bool setSaturationFlags_; // turn on/off flag indicating ADC saturation bool setTimingTrustFlags_; // turn on/off HF timing uncertainty flag - bool setPulseShapeFlags_; // turn on/off HBHE fit-based noise flags bool setNegativeFlags_; // turn on/off HBHE negative noise flags bool dropZSmarkedPassed_; // turn on/off dropping of zero suppression marked and passed digis diff --git a/RecoLocalTracker/Phase2TrackerRecHits/plugins/Phase2TrackerRecHits.cc b/RecoLocalTracker/Phase2TrackerRecHits/plugins/Phase2TrackerRecHits.cc index bfcacd3261ad5..343693fbffb2a 100644 --- a/RecoLocalTracker/Phase2TrackerRecHits/plugins/Phase2TrackerRecHits.cc +++ b/RecoLocalTracker/Phase2TrackerRecHits/plugins/Phase2TrackerRecHits.cc @@ -1,14 +1,15 @@ -#include "FWCore/Framework/interface/global/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/InputTag.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/Framework/interface/ConsumesCollector.h" -#include "FWCore/PluginManager/interface/ModuleDef.h" #include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/global/EDProducer.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Utilities/interface/InputTag.h" #include "Geometry/CommonDetUnit/interface/GeomDet.h" #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" @@ -30,9 +31,11 @@ class Phase2TrackerRecHits : public edm::global::EDProducer<> { public: explicit Phase2TrackerRecHits(const edm::ParameterSet& conf); - ~Phase2TrackerRecHits() override {} + ~Phase2TrackerRecHits() override = default; void produce(edm::StreamID sid, edm::Event& event, const edm::EventSetup& eventSetup) const final; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: edm::ESGetToken const tTrackerGeom_; edm::ESGetToken, TkPhase2OTCPERecord> const tCPE_; @@ -47,6 +50,13 @@ Phase2TrackerRecHits::Phase2TrackerRecHits(edm::ParameterSet const& conf) produces(); } +void Phase2TrackerRecHits::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("Phase2StripCPE", edm::ESInputTag("phase2StripCPEESProducer", "Phase2StripCPE")); + desc.add("src", edm::InputTag("siPhase2Clusters")); + descriptions.addWithDefaultLabel(desc); +} + void Phase2TrackerRecHits::produce(edm::StreamID sid, edm::Event& event, const edm::EventSetup& eventSetup) const { // Get the Clusters edm::Handle clusters; diff --git a/RecoLocalTracker/Phase2TrackerRecHits/python/Phase2TrackerRecHits_cfi.py b/RecoLocalTracker/Phase2TrackerRecHits/python/Phase2TrackerRecHits_cfi.py index 76949ae787bfb..ff9dc05620b72 100644 --- a/RecoLocalTracker/Phase2TrackerRecHits/python/Phase2TrackerRecHits_cfi.py +++ b/RecoLocalTracker/Phase2TrackerRecHits/python/Phase2TrackerRecHits_cfi.py @@ -1,7 +1,5 @@ import FWCore.ParameterSet.Config as cms # RecHits options -siPhase2RecHits = cms.EDProducer("Phase2TrackerRecHits", - src = cms.InputTag("siPhase2Clusters"), - Phase2StripCPE = cms.ESInputTag("phase2StripCPEESProducer", "Phase2StripCPE") -) +from RecoLocalTracker.Phase2TrackerRecHits.phase2TrackerRecHits_cfi import phase2TrackerRecHits +siPhase2RecHits = phase2TrackerRecHits.clone() diff --git a/RecoLocalTracker/SiPhase2Clusterizer/plugins/Phase2TrackerClusterizer.cc b/RecoLocalTracker/SiPhase2Clusterizer/plugins/Phase2TrackerClusterizer.cc index 531f2d38e8b2c..2e4bc361007e8 100644 --- a/RecoLocalTracker/SiPhase2Clusterizer/plugins/Phase2TrackerClusterizer.cc +++ b/RecoLocalTracker/SiPhase2Clusterizer/plugins/Phase2TrackerClusterizer.cc @@ -1,13 +1,14 @@ -#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/InputTag.h" -#include "FWCore/Framework/interface/ConsumesCollector.h" -#include "FWCore/PluginManager/interface/ModuleDef.h" #include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Utilities/interface/InputTag.h" #ifdef VERIFY_PH2_TK_CLUS #include "Phase2TrackerClusterizerAlgorithm.h" @@ -30,9 +31,11 @@ class Phase2TrackerClusterizer : public edm::stream::EDProducer<> { public: explicit Phase2TrackerClusterizer(const edm::ParameterSet& conf); - ~Phase2TrackerClusterizer() override; + ~Phase2TrackerClusterizer() override = default; void produce(edm::Event& event, const edm::EventSetup& eventSetup) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: #ifdef VERIFY_PH2_TK_CLUS std::unique_ptr clusterizer_; @@ -54,8 +57,6 @@ Phase2TrackerClusterizer::Phase2TrackerClusterizer(edm::ParameterSet const& conf produces(); } -Phase2TrackerClusterizer::~Phase2TrackerClusterizer() {} - /* * Clusterize the events */ @@ -146,4 +147,12 @@ void Phase2TrackerClusterizer::produce(edm::Event& event, const edm::EventSetup& event.put(std::move(outputClusters)); } +void Phase2TrackerClusterizer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("maxClusterSize", 0); + desc.add("maxNumberClusters", 0); + desc.add("src", edm::InputTag("mix", "Tracker")); + descriptions.add("default_phase2TrackerClusterizer", desc); +} + DEFINE_FWK_MODULE(Phase2TrackerClusterizer); diff --git a/RecoLocalTracker/SiPhase2Clusterizer/python/phase2TrackerClusterizer_cfi.py b/RecoLocalTracker/SiPhase2Clusterizer/python/phase2TrackerClusterizer_cfi.py index 6c18d6bcd8592..08f05e9e8266c 100644 --- a/RecoLocalTracker/SiPhase2Clusterizer/python/phase2TrackerClusterizer_cfi.py +++ b/RecoLocalTracker/SiPhase2Clusterizer/python/phase2TrackerClusterizer_cfi.py @@ -1,10 +1,11 @@ import FWCore.ParameterSet.Config as cms # Clusterizer options -siPhase2Clusters = cms.EDProducer('Phase2TrackerClusterizer', - src = cms.InputTag("mix", "Tracker"), - maxClusterSize = cms.uint32(0), # was 8 - maxNumberClusters = cms.uint32(0) +from RecoLocalTracker.SiPhase2Clusterizer.default_phase2TrackerClusterizer_cfi import default_phase2TrackerClusterizer +siPhase2Clusters = default_phase2TrackerClusterizer.clone( + src = "mix:Tracker", + maxClusterSize = 0, # was 8 + maxNumberClusters = 0 ) from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 diff --git a/RecoLocalTracker/SiStripZeroSuppression/plugins/SealModules.cc b/RecoLocalTracker/SiStripZeroSuppression/plugins/SealModules.cc index 03d00e58c3090..39926125391f9 100644 --- a/RecoLocalTracker/SiStripZeroSuppression/plugins/SealModules.cc +++ b/RecoLocalTracker/SiStripZeroSuppression/plugins/SealModules.cc @@ -1,4 +1,3 @@ - #include "FWCore/PluginManager/interface/ModuleDef.h" #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.cc b/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.cc index 5d7a947a3a2b4..593b951c961ae 100644 --- a/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.cc +++ b/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.cc @@ -275,3 +275,33 @@ inline void SiStripZeroSuppression::storeCMN(uint32_t id, const medians_t& vmedi if (!apvDetSet.empty()) output_apvcm.push_back(std::move(apvDetSet)); } + +void SiStripZeroSuppression::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + // Algorithms + edm::ParameterSetDescription algorithmsDesc; + SiStripRawProcessingFactory::fillDescriptions(algorithmsDesc); + desc.add("Algorithms", algorithmsDesc); + + // RawDigiProducersList + desc.add>("RawDigiProducersList", + {edm::InputTag("siStripDigis", "VirginRaw"), + edm::InputTag("siStripDigis", "ProcessedRaw"), + edm::InputTag("siStripDigis", "ScopeMode")}); + + // CM and baseline settings + desc.add("storeCM", true); + desc.add("fixCM", false); + + // Raw digi production settings + desc.add("produceRawDigis", true); + desc.add("produceCalculatedBaseline", false); + desc.add("produceBaselinePoints", false); + + // ZS collection settings + desc.add("storeInZScollBadAPV", true); + desc.add("produceHybridFormat", false); + + descriptions.add("siStripZeroSuppression", desc); +} diff --git a/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.h b/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.h index 539256abb5b65..4331a4e83982a 100644 --- a/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.h +++ b/RecoLocalTracker/SiStripZeroSuppression/plugins/SiStripZeroSuppression.h @@ -1,9 +1,11 @@ -#ifndef SiStripZeroSuppression_h -#define SiStripZeroSuppression_h +#ifndef RecoLocalTracker_SiStripZeroSuppression_SiStripZeroSuppression_h +#define RecoLocalTracker_SiStripZeroSuppression_SiStripZeroSuppression_h + #include "FWCore/Framework/interface/stream/EDProducer.h" #include "FWCore/Framework/interface/Frameworkfwd.h" - #include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" #include "FWCore/Utilities/interface/InputTag.h" #include "DataFormats/Common/interface/DetSet.h" #include "DataFormats/Common/interface/DetSetVector.h" @@ -18,6 +20,8 @@ class SiStripZeroSuppression : public edm::stream::EDProducer<> { explicit SiStripZeroSuppression(const edm::ParameterSet&); void produce(edm::Event&, const edm::EventSetup&) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + private: enum class RawType { Unknown, VirginRaw, ProcessedRaw, ScopeMode }; @@ -36,13 +40,13 @@ class SiStripZeroSuppression : public edm::stream::EDProducer<> { std::unique_ptr algorithms; - bool produceRawDigis; - bool storeCM; - bool fixCM; - bool produceCalculatedBaseline; - bool produceBaselinePoints; - bool storeInZScollBadAPV; - bool produceHybridFormat; + const bool produceRawDigis; + const bool storeCM; + const bool fixCM; + const bool produceCalculatedBaseline; + const bool produceBaselinePoints; + const bool storeInZScollBadAPV; + const bool produceHybridFormat; using rawtoken_t = edm::EDGetTokenT>; using zstoken_t = edm::EDGetTokenT>; diff --git a/RecoLocalTracker/SiStripZeroSuppression/python/SiStripZeroSuppression_cfi.py b/RecoLocalTracker/SiStripZeroSuppression/python/SiStripZeroSuppression_cfi.py index 1dd478402609d..f5150bb75a49e 100644 --- a/RecoLocalTracker/SiStripZeroSuppression/python/SiStripZeroSuppression_cfi.py +++ b/RecoLocalTracker/SiStripZeroSuppression/python/SiStripZeroSuppression_cfi.py @@ -2,22 +2,21 @@ from RecoLocalTracker.SiStripZeroSuppression.DefaultAlgorithms_cff import * -siStripZeroSuppression = cms.EDProducer("SiStripZeroSuppression", - +from RecoLocalTracker.SiStripZeroSuppression.siStripZeroSuppression_cfi import siStripZeroSuppression +siStripZeroSuppression = siStripZeroSuppression.clone( Algorithms = DefaultAlgorithms, - RawDigiProducersList = cms.VInputTag( cms.InputTag('siStripDigis','VirginRaw'), - cms.InputTag('siStripDigis','ProcessedRaw'), - cms.InputTag('siStripDigis','ScopeMode')), - # cms.InputTag('siStripDigis','ZeroSuppressed')), - - storeCM = cms.bool(True), - fixCM= cms.bool(False), # put -999 into CM collection for "inspected" APV - - produceRawDigis = cms.bool(True), - produceCalculatedBaseline = cms.bool(False), - produceBaselinePoints = cms.bool(False), - storeInZScollBadAPV = cms.bool(True), # it selects if in the ZS collection the bad APVs are written. To be kept for ZS - produceHybridFormat = cms.bool(False) + RawDigiProducersList = [ ("siStripDigis","VirginRaw"), + ("siStripDigis","ProcessedRaw"), + ("siStripDigis","ScopeMode"), + # ("siStripDigis","ZeroSuppressed") + ], + storeCM = True, + fixCM = False, # put -999 into CM collection for "inspected" APV + produceRawDigis = True, + produceCalculatedBaseline = False, + produceBaselinePoints = False, + storeInZScollBadAPV = True, # it selects if in the ZS collection the bad APVs are written. To be kept for ZS + produceHybridFormat = False ) # The SiStripClusters are not used anymore in phase2 tracking diff --git a/RecoLocalTracker/SubCollectionProducers/python/seedClusterRemoverPhase2_cfi.py b/RecoLocalTracker/SubCollectionProducers/python/seedClusterRemoverPhase2_cfi.py index 85b9c696229f8..5f09871f17cd5 100644 --- a/RecoLocalTracker/SubCollectionProducers/python/seedClusterRemoverPhase2_cfi.py +++ b/RecoLocalTracker/SubCollectionProducers/python/seedClusterRemoverPhase2_cfi.py @@ -1,8 +1,9 @@ import FWCore.ParameterSet.Config as cms -seedClusterRemoverPhase2 = cms.EDProducer("SeedClusterRemoverPhase2", - trajectories = cms.InputTag("initialStepSeeds"), - phase2OTClusters = cms.InputTag("siPhase2Clusters"), - pixelClusters = cms.InputTag("siPixelClusters"), - ) +from RecoLocalTracker.SubCollectionProducers.default_seedClusterRemoverPhase2_cfi import default_seedClusterRemoverPhase2 +seedClusterRemoverPhase2 = default_seedClusterRemoverPhase2.clone( + trajectories = "initialStepSeeds", + phase2OTClusters = "siPhase2Clusters", + pixelClusters = "siPixelClusters" +) diff --git a/RecoLocalTracker/SubCollectionProducers/src/SeedClusterRemoverPhase2.cc b/RecoLocalTracker/SubCollectionProducers/src/SeedClusterRemoverPhase2.cc index 60fb9b40b597e..82fe249b0f404 100644 --- a/RecoLocalTracker/SubCollectionProducers/src/SeedClusterRemoverPhase2.cc +++ b/RecoLocalTracker/SubCollectionProducers/src/SeedClusterRemoverPhase2.cc @@ -1,6 +1,7 @@ +#include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/Frameworkfwd.h" #include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/Utilities/interface/InputTag.h" @@ -36,10 +37,12 @@ class SeedClusterRemoverPhase2 : public edm::stream::EDProducer<> { SeedClusterRemoverPhase2(const edm::ParameterSet &iConfig); void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override; + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + private: edm::ESGetToken const tTrackerGeom_; - bool doOuterTracker_, doPixel_; - bool mergeOld_; + const bool doOuterTracker_, doPixel_; + const bool mergeOld_; typedef edm::ContainerMask > PixelMaskContainer; typedef edm::ContainerMask > Phase2OTMaskContainer; edm::EDGetTokenT > pixelClusters_; @@ -62,9 +65,9 @@ using namespace edm; SeedClusterRemoverPhase2::SeedClusterRemoverPhase2(const ParameterSet &iConfig) : tTrackerGeom_(esConsumes()), - doOuterTracker_(iConfig.existsAs("doOuterTracker") ? iConfig.getParameter("doOuterTracker") : true), - doPixel_(iConfig.existsAs("doPixel") ? iConfig.getParameter("doPixel") : true), - mergeOld_(iConfig.exists("oldClusterRemovalInfo")) { + doOuterTracker_(iConfig.getParameter("doOuterTracker")), + doPixel_(iConfig.getParameter("doPixel")), + mergeOld_(!iConfig.getParameter("oldClusterRemovalInfo").label().empty()) { produces > >(); produces > >(); @@ -233,6 +236,17 @@ void SeedClusterRemoverPhase2::produce(Event &iEvent, const EventSetup &iSetup) collectedPixels_.clear(); } +void SeedClusterRemoverPhase2::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + edm::ParameterSetDescription desc; + desc.add("doOuterTracker", true); + desc.add("doPixel", true); + desc.add("trajectories", edm::InputTag("initialStepSeeds")); + desc.add("pixelClusters", edm::InputTag("siPixelClusters")); + desc.add("phase2OTClusters", edm::InputTag("siPhase2Clusters")); + desc.add("oldClusterRemovalInfo", edm::InputTag("")); + descriptions.add("default_seedClusterRemoverPhase2", desc); +} + #include "FWCore/PluginManager/interface/ModuleDef.h" #include "FWCore/Framework/interface/MakerMacros.h" DEFINE_FWK_MODULE(SeedClusterRemoverPhase2); diff --git a/RecoTracker/FinalTrackSelectors/plugins/CosmicTrackSelector.cc b/RecoTracker/FinalTrackSelectors/plugins/CosmicTrackSelector.cc index 6f976634b98b5..a734f07a69c09 100644 --- a/RecoTracker/FinalTrackSelectors/plugins/CosmicTrackSelector.cc +++ b/RecoTracker/FinalTrackSelectors/plugins/CosmicTrackSelector.cc @@ -8,24 +8,29 @@ * */ -#include -#include -#include #include #include -#include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/Framework/interface/EventPrincipal.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/InputTag.h" +#include +#include +#include -#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" #include "DataFormats/TrackReco/interface/Track.h" #include "DataFormats/TrackReco/interface/TrackExtra.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" #include "DataFormats/VertexReco/interface/VertexFwd.h" -#include "DataFormats/BeamSpot/interface/BeamSpot.h" -#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventPrincipal.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" + +#include +#include "TMath.h" using namespace reco; @@ -35,7 +40,9 @@ class dso_hidden CosmicTrackSelector final : public edm::stream::EDProducer<> { // constructor explicit CosmicTrackSelector(const edm::ParameterSet &cfg); // destructor - ~CosmicTrackSelector() override; + ~CosmicTrackSelector() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); private: typedef math::XYZPoint Point; @@ -92,16 +99,12 @@ class dso_hidden CosmicTrackSelector final : public edm::stream::EDProducer<> { std::vector trackRefs_; }; -#include -#include "TMath.h" - CosmicTrackSelector::CosmicTrackSelector(const edm::ParameterSet &cfg) : src_(consumes(cfg.getParameter("src"))), beamspot_(consumes(cfg.getParameter("beamspot"))), copyExtras_(cfg.getUntrackedParameter("copyExtras", false)), copyTrajectories_(cfg.getUntrackedParameter("copyTrajectories", false)), - keepAllTracks_(cfg.exists("keepAllTracks") ? cfg.getParameter("keepAllTracks") - : false), // as this is what you expect from a well behaved selector + keepAllTracks_(cfg.getParameter("keepAllTracks")), setQualityBit_(false), qualityToSet_(TrackBase::undefQuality), chi2n_par_(cfg.getParameter("chi2n_par")), @@ -119,13 +122,12 @@ CosmicTrackSelector::CosmicTrackSelector(const edm::ParameterSet &cfg) min_layers_(cfg.getParameter("minNumberLayers")), min_3Dlayers_(cfg.getParameter("minNumber3DLayers")), max_lostLayers_(cfg.getParameter("maxNumberLostLayers")) { - if (cfg.exists("qualityBit")) { - std::string qualityStr = cfg.getParameter("qualityBit"); - if (!qualityStr.empty()) { - setQualityBit_ = true; - qualityToSet_ = TrackBase::qualityByName(cfg.getParameter("qualityBit")); - } + std::string qualityStr = cfg.getParameter("qualityBit"); + if (!qualityStr.empty()) { + setQualityBit_ = true; + qualityToSet_ = TrackBase::qualityByName(cfg.getParameter("qualityBit")); } + if (keepAllTracks_ && !setQualityBit_) throw cms::Exception("Configuration") << "If you set 'keepAllTracks' to true, you must specify which qualityBit to set.\n"; @@ -148,8 +150,6 @@ CosmicTrackSelector::CosmicTrackSelector(const edm::ParameterSet &cfg) } } -CosmicTrackSelector::~CosmicTrackSelector() {} - void CosmicTrackSelector::produce(edm::Event &evt, const edm::EventSetup &es) { using namespace std; using namespace edm; @@ -318,6 +318,29 @@ bool CosmicTrackSelector::select(const reco::BeamSpot &vertexBeamSpot, const rec return true; } +void CosmicTrackSelector::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("ctfWithMaterialTracksCosmics")); + desc.add("beamspot", edm::InputTag("offlineBeamSpot")); + desc.addUntracked("copyExtras", true); + desc.addUntracked("copyTrajectories", false); + desc.add("keepAllTracks", false) + ->setComment("if set to true tracks failing this filter are kept in the output"); + desc.add("chi2n_par", 10.0)->setComment("parameters for adapted optimal cuts on chi2"); + desc.add("max_d0", 110.)->setComment("d0 impact parameter absolute cut"); + desc.add("max_z0", 300.)->setComment("z0 impact parameter absolute cut"); + desc.add("min_pt", 1.0); + desc.add("max_eta", 2.0); + desc.add("min_nHit", 5); + desc.add("min_nPixelHit", 0); + desc.add("minNumberLayers", 0); + desc.add("minNumber3DLayers", 0); + desc.add("maxNumberLostLayers", 999); + desc.add("qualityBit", std::string("")) + ->setComment("set to '' or comment out if you don't want to set the bit"); + descriptions.addWithDefaultLabel(desc); +} + #include "FWCore/PluginManager/interface/ModuleDef.h" #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoTracker/FinalTrackSelectors/python/cosmictrackSelector_cfi.py b/RecoTracker/FinalTrackSelectors/python/cosmictrackSelector_cfi.py index f08d762a09a1e..408f02a0072a1 100644 --- a/RecoTracker/FinalTrackSelectors/python/cosmictrackSelector_cfi.py +++ b/RecoTracker/FinalTrackSelectors/python/cosmictrackSelector_cfi.py @@ -1,29 +1,6 @@ import FWCore.ParameterSet.Config as cms -cosmictrackSelector = cms.EDProducer("CosmicTrackSelector", - src = cms.InputTag("ctfWithMaterialTracksCosmics"), - keepAllTracks = cms.bool(False), ## if set to true tracks failing this filter are kept in the output - beamspot = cms.InputTag("offlineBeamSpot"), - #untracked bool copyTrajectories = true // when doing retracking before - copyTrajectories = cms.untracked.bool(False), - copyExtras = cms.untracked.bool(True), ## set to false on AOD - qualityBit = cms.string(''), # set to '' or comment out if you don't want to set the bit - # parameters for adapted optimal cuts on chi2 - chi2n_par = cms.double(10.0), - # Impact parameter absolute cuts. - max_d0 = cms.double(110.), - max_z0 = cms.double(300.), - # track parameter cuts - max_eta = cms.double(2.0), - min_pt = cms.double(1.0), - # Cut on numbers of valid hits - min_nHit = cms.uint32(5), - # Cut on number of Pixel Hit - min_nPixelHit = cms.uint32(0), - # Cuts on numbers of layers with hits/3D hits/lost hits. - minNumberLayers = cms.uint32(0), - minNumber3DLayers = cms.uint32(0), - maxNumberLostLayers = cms.uint32(999) - ) +from RecoTracker.FinalTrackSelectors.cosmicTrackSelector_cfi import cosmicTrackSelector as _cosmictrackSelector +cosmictrackSelector = _cosmictrackSelector.clone() diff --git a/RecoTracker/SpecialSeedGenerators/interface/SimpleCosmicBONSeeder.h b/RecoTracker/SpecialSeedGenerators/interface/SimpleCosmicBONSeeder.h index 378d48c6240a5..ba8fa9255b26e 100644 --- a/RecoTracker/SpecialSeedGenerators/interface/SimpleCosmicBONSeeder.h +++ b/RecoTracker/SpecialSeedGenerators/interface/SimpleCosmicBONSeeder.h @@ -1,40 +1,38 @@ #ifndef SimpleCosmicBONSeeder_h #define SimpleCosmicBONSeeder_h -#include "FWCore/Framework/interface/stream/EDProducer.h" -#include "FWCore/Framework/interface/Event.h" #include "DataFormats/Common/interface/Handle.h" -#include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/Utilities/interface/InputTag.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/EDGetToken.h" - #include "DataFormats/GeometryCommonDetAlgo/interface/GlobalError.h" +#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2DCollection.h" #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2DCollection.h" #include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h" -#include "DataFormats/SiStripDetId/interface/StripSubdetector.h" - +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Utilities/interface/InputTag.h" #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" #include "MagneticField/Engine/interface/MagneticField.h" #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" - #include "RecoTracker/PixelSeeding/interface/OrderedHitTriplets.h" -#include "RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h" +#include "RecoTracker/SpecialSeedGenerators/interface/ClusterChecker.h" #include "RecoTracker/TkSeedGenerator/interface/FastCircle.h" #include "RecoTracker/TkSeedGenerator/interface/FastHelix.h" -#include "RecoTracker/SpecialSeedGenerators/interface/ClusterChecker.h" - +#include "RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" #include "TrackingTools/KalmanUpdators/interface/KFUpdator.h" #include "TrackingTools/MaterialEffects/interface/PropagatorWithMaterial.h" +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" -#include "TrackingTools/Records/interface/TransientRecHitRecord.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" class SeedingLayerSetsHits; @@ -42,7 +40,9 @@ class SimpleCosmicBONSeeder : public edm::stream::EDProducer<> { public: explicit SimpleCosmicBONSeeder(const edm::ParameterSet &conf); - ~SimpleCosmicBONSeeder() override {} + ~SimpleCosmicBONSeeder() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); void produce(edm::Event &e, const edm::EventSetup &c) override; diff --git a/RecoTracker/SpecialSeedGenerators/python/SimpleCosmicBONSeeder_cfi.py b/RecoTracker/SpecialSeedGenerators/python/SimpleCosmicBONSeeder_cfi.py index 7b2cc2093856d..02b097ca6ba1f 100644 --- a/RecoTracker/SpecialSeedGenerators/python/SimpleCosmicBONSeeder_cfi.py +++ b/RecoTracker/SpecialSeedGenerators/python/SimpleCosmicBONSeeder_cfi.py @@ -32,18 +32,20 @@ def makeSimpleCosmicSeedLayers(*layers): ) layerList = makeSimpleCosmicSeedLayers('ALL'), -simpleCosmicBONSeeds = cms.EDProducer("SimpleCosmicBONSeeder", - TTRHBuilder = cms.string('WithTrackAngle'), + +from RecoTracker.SpecialSeedGenerators.simpleCosmicBONSeeder_cfi import simpleCosmicBONSeeder +simpleCosmicBONSeeds = simpleCosmicBONSeeder.clone( + TTRHBuilder = 'WithTrackAngle', ClusterCheckPSet = cms.PSet( - doClusterCheck = cms.bool(True), - MaxNumberOfStripClusters = cms.uint32(300), - ClusterCollectionLabel = cms.InputTag("siStripClusters"), - DontCountDetsAboveNClusters = cms.uint32(20), # if N > 0, ignore in total the dets with more than N clusters - MaxNumberOfPixelClusters = cms.uint32(1000), - PixelClusterCollectionLabel = cms.InputTag("siPixelClusters") + doClusterCheck = cms.bool(True), + MaxNumberOfStripClusters = cms.uint32(300), + ClusterCollectionLabel = cms.InputTag("siStripClusters"), + DontCountDetsAboveNClusters = cms.uint32(20), # if N > 0, ignore in total the dets with more than N clusters + MaxNumberOfPixelClusters = cms.uint32(1000), + PixelClusterCollectionLabel = cms.InputTag("siPixelClusters") ), - maxTriplets = cms.int32(50000), - maxSeeds = cms.int32(20000), + maxTriplets = 50000, + maxSeeds = 20000, RegionPSet = cms.PSet( originZPosition = cms.double(0.0), # \ These three parameters originRadius = cms.double(150.0), # |-> probably don't change @@ -51,10 +53,10 @@ def makeSimpleCosmicSeedLayers(*layers): ptMin = cms.double(0.5), # pt cut, applied both at the triplet finding and at the seeding level pMin = cms.double(1.0), # p cut, applied only at the seeding level ), - TripletsSrc = cms.InputTag("simpleCosmicBONSeedingLayers"), - TripletsDebugLevel = cms.untracked.uint32(0), # debug triplet finding (0 to 3) - seedOnMiddle = cms.bool(False), # after finding the triplet, add only two hits to the seed - rescaleError = cms.double(1.0), # we don't need it anymore. At least for runs with BON + TripletsSrc = "simpleCosmicBONSeedingLayers", + TripletsDebugLevel = 0, # debug triplet finding (0 to 3) + seedOnMiddle = False, # after finding the triplet, add only two hits to the seed + rescaleError = 1.0, # we don't need it anymore. At least for runs with BON ClusterChargeCheck = cms.PSet( checkCharge = cms.bool(False), # Apply cuts on cluster charge @@ -75,14 +77,15 @@ def makeSimpleCosmicSeedLayers(*layers): TEC = cms.int32(20), # ), ), - minimumGoodHitsInSeed = cms.int32(3), # NO bad hits in the seed (set to '2' to allow one bad hit in the seed) + + minimumGoodHitsInSeed = 3, # NO bad hits in the seed (set to '2' to allow one bad hit in the seed) - writeTriplets = cms.bool(False), # write the triplets to the Event as OwnVector - helixDebugLevel = cms.untracked.uint32(0), # debug FastHelix (0 to 2) - seedDebugLevel = cms.untracked.uint32(0), # debug seed building (0 to 3) + writeTriplets = False, # write the triplets to the Event as OwnVector + helixDebugLevel = 0, # debug FastHelix (0 to 2) + seedDebugLevel = 0, # debug seed building (0 to 3) #***top-bottom - PositiveYOnly = cms.bool(False), - NegativeYOnly = cms.bool(False) + PositiveYOnly = False, + NegativeYOnly = False #*** ) diff --git a/RecoTracker/SpecialSeedGenerators/src/SimpleCosmicBONSeeder.cc b/RecoTracker/SpecialSeedGenerators/src/SimpleCosmicBONSeeder.cc index 413d4eec8525a..44dd1b9fb3fbb 100644 --- a/RecoTracker/SpecialSeedGenerators/src/SimpleCosmicBONSeeder.cc +++ b/RecoTracker/SpecialSeedGenerators/src/SimpleCosmicBONSeeder.cc @@ -5,11 +5,11 @@ // From CosmicSeedGenerator+SimpleCosmicBONSeeder, with changes by Giovanni // to seed Cosmics with B != 0 -#include "RecoTracker/SpecialSeedGenerators/interface/SimpleCosmicBONSeeder.h" #include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h" #include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h" -#include "FWCore/Utilities/interface/isFinite.h" #include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Utilities/interface/isFinite.h" +#include "RecoTracker/SpecialSeedGenerators/interface/SimpleCosmicBONSeeder.h" #include "TrackingTools/TransientTrackingRecHit/interface/SeedingLayerSetsHits.h" typedef SeedingHitSet::ConstRecHitPointer SeedingHit; @@ -28,8 +28,8 @@ SimpleCosmicBONSeeder::SimpleCosmicBONSeeder(edm::ParameterSet const &conf) trackerToken_(esConsumes()), ttrhBuilderToken_(esConsumes(edm::ESInputTag("", conf.getParameter("TTRHBuilder")))), writeTriplets_(conf.getParameter("writeTriplets")), - seedOnMiddle_(conf.existsAs("seedOnMiddle") ? conf.getParameter("seedOnMiddle") : false), - rescaleError_(conf.existsAs("rescaleError") ? conf.getParameter("rescaleError") : 1.0), + seedOnMiddle_(conf.getParameter("seedOnMiddle")), + rescaleError_(conf.getParameter("rescaleError")), tripletsVerbosity_(conf.getUntrackedParameter("TripletsDebugLevel", 0)), seedVerbosity_(conf.getUntrackedParameter("seedDebugLevel", 0)), helixVerbosity_(conf.getUntrackedParameter("helixDebugLevel", 0)), @@ -621,3 +621,64 @@ void SimpleCosmicBONSeeder::done() { delete thePropagatorOp; delete theUpdator; } + +void SimpleCosmicBONSeeder::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + edm::ParameterSetDescription desc; + + desc.add("TTRHBuilder", "WithTrackAngle"); + + edm::ParameterSetDescription clusterCheckPSet; + clusterCheckPSet.add("doClusterCheck", true); + clusterCheckPSet.add("MaxNumberOfStripClusters", 300); + clusterCheckPSet.add("ClusterCollectionLabel", edm::InputTag("siStripClusters")); + clusterCheckPSet.add("DontCountDetsAboveNClusters", 20); + clusterCheckPSet.add("MaxNumberOfPixelClusters", 1000); + clusterCheckPSet.add("PixelClusterCollectionLabel", edm::InputTag("siPixelClusters")); + desc.add("ClusterCheckPSet", clusterCheckPSet); + + desc.add("maxTriplets", 50000); + desc.add("maxSeeds", 20000); + + edm::ParameterSetDescription regionPSet; + regionPSet.add("originZPosition", 0.0); + regionPSet.add("originRadius", 150.0); + regionPSet.add("originHalfLength", 90.0); + regionPSet.add("ptMin", 0.5); + regionPSet.add("pMin", 1.0); + desc.add("RegionPSet", regionPSet); + + desc.add("TripletsSrc", edm::InputTag("simpleCosmicBONSeedingLayers")); + desc.addUntracked("TripletsDebugLevel", 0); + desc.add("seedOnMiddle", false); + desc.add("rescaleError", 1.0); + + edm::ParameterSetDescription clusterChargeCheck; + clusterChargeCheck.add("checkCharge", false); + clusterChargeCheck.add("matchedRecHitsUseAnd", true); + edm::ParameterSetDescription thresholds; + thresholds.add("TIB", 0); + thresholds.add("TID", 0); + thresholds.add("TOB", 0); + thresholds.add("TEC", 0); + clusterChargeCheck.add("Thresholds", thresholds); + desc.add("ClusterChargeCheck", clusterChargeCheck); + + edm::ParameterSetDescription hitsPerModuleCheck; + hitsPerModuleCheck.add("checkHitsPerModule", true); + edm::ParameterSetDescription hitsThresholds; + hitsThresholds.add("TIB", 20); + hitsThresholds.add("TID", 20); + hitsThresholds.add("TOB", 20); + hitsThresholds.add("TEC", 20); + hitsPerModuleCheck.add("Thresholds", hitsThresholds); + desc.add("HitsPerModuleCheck", hitsPerModuleCheck); + + desc.add("minimumGoodHitsInSeed", 3); + desc.add("writeTriplets", false); + desc.addUntracked("helixDebugLevel", 0); + desc.addUntracked("seedDebugLevel", 0); + desc.add("PositiveYOnly", false); + desc.add("NegativeYOnly", false); + + descriptions.addWithDefaultLabel(desc); +}