diff --git a/CondCore/EcalPlugins/src/plugin.cc b/CondCore/EcalPlugins/src/plugin.cc index 3693b20d2dfe3..8a80718d7b948 100644 --- a/CondCore/EcalPlugins/src/plugin.cc +++ b/CondCore/EcalPlugins/src/plugin.cc @@ -161,6 +161,11 @@ #include "CondFormats/EcalObjects/interface/EcalSimPulseShape.h" #include "CondFormats/DataRecord/interface/EcalSimPulseShapeRcd.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" + REGISTER_PLUGIN(EcalPedestalsRcd, EcalCondObjectContainer); REGISTER_PLUGIN(EcalWeightXtalGroupsRcd, EcalCondObjectContainer); REGISTER_PLUGIN(EcalTBWeightsRcd, EcalTBWeights); @@ -222,3 +227,6 @@ REGISTER_PLUGIN(EcalSamplesCorrelationRcd, EcalSamplesCorrelation); REGISTER_PLUGIN(EcalPulseShapesRcd, EcalCondObjectContainer); REGISTER_PLUGIN(EcalPulseCovariancesRcd, EcalCondObjectContainer); REGISTER_PLUGIN(EcalPulseSymmCovariancesRcd, EcalCondObjectContainer); + +REGISTER_PLUGIN(EcalMustacheSCParametersRcd, EcalMustacheSCParameters); +REGISTER_PLUGIN(EcalSCDynamicDPhiParametersRcd, EcalSCDynamicDPhiParameters); diff --git a/CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h b/CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h new file mode 100644 index 0000000000000..c366352b89e63 --- /dev/null +++ b/CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h @@ -0,0 +1,26 @@ +#ifndef CondFormats_DataRecord_EcalMustacheSCParametersRcd_h +#define CondFormats_DataRecord_EcalMustacheSCParametersRcd_h +// -*- C++ -*- +// +// Package: CondFormats/DataRecord +// Class : EcalMustacheSCParametersRcd +// +/**\class EcalMustacheSCParametersRcd EcalMustacheSCParametersRcd.h CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h + + Description: [one line class summary] + + Usage: + + +*/ +// +// Author: Thomas Reis +// Created: Fri, 23 Oct 2020 09:52:36 GMT +// + +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" + +class EcalMustacheSCParametersRcd + : public edm::eventsetup::EventSetupRecordImplementation {}; + +#endif diff --git a/CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h b/CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h new file mode 100644 index 0000000000000..3326f6d528367 --- /dev/null +++ b/CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h @@ -0,0 +1,26 @@ +#ifndef CondFormats_DataRecord_EcalSCDynamicDPhiParametersRcd_h +#define CondFormats_DataRecord_EcalSCDynamicDPhiParametersRcd_h +// -*- C++ -*- +// +// Package: CondFormats/DataRecord +// Class : EcalSCDynamicDPhiParametersRcd +// +/**\class EcalSCDynamicDPhiParametersRcd EcalSCDynamicDPhiParametersRcd.h CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h + + Description: [one line class summary] + + Usage: + + +*/ +// +// Author: Thomas Reis +// Created: Wed, 28 Oct 2020 12:56:00 GMT +// + +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" + +class EcalSCDynamicDPhiParametersRcd + : public edm::eventsetup::EventSetupRecordImplementation {}; + +#endif diff --git a/CondFormats/DataRecord/src/EcalMustacheSCParametersRcd.cc b/CondFormats/DataRecord/src/EcalMustacheSCParametersRcd.cc new file mode 100644 index 0000000000000..17e0799dad9a1 --- /dev/null +++ b/CondFormats/DataRecord/src/EcalMustacheSCParametersRcd.cc @@ -0,0 +1,15 @@ +// -*- C++ -*- +// +// Package: CondFormats/DataRecord +// Class : EcalMustacheSCParametersRcd +// +// Implementation: +// [Notes on implementation] +// +// Author: Thomas Reis +// Created: Fri, 23 Oct 2020 09:52:36 GMT + +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" +#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" + +EVENTSETUP_RECORD_REG(EcalMustacheSCParametersRcd); diff --git a/CondFormats/DataRecord/src/EcalSCDynamicDPhiParametersRcd.cc b/CondFormats/DataRecord/src/EcalSCDynamicDPhiParametersRcd.cc new file mode 100644 index 0000000000000..8fc4b8aa22842 --- /dev/null +++ b/CondFormats/DataRecord/src/EcalSCDynamicDPhiParametersRcd.cc @@ -0,0 +1,15 @@ +// -*- C++ -*- +// +// Package: CondFormats/DataRecord +// Class : EcalSCDynamicDPhiParametersRcd +// +// Implementation: +// [Notes on implementation] +// +// Author: Thomas Reis +// Created: Wed, 28 Oct 2020 12:56:00 GMT + +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" +#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" + +EVENTSETUP_RECORD_REG(EcalSCDynamicDPhiParametersRcd); diff --git a/CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h b/CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h new file mode 100644 index 0000000000000..f5d44be83fc5d --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h @@ -0,0 +1,54 @@ +#ifndef CondFormats_EcalObjects_EcalMustacheSCParameters_h +#define CondFormats_EcalObjects_EcalMustacheSCParameters_h + +#include +#include + +#include "CondFormats/Serialization/interface/Serializable.h" + +namespace reco { + class MustacheSCParametersHelper; +} // namespace reco + +class EcalMustacheSCParameters { +public: + EcalMustacheSCParameters(){}; + virtual ~EcalMustacheSCParameters() = default; + + struct ParabolaParameters { + double log10EMin; + double etaMin; + std::vector pUp; + std::vector pLow; + std::vector w0Up; + std::vector w1Up; + std::vector w0Low; + std::vector w1Low; + + COND_SERIALIZABLE; + }; + + float sqrtLogClustETuning() const; + + const ParabolaParameters* parabolaParameters(float log10ClustE, float absSeedEta) const; + + // helper class to set parameters + friend class reco::MustacheSCParametersHelper; + + // print parameters to stream: + void print(std::ostream&) const; + friend std::ostream& operator<<(std::ostream& out, const EcalMustacheSCParameters& params) { + params.print(out); + return out; + } + +protected: + float sqrtLogClustETuning_; + + // collection is expected to be sorted in ascending ParabolaParameters.log10EMin and ascending ParabolaParameters.etaMax + std::vector parabolaParametersCollection_; + + COND_SERIALIZABLE; +}; + +#endif diff --git a/CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h b/CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h new file mode 100644 index 0000000000000..dbee3cd8f5a5b --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h @@ -0,0 +1,50 @@ +#ifndef CondFormats_EcalObjects_EcalSCDynamicDPhiParameters_h +#define CondFormats_EcalObjects_EcalSCDynamicDPhiParameters_h + +#include +#include + +#include "CondFormats/Serialization/interface/Serializable.h" + +namespace reco { + class SCDynamicDPhiParametersHelper; +} // namespace reco + +class EcalSCDynamicDPhiParameters { +public: + EcalSCDynamicDPhiParameters(){}; + virtual ~EcalSCDynamicDPhiParameters() = default; + + struct DynamicDPhiParameters { + double eMin; + double etaMin; + double yoffset; + double scale; + double xoffset; + double width; + double saturation; + double cutoff; + + COND_SERIALIZABLE; + }; + + const DynamicDPhiParameters* dynamicDPhiParameters(double clustE, double absSeedEta) const; + + // helper class to set parameters + friend class reco::SCDynamicDPhiParametersHelper; + + // print parameters to stream: + void print(std::ostream&) const; + friend std::ostream& operator<<(std::ostream& out, const EcalSCDynamicDPhiParameters& params) { + params.print(out); + return out; + } + +protected: + // collection is expected to be sorted in ascending DynamicDPhiParameters.eMin and ascending DynamicDPhiParameters.etaMax + std::vector dynamicDPhiParametersCollection_; + + COND_SERIALIZABLE; +}; + +#endif diff --git a/CondFormats/EcalObjects/src/EcalMustacheSCParameters.cc b/CondFormats/EcalObjects/src/EcalMustacheSCParameters.cc new file mode 100644 index 0000000000000..04469103d4c1d --- /dev/null +++ b/CondFormats/EcalObjects/src/EcalMustacheSCParameters.cc @@ -0,0 +1,71 @@ +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" + +float EcalMustacheSCParameters::sqrtLogClustETuning() const { return sqrtLogClustETuning_; } + +const EcalMustacheSCParameters::ParabolaParameters* EcalMustacheSCParameters::parabolaParameters( + float log10ClustE, float absSeedEta) const { + // assume the collection is lexicographically sorted in ascending ParabolaParameters.log10EMin and ascending ParabolaParameters.etaMin + // find the matching log10EMin value + auto it1 = std::lower_bound(parabolaParametersCollection_.begin(), + parabolaParametersCollection_.end(), + log10ClustE, + [](const EcalMustacheSCParameters::ParabolaParameters& params, const double var) { + return params.log10EMin < var; + }); + if (it1 != parabolaParametersCollection_.begin()) { + --it1; + } + + // find the matching log10EMin and etaMin entry going only up to the sets matching for log10ClustE + const auto vars = std::make_pair(it1->log10EMin, absSeedEta); + auto it2 = std::lower_bound( + parabolaParametersCollection_.begin(), + it1 + 1, + vars, + [](const EcalMustacheSCParameters::ParabolaParameters& params, const std::pair vars) { + return params.log10EMin < vars.first || params.etaMin < vars.second; + }); + + return (it2 != parabolaParametersCollection_.begin()) ? &*(it2 - 1) : nullptr; +} + +void EcalMustacheSCParameters::print(std::ostream& out) const { + out << "Mustache SC parameters:" << std::endl; + out << " sqrtLogClustETuning: " << sqrtLogClustETuning_ << std::endl; + out << " Parabola parameters are binned in " << parabolaParametersCollection_.size() << " (log10(E), |eta|) regions." + << std::endl; + for (const auto& params : parabolaParametersCollection_) { + out << " Parameters for log10(E_min)=" << params.log10EMin << " and |eta_min|=" << params.etaMin << ":" + << std::endl; + + out << " pUp:" << std::endl; + for (size_t i = 0; i < params.pUp.size(); ++i) { + out << " [" << i << "]: " << params.pUp[i] << std::endl; + } + + out << " pLow:" << std::endl; + for (size_t i = 0; i < params.pLow.size(); ++i) { + out << " [" << i << "]: " << params.pLow[i] << std::endl; + } + + out << " w0Up:" << std::endl; + for (size_t i = 0; i < params.w0Up.size(); ++i) { + out << " [" << i << "]: " << params.w0Up[i] << std::endl; + } + + out << " w1Up:" << std::endl; + for (size_t i = 0; i < params.w1Up.size(); ++i) { + out << " [" << i << "]: " << params.w1Up[i] << std::endl; + } + + out << " w0Low:" << std::endl; + for (size_t i = 0; i < params.w0Low.size(); ++i) { + out << " [" << i << "]: " << params.w0Low[i] << std::endl; + } + + out << " w1Low:" << std::endl; + for (size_t i = 0; i < params.w1Low.size(); ++i) { + out << " [" << i << "]: " << params.w1Low[i] << std::endl; + } + } +} diff --git a/CondFormats/EcalObjects/src/EcalSCDynamicDPhiParameters.cc b/CondFormats/EcalObjects/src/EcalSCDynamicDPhiParameters.cc new file mode 100644 index 0000000000000..8734384db5f88 --- /dev/null +++ b/CondFormats/EcalObjects/src/EcalSCDynamicDPhiParameters.cc @@ -0,0 +1,42 @@ +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" + +const EcalSCDynamicDPhiParameters::DynamicDPhiParameters* EcalSCDynamicDPhiParameters::dynamicDPhiParameters( + double clustE, double absSeedEta) const { + // assume the collection is lexicographically sorted in ascending DynamicDPhiParams.eMin and ascending DynamicDPhiParams.etaMin + // find the matching eMin value + auto it1 = std::lower_bound(dynamicDPhiParametersCollection_.begin(), + dynamicDPhiParametersCollection_.end(), + clustE, + [](const EcalSCDynamicDPhiParameters::DynamicDPhiParameters& params, const double var) { + return params.eMin < var; + }); + if (it1 != dynamicDPhiParametersCollection_.begin()) { + --it1; + } + + // find the matching eMin and etaMin entry going only up to the sets matching for clustE + const auto vars = std::make_pair(it1->eMin, absSeedEta); + auto it2 = std::lower_bound( + dynamicDPhiParametersCollection_.begin(), + it1 + 1, + vars, + [](const EcalSCDynamicDPhiParameters::DynamicDPhiParameters& params, const std::pair vars) { + return params.eMin < vars.first || params.etaMin < vars.second; + }); + + return (it2 != dynamicDPhiParametersCollection_.begin()) ? &*(it2 - 1) : nullptr; +} + +void EcalSCDynamicDPhiParameters::print(std::ostream& out) const { + out << "SC dynamic dPhi parameters:" << std::endl; + out << " Parameters are binned in " << dynamicDPhiParametersCollection_.size() << " (E, |eta|) regions." << std::endl; + for (const auto& params : dynamicDPhiParametersCollection_) { + out << " Parameters for E_min=" << params.eMin << " and |eta_min|=" << params.etaMin << ":" << std::endl; + out << " yoffset: " << params.yoffset << std::endl; + out << " scale: " << params.scale << std::endl; + out << " xoffset: " << params.xoffset << std::endl; + out << " width: " << params.width << std::endl; + out << " saturation: " << params.saturation << std::endl; + out << " cutoff: " << params.cutoff << std::endl; + } +} diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalMustacheSCParameters.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalMustacheSCParameters.cc new file mode 100644 index 0000000000000..413f4b131c2cf --- /dev/null +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalMustacheSCParameters.cc @@ -0,0 +1,5 @@ +// user include files +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(EcalMustacheSCParameters); diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalSCDynamicDPhiParameters.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalSCDynamicDPhiParameters.cc new file mode 100644 index 0000000000000..48fd050bbf663 --- /dev/null +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalSCDynamicDPhiParameters.cc @@ -0,0 +1,5 @@ +// user include files +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(EcalSCDynamicDPhiParameters); diff --git a/CondFormats/EcalObjects/src/classes.h b/CondFormats/EcalObjects/src/classes.h index 2c40d0319ff6b..220714ded1644 100644 --- a/CondFormats/EcalObjects/src/classes.h +++ b/CondFormats/EcalObjects/src/classes.h @@ -64,169 +64,8 @@ #include "CondFormats/EcalObjects/interface/EcalTPGSpike.h" #include "CondFormats/EcalObjects/interface/EcalSRSettings.h" #include "CondFormats/EcalObjects/interface/EcalSimPulseShape.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" //ECAL PH2: #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" #include "CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h" - -namespace CondFormats_EcalObjects { - struct dictionary { - std::vector v_ecalChannelStatusCode; - EcalContainer ec_eeDetId_ecalChannelStatusCode; - EcalContainer ec_ebDetId_ecalChannelStatusCode; - EcalCondObjectContainer channelStatus; //typedef: EcalChannelStatus - - std::vector v_ecalDQMStatusCode; - EcalContainer ec_eeDetId_ecalDQMStatusCode; - EcalContainer ec_ebDetId_ecalDQMStatusCode; - EcalCondObjectContainer dqmChannelStatus; //typedef EcalDQMChannelStatus - - std::vector v_ecalMGPAGainRatio; - EcalContainer ec_eeDetId_ecalMGPAGainRatio; - EcalContainer ec_ebDetId_ecalMGPAGainRatio; - EcalCondObjectContainer gainratios; // typedef EcalGainRatios - - std::vector v_ecalMappingElement; - EcalContainer ec_eeDetId_ecalMappingElement; - EcalContainer ec_ebDetId_ecalMappingElement; - EcalCondObjectContainer ecalMap; //typedef EcalMappingElectronics - - std::vector v_ecalPedestal; - EcalContainer ec_eeDetId_ecalPedestal; - EcalContainer ec_ebDetId_ecalPedestal; - EcalCondObjectContainer pedmap; //typedef EcalPedestals - - //ECAL PH2: - std::vector v_ecalDTUPedestals; - EcalContainer ec_ebDetId_ecalLiteDTUPedestals; - EcalCondObjectContainer pedmapDTU; //typedef EcalPedestals - - std::vector v_ecalTPGCrystalStatusCode; - EcalContainer ec_eeDetId_ecalTPGCrystalStatusCode; - EcalContainer ec_ebDetId_ecalTPGCrystalStatusCode; - EcalCondObjectContainer tpgCrystalStatus; //typedef EcalTPGCrystalStatus - - std::vector v_ecalTPGLinearizationConstant; - EcalContainer ec_eeDetId_ecalTPGLinearizationConstant; - EcalContainer ec_ebDetId_ecalTPGLinearizationConstant; - EcalCondObjectContainer tpglinconstmap; //typedef EcalTPGLinearizationConst - - std::vector v_ecalTPGPedestal; - EcalContainer ec_eeDetId_ecalTPGPedestal; - EcalContainer ec_ebDetId_ecalTPGPedestal; - EcalCondObjectContainer tpgpedmap; //typedef EcalTPGPedestals - - std::vector v_ecalXtalGroupId; - EcalContainer ec_eeDetId_ecalXtalGroupId; - EcalContainer ec_ebDetId_ecalXtalGroupId; - EcalCondObjectContainer gg; //typedef EcalWeightXtalGroups - - EcalContainer ec_eeDetId_float; - EcalContainer ec_ebDetId_float; - EcalCondObjectContainer - floatCondObjectContainer; //typedefs: EcalFloatCondObjectContainer, EcalLinearCorrections, EcalIntercalibConstants, EcalIntercalibConstantsMC, EcalIntercalibErrors, EcalLaserAPDPNRatiosRef, EcalLaserAlphas, EcalTimeCalibConstants, EcalTimeCalibErrors, EcalPFRecHitThresholds - - EcalLaserAPDPNRatios laser_map; - std::vector laser_pair_map; - std::vector laser_time_map; - EcalContainer laser_ec_eeDetId_pair; - EcalContainer laser_ec_ebDetId_pair; - EcalCondObjectContainer laser_map_dm; - - EcalTimeDependentCorrections correction_map; - std::vector value_map; - std::vector time_map; - EcalContainer ec_eeDetId_pair; - EcalContainer ec_ebDetId_pair; - EcalCondObjectContainer correction_map_dm; - - EcalLinearCorrections linear_correction_map; - - EcalContainer ec_ettDetId_ecalChannelStatusCode; - EcalContainer ec_esDetId_ecalChannelStatusCode; - EcalCondTowerObjectContainer dcsTowerStatus; //typedef EcalDCSTowerStatus - - EcalContainer ec_ettDetId_ecalDAQStatusCode; - EcalContainer ec_esDetId_ecalDAQStatusCode; - EcalCondTowerObjectContainer daqTowerStatus; //typedef EcalDAQTowerStatus - - EcalContainer ec_ettDetId_ecalDQMStatusCode; - EcalContainer ec_esDetId_ecalDQMStatusCode; - EcalCondTowerObjectContainer dqmTowerStatus; //typedef EcalDQMTowerStatus - - EcalTBWeights tbwgt; - EcalWeightSet wset; - EcalTBWeights::EcalTDCId id; - std::pair wgpair; - std::map, EcalWeightSet> wgmap; - std::pair, EcalWeightSet> wgmapvalue; - - EcalSampleMask sampleMask; - - EcalADCToGeVConstant adcfactor; - - EcalTimeOffsetConstant timeOffsetConstant; - - EcalDCUTemperatures dcuTemperatures; - - EcalPTMTemperatures ptmTemperatures; - - EcalTPGFineGrainConstEB grain; - std::map EcalTPGFineGrainEBMap; - std::pair EcalTPGFineGrainEBMap_valuetype; - - std::map EcalTPGFineGrainStripEEMap; - std::pair EcalTPGFineGrainStripEEMap_valuetype; - - EcalTPGLut lut; - std::map EcalTPGLutMap; - std::pair EcalTPGLutMap_valuetype; - - EcalTPGWeights weightsweights; - std::map EcalTPGWeightMap; - std::pair EcalTPGWeightMap_valuetype; - - EcalFunParams - funParams; // typdefs: EcalClusterCrackCorrParameters, EcalClusterEnergyCorrectionObjectSpecificParameters, EcalClusterEnergyCorrectionParameters, EcalClusterEnergyUncertaintyParameters, EcalClusterLocalContCorrParameters - - EcalTPGFineGrainEBGroup fgrgroup; - - EcalTPGLutGroup lutgroup; - - EcalTPGWeightGroup wgroup; - - EcalTPGPhysicsConst::Item foo1; - std::map phConst; - std::pair phConst_valuetype; - - EcalTPGTowerStatus towerstatus; - std::map tStatus; - std::pair tStatus_valuetype; - - EcalTPGTowerStatus stripstatus; - - EcalTPGTowerStatus spike; - - EcalSRSettings ecalSRSettings; - - EcalTimeBiasCorrections timeBiasCorrections; - - EcalSamplesCorrelation samplesCorrelation; - - std::vector v_ecalPulseShape; - EcalContainer ec_eeDetId_ecalPulseShape; - EcalContainer ec_ebDetId_ecalPulseShape; - EcalCondObjectContainer ecalPSmap; //typedef EcalPulseShape - - std::vector v_ecalPulseCovariance; - EcalContainer ec_eeDetId_ecalPulseCovariance; - EcalContainer ec_ebDetId_ecalPulseCovariance; - EcalCondObjectContainer ecalPCmap; //typedef EcalPulseCovariance - - std::vector v_ecalPulseSymmCovariance; - EcalContainer ec_eeDetId_ecalPulseSymmCovariance; - EcalContainer ec_ebDetId_ecalPulseSymmCovariance; - EcalCondObjectContainer ecalSPCmap; //typedef EcalPulseSymmCovariance - - EcalSimPulseShape ecal_sim_pulse_shapes; - }; -} // namespace CondFormats_EcalObjects diff --git a/CondFormats/EcalObjects/src/classes_def.xml b/CondFormats/EcalObjects/src/classes_def.xml index c5cc8af4e828b..8a64c5b637176 100644 --- a/CondFormats/EcalObjects/src/classes_def.xml +++ b/CondFormats/EcalObjects/src/classes_def.xml @@ -291,4 +291,14 @@ + + + + + + + + + + diff --git a/CondFormats/EcalObjects/src/headers.h b/CondFormats/EcalObjects/src/headers.h index 8e2b47dc61be3..35296d9e63edb 100644 --- a/CondFormats/EcalObjects/src/headers.h +++ b/CondFormats/EcalObjects/src/headers.h @@ -6,6 +6,8 @@ #include "CondFormats/EcalObjects/interface/EcalPulseSymmCovariances.h" #include "CondFormats/EcalObjects/interface/EcalPFRecHitThresholds.h" #include "CondFormats/EcalObjects/interface/EcalSimPulseShape.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" #include "CondFormats/External/interface/EcalDetID.h" #include "CondFormats/External/interface/SMatrix.h" diff --git a/CondFormats/EcalObjects/test/testSerializationEcalObjects.cpp b/CondFormats/EcalObjects/test/testSerializationEcalObjects.cpp index 4513d323c1e91..014d131cc0878 100644 --- a/CondFormats/EcalObjects/test/testSerializationEcalObjects.cpp +++ b/CondFormats/EcalObjects/test/testSerializationEcalObjects.cpp @@ -158,6 +158,14 @@ int main() { testSerialization>(); testSerialization>(); testSerialization>(); + testSerialization(); + testSerialization(); + testSerialization>(); + testSerialization>(); + testSerialization(); + testSerialization(); + testSerialization>(); + testSerialization>(); return 0; } diff --git a/CondTools/Ecal/plugins/EcalMustacheSCParametersMaker.cc b/CondTools/Ecal/plugins/EcalMustacheSCParametersMaker.cc new file mode 100644 index 0000000000000..fee8c7e863877 --- /dev/null +++ b/CondTools/Ecal/plugins/EcalMustacheSCParametersMaker.cc @@ -0,0 +1,68 @@ +// -*- C++ -*- +// +// Package: RecoEcal/EcalMustacheSCParametersMaker +// Class: EcalMustacheSCParametersMaker +// +/**\class EcalMustacheSCParametersMaker EcalMustacheSCParametersMaker.cc + + Description: Writes EcalMustacheSCParameters to the DB + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Thomas Reis +// Created: Thu, 05 Nov 2020 09:18:19 GMT +// +// + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Utilities/interface/Exception.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondCore/DBOutputService/interface/PoolDBOutputService.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" + +class EcalMustacheSCParametersMaker : public edm::one::EDAnalyzer<> { +public: + explicit EcalMustacheSCParametersMaker(const edm::ParameterSet&); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void analyze(const edm::Event&, const edm::EventSetup&) override; + + edm::ESGetToken parametersToken_; +}; + +EcalMustacheSCParametersMaker::EcalMustacheSCParametersMaker(const edm::ParameterSet& iConfig) + : parametersToken_(esConsumes()) {} + +void EcalMustacheSCParametersMaker::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::ESHandle esParamsHandle_ = iSetup.getHandle(parametersToken_); + + edm::Service poolDbService; + if (poolDbService.isAvailable()) { + poolDbService->writeOne(esParamsHandle_.product(), poolDbService->currentTime(), "EcalMustacheSCParametersRcd"); + } else { + throw cms::Exception("PoolDBService") << "No PoolDBService available."; + } +} + +void EcalMustacheSCParametersMaker::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + descriptions.addDefault(desc); +} + +DEFINE_FWK_MODULE(EcalMustacheSCParametersMaker); diff --git a/CondTools/Ecal/plugins/EcalSCDynamicDPhiParametersMaker.cc b/CondTools/Ecal/plugins/EcalSCDynamicDPhiParametersMaker.cc new file mode 100644 index 0000000000000..e5e6fb0521196 --- /dev/null +++ b/CondTools/Ecal/plugins/EcalSCDynamicDPhiParametersMaker.cc @@ -0,0 +1,68 @@ +// -*- C++ -*- +// +// Package: RecoEcal/EcalSCDynamicDPhiParametersMaker +// Class: EcalSCDynamicDPhiParametersMaker +// +/**\class EcalSCDynamicDPhiParametersMaker EcalSCDynamicDPhiParametersMaker.cc + + Description: Writes EcalSCDynamicDPhiParameters to the DB + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Thomas Reis +// Created: Thu, 05 Nov 2020 12:32:03 GMT +// +// + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Utilities/interface/Exception.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondCore/DBOutputService/interface/PoolDBOutputService.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" + +class EcalSCDynamicDPhiParametersMaker : public edm::one::EDAnalyzer<> { +public: + explicit EcalSCDynamicDPhiParametersMaker(const edm::ParameterSet&); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + void analyze(const edm::Event&, const edm::EventSetup&) override; + + edm::ESGetToken parametersToken_; +}; + +EcalSCDynamicDPhiParametersMaker::EcalSCDynamicDPhiParametersMaker(const edm::ParameterSet& iConfig) + : parametersToken_(esConsumes()) {} + +void EcalSCDynamicDPhiParametersMaker::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::ESHandle esParamsHandle_ = iSetup.getHandle(parametersToken_); + + edm::Service poolDbService; + if (poolDbService.isAvailable()) { + poolDbService->writeOne(esParamsHandle_.product(), poolDbService->currentTime(), "EcalSCDynamicDPhiParametersRcd"); + } else { + throw cms::Exception("PoolDBService") << "No PoolDBService available."; + } +} + +void EcalSCDynamicDPhiParametersMaker::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + descriptions.addDefault(desc); +} + +DEFINE_FWK_MODULE(EcalSCDynamicDPhiParametersMaker); diff --git a/CondTools/Ecal/test/EcalMustacheSCParametersMaker_cfg.py b/CondTools/Ecal/test/EcalMustacheSCParametersMaker_cfg.py new file mode 100644 index 0000000000000..1f41796245daf --- /dev/null +++ b/CondTools/Ecal/test/EcalMustacheSCParametersMaker_cfg.py @@ -0,0 +1,30 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("EcalMustacheSCParametersMakerwrite") + +# Load CondDB service +process.load("CondCore.CondDB.CondDB_cfi") + +# output database +process.CondDB.connect = 'sqlite_file:ecalmustachescparameters.db' + +# load the ESSource and ESProducer for the record +process.load("RecoEcal.EgammaCoreTools.EcalMustacheSCParametersESProducer_cff") + +process.PoolDBOutputService = cms.Service("PoolDBOutputService", + process.CondDB, + toPut = cms.VPSet( + cms.PSet( + record = cms.string('EcalMustacheSCParametersRcd'), + tag = cms.string('EcalMustacheSCParameters_average') + ) + ) +) + +process.source = cms.Source("EmptySource") +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1)) + +process.ecalMustacheSCParamsMaker = cms.EDAnalyzer("EcalMustacheSCParametersMaker") + +process.path = cms.Path(process.ecalMustacheSCParamsMaker) + diff --git a/CondTools/Ecal/test/EcalSCDynamicDPhiParametersMaker_cfg.py b/CondTools/Ecal/test/EcalSCDynamicDPhiParametersMaker_cfg.py new file mode 100644 index 0000000000000..04899548ce734 --- /dev/null +++ b/CondTools/Ecal/test/EcalSCDynamicDPhiParametersMaker_cfg.py @@ -0,0 +1,30 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("EcalSCDynamicDPhiParametersMakerwrite") + +# Load CondDB service +process.load("CondCore.CondDB.CondDB_cfi") + +# output database +process.CondDB.connect = 'sqlite_file:ecalscdynamicdphiparameters.db' + +# load the ESSource and ESProducer for the record +process.load("RecoEcal.EgammaCoreTools.EcalSCDynamicDPhiParametersESProducer_cff") + +process.PoolDBOutputService = cms.Service("PoolDBOutputService", + process.CondDB, + toPut = cms.VPSet( + cms.PSet( + record = cms.string('EcalSCDynamicDPhiParametersRcd'), + tag = cms.string('EcalSCDynamicDPhiParameters_local') + ) + ) +) + +process.source = cms.Source("EmptySource") +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1)) + +process.ecalSCDynamicDPhiParamsMaker = cms.EDAnalyzer("EcalSCDynamicDPhiParametersMaker") + +process.path = cms.Path(process.ecalSCDynamicDPhiParamsMaker) + diff --git a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py index a39bf91851e18..f7ab7e23d72e6 100644 --- a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py +++ b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py @@ -202,6 +202,16 @@ def customiseFor2018Input(process): process = customisePixelGainForRun2Input(process) process = synchronizeHCALHLTofflineRun3on2018data(process) +def customiseFor32066(process): + """Add the ESSource and ESProducer for the mustache SC and the dynamic dphi parameters records""" + + # create the EcalMustacheSCParameters record + process.load('RecoEcal.EgammaCoreTools.EcalMustacheSCParametersESProducer_cff') + # create the EcalSCDynamicDPhiParameters record + process.load('RecoEcal.EgammaCoreTools.EcalSCDynamicDPhiParametersESProducer_cff') + + return process + # CMSSW version specific customizations def customizeHLTforCMSSW(process, menuType="GRun"): @@ -209,4 +219,6 @@ def customizeHLTforCMSSW(process, menuType="GRun"): # add call to action function in proper order: newest last! # process = customiseFor12718(process) + process = customiseFor32066(process) + return process diff --git a/RecoEcal/EgammaClusterAlgos/interface/PFECALSuperClusterAlgo.h b/RecoEcal/EgammaClusterAlgos/interface/PFECALSuperClusterAlgo.h index 239f244485c49..4e3558e89fe90 100644 --- a/RecoEcal/EgammaClusterAlgos/interface/PFECALSuperClusterAlgo.h +++ b/RecoEcal/EgammaClusterAlgos/interface/PFECALSuperClusterAlgo.h @@ -32,6 +32,11 @@ #include "CondFormats/DataRecord/interface/ESChannelStatusRcd.h" #include "CondFormats/ESObjects/interface/ESEEIntercalibConstants.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" + #include #include @@ -106,6 +111,7 @@ class PFECALSuperClusterAlgo { void setTokens(const edm::ParameterSet&, edm::ConsumesCollector&&); void update(const edm::EventSetup&); + void updateSCParams(const edm::EventSetup&); std::unique_ptr& getEBOutputSCCollection() { return superClustersEB_; } std::unique_ptr& getEEOutputSCCollection() { return superClustersEE_; } @@ -121,9 +127,13 @@ class PFECALSuperClusterAlgo { edm::ESGetToken esEEInterCalibToken_; edm::ESGetToken esChannelStatusToken_; + edm::ESGetToken ecalMustacheSCParametersToken_; + edm::ESGetToken ecalSCDynamicDPhiParametersToken_; const reco::BeamSpot* beamSpot_; const ESChannelStatus* channelStatus_; + const EcalMustacheSCParameters* mustacheSCParams_; + const EcalSCDynamicDPhiParameters* scDynamicDPhiParams_; CalibratedClusterPtrVector _clustersEB; CalibratedClusterPtrVector _clustersEE; diff --git a/RecoEcal/EgammaClusterAlgos/src/PFECALSuperClusterAlgo.cc b/RecoEcal/EgammaClusterAlgos/src/PFECALSuperClusterAlgo.cc index 063151c7be66f..24c9cb9cf5093 100644 --- a/RecoEcal/EgammaClusterAlgos/src/PFECALSuperClusterAlgo.cc +++ b/RecoEcal/EgammaClusterAlgos/src/PFECALSuperClusterAlgo.cc @@ -84,20 +84,23 @@ namespace { bool isClustered(const CalibClusterPtr& x, const CalibClusterPtr seed, const PFECALSuperClusterAlgo::clustering_type type, + const EcalMustacheSCParameters* mustache_params, + const EcalSCDynamicDPhiParameters* dynamic_dphi_params, const bool dyn_dphi, const double etawidthSuperCluster, const double phiwidthSuperCluster) { const double dphi = std::abs(TVector2::Phi_mpi_pi(seed->phi() - x->phi())); - const bool passes_dphi = ((!dyn_dphi && dphi < phiwidthSuperCluster) || - (dyn_dphi && reco::MustacheKernel::inDynamicDPhiWindow( - seed->eta(), seed->phi(), x->energy_nocalib(), x->eta(), x->phi()))); + const bool passes_dphi = + ((!dyn_dphi && dphi < phiwidthSuperCluster) || + (dyn_dphi && reco::MustacheKernel::inDynamicDPhiWindow( + dynamic_dphi_params, seed->eta(), seed->phi(), x->energy_nocalib(), x->eta(), x->phi()))); if (type == PFECALSuperClusterAlgo::kBOX) { return (std::abs(seed->eta() - x->eta()) < etawidthSuperCluster && passes_dphi); } if (type == PFECALSuperClusterAlgo::kMustache) { - return (passes_dphi && - reco::MustacheKernel::inMustache(seed->eta(), seed->phi(), x->energy_nocalib(), x->eta(), x->phi())); + return (passes_dphi && reco::MustacheKernel::inMustache( + mustache_params, seed->eta(), seed->phi(), x->energy_nocalib(), x->eta(), x->phi())); } return false; } @@ -119,6 +122,8 @@ void PFECALSuperClusterAlgo::setTokens(const edm::ParameterSet& iConfig, edm::Co esEEInterCalibToken_ = cc.esConsumes(); esChannelStatusToken_ = cc.esConsumes(); + ecalMustacheSCParametersToken_ = cc.esConsumes(); + ecalSCDynamicDPhiParametersToken_ = cc.esConsumes(); if (useRegression_) { const edm::ParameterSet& regconf = iConfig.getParameter("regressionConfig"); @@ -145,6 +150,11 @@ void PFECALSuperClusterAlgo::update(const edm::EventSetup& setup) { channelStatus_ = esChannelStatusHandle_.product(); } +void PFECALSuperClusterAlgo::updateSCParams(const edm::EventSetup& setup) { + mustacheSCParams_ = &setup.getData(ecalMustacheSCParametersToken_); + scDynamicDPhiParams_ = &setup.getData(ecalSCDynamicDPhiParametersToken_); +} + void PFECALSuperClusterAlgo::loadAndSortPFClusters(const edm::Event& iEvent) { //load input collections //Load the pfcluster collections @@ -267,8 +277,15 @@ void PFECALSuperClusterAlgo::buildSuperCluster(CalibClusterPtr& seed, CalibClust default: break; } - auto isClusteredWithSeed = - std::bind(isClustered, _1, seed, _clustype, useDynamicDPhi_, etawidthSuperCluster, phiwidthSuperCluster); + auto isClusteredWithSeed = std::bind(isClustered, + _1, + seed, + _clustype, + mustacheSCParams_, + scDynamicDPhiParams_, + useDynamicDPhi_, + etawidthSuperCluster, + phiwidthSuperCluster); auto matchesSeedByRecHit = std::bind(isLinkedByRecHit, _1, seed, satelliteThreshold_, fractionForMajority_, 0.1, 0.2); // this function shuffles the list of clusters into a list diff --git a/RecoEcal/EgammaClusterProducers/python/particleFlowSuperClusterECAL_cfi.py b/RecoEcal/EgammaClusterProducers/python/particleFlowSuperClusterECAL_cfi.py index a41c8e07ccfd5..873adaa6a756e 100644 --- a/RecoEcal/EgammaClusterProducers/python/particleFlowSuperClusterECAL_cfi.py +++ b/RecoEcal/EgammaClusterProducers/python/particleFlowSuperClusterECAL_cfi.py @@ -2,6 +2,11 @@ from RecoEcal.EgammaClusterProducers.particleFlowSuperClusterECALMustache_cfi import particleFlowSuperClusterECALMustache as _particleFlowSuperClusterECALMustache +# create the EcalMustacheSCParameters record on the fly +from RecoEcal.EgammaCoreTools.EcalMustacheSCParametersESProducer_cff import * +# create the EcalSCDynamicDPhiParameters record on the fly +from RecoEcal.EgammaCoreTools.EcalSCDynamicDPhiParametersESProducer_cff import * + # define the default ECAL clustering (Mustache or Box) particleFlowSuperClusterECAL = _particleFlowSuperClusterECALMustache.clone() diff --git a/RecoEcal/EgammaClusterProducers/src/PFECALSuperClusterProducer.cc b/RecoEcal/EgammaClusterProducers/src/PFECALSuperClusterProducer.cc index 240cb42c09bbd..4ab57e1d1bf29 100644 --- a/RecoEcal/EgammaClusterProducers/src/PFECALSuperClusterProducer.cc +++ b/RecoEcal/EgammaClusterProducers/src/PFECALSuperClusterProducer.cc @@ -164,6 +164,8 @@ void PFECALSuperClusterProducer::beginLuminosityBlock(LuminosityBlock const& iL, } void PFECALSuperClusterProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + // update SC parameters + superClusterAlgo_.updateSCParams(iSetup); // do clustering superClusterAlgo_.loadAndSortPFClusters(iEvent); superClusterAlgo_.run(); diff --git a/RecoEcal/EgammaClusterProducers/test/PFSuperClusterTreeMaker.cc b/RecoEcal/EgammaClusterProducers/test/PFSuperClusterTreeMaker.cc index 29cfd4c871dea..7843a62f04359 100644 --- a/RecoEcal/EgammaClusterProducers/test/PFSuperClusterTreeMaker.cc +++ b/RecoEcal/EgammaClusterProducers/test/PFSuperClusterTreeMaker.cc @@ -34,6 +34,10 @@ #include "DataFormats/HepMCCandidate/interface/GenParticle.h" #include "RecoEcal/EgammaCoreTools/interface/Mustache.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" namespace MK = reco::MustacheKernel; #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h" @@ -78,7 +82,7 @@ class PFSuperClusterTreeMaker : public edm::EDAnalyzer { PFSuperClusterTreeMaker(const PSet&); ~PFSuperClusterTreeMaker() {} - void analyze(const edm::Event&, const edm::EventSetup&); + void analyze(const edm::Event&, const edm::EventSetup&) override; private: edm::Service _fs; @@ -91,6 +95,13 @@ class PFSuperClusterTreeMaker : public edm::EDAnalyzer { std::map _genmatched; void findBestGenMatches(const edm::Event& e, const edm::Handle& scs); void processSuperClusterFillTree(const edm::Event&, const reco::SuperClusterRef&); + + // SC parameters + edm::ESGetToken ecalMustacheSCParametersToken_; + const EcalMustacheSCParameters* mustacheSCParams_; + edm::ESGetToken ecalSCDynamicDPhiParametersToken_; + const EcalSCDynamicDPhiParameters* scDynamicDPhiParams_; + // the tree void setTreeArraysForSize(const size_t N_ECAL, const size_t N_PS); treeptr _tree; @@ -108,6 +119,9 @@ class PFSuperClusterTreeMaker : public edm::EDAnalyzer { }; void PFSuperClusterTreeMaker::analyze(const edm::Event& e, const edm::EventSetup& es) { + mustacheSCParams_ = &es.getData(ecalMustacheSCParametersToken_); + scDynamicDPhiParams_ = &es.getData(ecalSCDynamicDPhiParametersToken_); + edm::Handle vtcs; e.getByLabel(_vtxsrc, vtcs); if (vtcs.isValid()) @@ -261,11 +275,11 @@ void PFSuperClusterTreeMaker::processSuperClusterFillTree(const edm::Event& e, c clusterDPhiToGen.get()[iclus] = TVector2::Phi_mpi_pi((*clus)->phi() - genmatch->phi()); clusterDEtaToGen.get()[iclus] = (*clus)->eta() - genmatch->eta(); } - clusterInMustache.get()[iclus] = - (Int_t)MK::inMustache(theseed->eta(), theseed->phi(), (*clus)->energy(), (*clus)->eta(), (*clus)->phi()); + clusterInMustache.get()[iclus] = (Int_t)MK::inMustache( + mustacheSCParams_, theseed->eta(), theseed->phi(), (*clus)->energy(), (*clus)->eta(), (*clus)->phi()); clusterInDynDPhi.get()[iclus] = (Int_t)MK::inDynamicDPhiWindow( - theseed->eta(), theseed->phi(), (*clus)->energy(), (*clus)->eta(), (*clus)->phi()); + scDynamicDPhiParams_, theseed->eta(), theseed->phi(), (*clus)->energy(), (*clus)->eta(), (*clus)->phi()); ++iclus; } // loop over all preshower clusters @@ -283,6 +297,9 @@ void PFSuperClusterTreeMaker::processSuperClusterFillTree(const edm::Event& e, c } PFSuperClusterTreeMaker::PFSuperClusterTreeMaker(const PSet& p) { + ecalMustacheSCParametersToken_ = esConsumes(); + ecalSCDynamicDPhiParametersToken_ = esConsumes(); + _calib.reset(new PFEnergyCalibration()); N_ECALClusters = 1; N_PSClusters = 1; diff --git a/RecoEcal/EgammaCoreTools/interface/Mustache.h b/RecoEcal/EgammaCoreTools/interface/Mustache.h index 6e472b6a5becc..5e74a819c06d8 100644 --- a/RecoEcal/EgammaCoreTools/interface/Mustache.h +++ b/RecoEcal/EgammaCoreTools/interface/Mustache.h @@ -5,18 +5,30 @@ #include "DataFormats/CaloRecHit/interface/CaloCluster.h" #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" #include "DataFormats/EgammaReco/interface/SuperCluster.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" namespace reco { namespace MustacheKernel { - bool inMustache( - const float maxEta, const float maxPhi, const float ClustE, const float ClusEta, const float ClusPhi); - bool inDynamicDPhiWindow( - const float seedEta, const float seedPhi, const float ClustE, const float ClusEta, const float clusPhi); + bool inMustache(const EcalMustacheSCParameters* params, + const float maxEta, + const float maxPhi, + const float ClustE, + const float ClusEta, + const float ClusPhi); + bool inDynamicDPhiWindow(const EcalSCDynamicDPhiParameters* params, + const float seedEta, + const float seedPhi, + const float ClustE, + const float ClusEta, + const float clusPhi); } // namespace MustacheKernel class Mustache { public: + Mustache(const EcalMustacheSCParameters* mustache_params); + void MustacheID(const CaloClusterPtrVector& clusters, int& nclusters, float& EoutsideMustache); void MustacheID(const std::vector&, int& nclusers, float& EoutsideMustache); void MustacheID(const reco::SuperCluster& sc, int& nclusters, float& EoutsideMustache); @@ -47,6 +59,7 @@ namespace reco { float LowestClusterEInMustache_; int excluded_; int included_; + const EcalMustacheSCParameters* mustache_params_; }; } // namespace reco diff --git a/RecoEcal/EgammaCoreTools/interface/MustacheSCParametersHelper.h b/RecoEcal/EgammaCoreTools/interface/MustacheSCParametersHelper.h new file mode 100644 index 0000000000000..ddb179be85410 --- /dev/null +++ b/RecoEcal/EgammaCoreTools/interface/MustacheSCParametersHelper.h @@ -0,0 +1,25 @@ +#ifndef RecoEcal_EgammaCoreTools_MustacheSCParametersHelper_h +#define RecoEcal_EgammaCoreTools_MustacheSCParametersHelper_h + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" + +namespace reco { + + class MustacheSCParametersHelper { + public: + MustacheSCParametersHelper(EcalMustacheSCParameters ¶ms, const edm::ParameterSet &iConfig); + ~MustacheSCParametersHelper() = default; + + void setSqrtLogClustETuning(const float sqrtLogClustETuning); + + void addParabolaParameters(const EcalMustacheSCParameters::ParabolaParameters ¶bolaParams); + void sortParabolaParametersCollection(); + + private: + EcalMustacheSCParameters ¶meters_; + }; + +} // namespace reco + +#endif diff --git a/RecoEcal/EgammaCoreTools/interface/SCDynamicDPhiParametersHelper.h b/RecoEcal/EgammaCoreTools/interface/SCDynamicDPhiParametersHelper.h new file mode 100644 index 0000000000000..2b72a41ed7646 --- /dev/null +++ b/RecoEcal/EgammaCoreTools/interface/SCDynamicDPhiParametersHelper.h @@ -0,0 +1,23 @@ +#ifndef RecoEcal_EgammaCoreTools_SCDynamicDPhiParametersHelper_h +#define RecoEcal_EgammaCoreTools_SCDynamicDPhiParametersHelper_h + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" + +namespace reco { + + class SCDynamicDPhiParametersHelper { + public: + SCDynamicDPhiParametersHelper(EcalSCDynamicDPhiParameters ¶ms, const edm::ParameterSet &iConfig); + ~SCDynamicDPhiParametersHelper() = default; + + void addDynamicDPhiParameters(const EcalSCDynamicDPhiParameters::DynamicDPhiParameters &dynDPhiParams); + void sortDynamicDPhiParametersCollection(); + + private: + EcalSCDynamicDPhiParameters ¶meters_; + }; + +} // namespace reco + +#endif diff --git a/RecoEcal/EgammaCoreTools/plugins/EcalMustacheSCParametersESProducer.cc b/RecoEcal/EgammaCoreTools/plugins/EcalMustacheSCParametersESProducer.cc new file mode 100644 index 0000000000000..3752dcee4f9eb --- /dev/null +++ b/RecoEcal/EgammaCoreTools/plugins/EcalMustacheSCParametersESProducer.cc @@ -0,0 +1,105 @@ +// -*- C++ -*- +// +// Package: RecoEcal/EgammaCoreTools +// Class: EcalMustacheSCParametersESProducer +// +/**\class EcalMustacheSCParametersESProducer + + Description: Produces the mustache superclusedr parameters + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Thomas Reis +// Created: Wed, 21 Oct 2020 15:05:26 GMT +// +// + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" +#include "RecoEcal/EgammaCoreTools/interface/MustacheSCParametersHelper.h" + +// +// class declaration +// + +class EcalMustacheSCParametersESProducer : public edm::ESProducer { +public: + EcalMustacheSCParametersESProducer(const edm::ParameterSet&); + ~EcalMustacheSCParametersESProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + using ReturnType = std::unique_ptr; + + ReturnType produce(const EcalMustacheSCParametersRcd&); + +private: + EcalMustacheSCParameters params_; +}; + +// +// constructors and destructor +// +EcalMustacheSCParametersESProducer::EcalMustacheSCParametersESProducer(const edm::ParameterSet& iConfig) { + setWhatProduced(this); + + reco::MustacheSCParametersHelper mustacheSCParams(params_, iConfig); +} + +EcalMustacheSCParametersESProducer::~EcalMustacheSCParametersESProducer() {} + +// +// member functions +// + +// ------------ method called to produce the data ------------ +EcalMustacheSCParametersESProducer::ReturnType EcalMustacheSCParametersESProducer::produce( + const EcalMustacheSCParametersRcd& iRecord) { + auto product = std::make_unique(params_); + return product; +} + +void EcalMustacheSCParametersESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("sqrtLogClustETuning", 1.1); + { + edm::ParameterSetDescription vpsd1; + vpsd1.add("log10EMin"); + vpsd1.add("etaMin"); + vpsd1.add>("pUp"); + vpsd1.add>("pLow"); + vpsd1.add>("w0Up"); + vpsd1.add>("w1Up"); + vpsd1.add>("w0Low"); + vpsd1.add>("w1Low"); + std::vector temp1; + temp1.reserve(1); + { + edm::ParameterSet temp2; + temp2.addParameter("log10EMin", -3.); + temp2.addParameter("etaMin", 0.); + temp2.addParameter>("pUp", {-0.107537, 0.590969, -0.076494}); + temp2.addParameter>("pLow", {-0.0268843, 0.147742, -0.0191235}); + temp2.addParameter>("w0Up", {-0.00681785, -0.00239516}); + temp2.addParameter>("w1Up", {0.000699995, -0.00554331}); + temp2.addParameter>("w0Low", {-0.00681785, -0.00239516}); + temp2.addParameter>("w1Low", {0.000699995, -0.00554331}); + temp1.push_back(temp2); + } + desc.addVPSet("parabolaParameterSets", vpsd1, temp1); + } + descriptions.add("ecalMustacheSCParametersESProducer", desc); +} + +//define this as a plug-in +DEFINE_FWK_EVENTSETUP_MODULE(EcalMustacheSCParametersESProducer); diff --git a/RecoEcal/EgammaCoreTools/plugins/EcalSCDynamicDPhiParametersESProducer.cc b/RecoEcal/EgammaCoreTools/plugins/EcalSCDynamicDPhiParametersESProducer.cc new file mode 100644 index 0000000000000..b2ec206fe0401 --- /dev/null +++ b/RecoEcal/EgammaCoreTools/plugins/EcalSCDynamicDPhiParametersESProducer.cc @@ -0,0 +1,104 @@ +// -*- C++ -*- +// +// Package: RecoEcal/EgammaCoreTools +// Class: EcalSCDynamicDPhiParametersESProducer +// +/**\class EcalSCDynamicDPhiParametersESProducer + + Description: Produces the supercluster dynamic dPhi parameters + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Thomas Reis +// Created: Wed, 28 Oct 2020 16:17:26 GMT +// +// + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" +#include +#include + +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" +#include "RecoEcal/EgammaCoreTools/interface/SCDynamicDPhiParametersHelper.h" + +// +// class declaration +// + +class EcalSCDynamicDPhiParametersESProducer : public edm::ESProducer { +public: + EcalSCDynamicDPhiParametersESProducer(const edm::ParameterSet&); + ~EcalSCDynamicDPhiParametersESProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + using ReturnType = std::unique_ptr; + + ReturnType produce(const EcalSCDynamicDPhiParametersRcd&); + +private: + EcalSCDynamicDPhiParameters params_; +}; + +// +// constructors and destructor +// +EcalSCDynamicDPhiParametersESProducer::EcalSCDynamicDPhiParametersESProducer(const edm::ParameterSet& iConfig) { + setWhatProduced(this); + + reco::SCDynamicDPhiParametersHelper scDynamicDPhiParams(params_, iConfig); +} + +EcalSCDynamicDPhiParametersESProducer::~EcalSCDynamicDPhiParametersESProducer() {} + +// +// member functions +// + +// ------------ method called to produce the data ------------ +EcalSCDynamicDPhiParametersESProducer::ReturnType EcalSCDynamicDPhiParametersESProducer::produce( + const EcalSCDynamicDPhiParametersRcd& iRecord) { + auto product = std::make_unique(params_); + return product; +} + +void EcalSCDynamicDPhiParametersESProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + { + edm::ParameterSetDescription vpsd1; + vpsd1.add("eMin"); + vpsd1.add("etaMin"); + vpsd1.add("yoffset"); + vpsd1.add("scale"); + vpsd1.add("xoffset"); + vpsd1.add("width"); + vpsd1.add("saturation"); + vpsd1.add("cutoff"); + std::vector temp1; + temp1.reserve(1); + { + edm::ParameterSet temp2; + temp2.addParameter("eMin", 0.); + temp2.addParameter("etaMin", 0.); + temp2.addParameter("yoffset", 0.0280506); + temp2.addParameter("scale", 0.946048); + temp2.addParameter("xoffset", -0.101172); + temp2.addParameter("width", 0.432767); + temp2.addParameter("saturation", 0.14); + temp2.addParameter("cutoff", 0.6); + temp1.push_back(temp2); + } + desc.addVPSet("dynamicDPhiParameterSets", vpsd1, temp1); + } + descriptions.add("ecalSCDynamicDPhiParametersESProducer", desc); +} + +//define this as a plug-in +DEFINE_FWK_EVENTSETUP_MODULE(EcalSCDynamicDPhiParametersESProducer); diff --git a/RecoEcal/EgammaCoreTools/python/EcalMustacheSCParametersESProducer_cff.py b/RecoEcal/EgammaCoreTools/python/EcalMustacheSCParametersESProducer_cff.py new file mode 100644 index 0000000000000..ef778d058eaee --- /dev/null +++ b/RecoEcal/EgammaCoreTools/python/EcalMustacheSCParametersESProducer_cff.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms + +ecalMustacheSCParamsSource = cms.ESSource( + "EmptyESSource", + recordName = cms.string('EcalMustacheSCParametersRcd'), + iovIsRunNotTime = cms.bool(True), + firstValid = cms.vuint32(1) +) + +from RecoEcal.EgammaCoreTools.EcalMustacheSCParametersESProducer_cfi import ecalMustacheSCParametersESProducer + diff --git a/RecoEcal/EgammaCoreTools/python/EcalMustacheSCParametersESProducer_cfi.py b/RecoEcal/EgammaCoreTools/python/EcalMustacheSCParametersESProducer_cfi.py new file mode 100644 index 0000000000000..6b99ef26641e7 --- /dev/null +++ b/RecoEcal/EgammaCoreTools/python/EcalMustacheSCParametersESProducer_cfi.py @@ -0,0 +1,22 @@ +import FWCore.ParameterSet.Config as cms + +ecalMustacheSCParametersESProducer = cms.ESProducer("EcalMustacheSCParametersESProducer", + sqrtLogClustETuning = cms.double(1.1), + + # Parameters from the analysis by L. Zygala [https://indico.cern.ch/event/949294/contributions/3988389/attachments/2091573/3514649/2020_08_26_Clustering.pdf] + # mustache parambola parameters depending on cluster energy and seed crystal eta + parabolaParameterSets = cms.VPSet( + # average parameters + cms.PSet( + log10EMin = cms.double(-3.), + etaMin = cms.double(0.), + pUp = cms.vdouble(-0.107537, 0.590969, -0.076494), + pLow = cms.vdouble(-0.0268843, 0.147742, -0.0191235), + w0Up = cms.vdouble( -0.00681785, -0.00239516), + w1Up = cms.vdouble( 0.000699995, -0.00554331), + w0Low = cms.vdouble(-0.00681785, -0.00239516), + w1Low = cms.vdouble(0.000699995, -0.00554331) + ) + ) +) + diff --git a/RecoEcal/EgammaCoreTools/python/EcalSCDynamicDPhiParametersESProducer_cff.py b/RecoEcal/EgammaCoreTools/python/EcalSCDynamicDPhiParametersESProducer_cff.py new file mode 100644 index 0000000000000..5800244eab91c --- /dev/null +++ b/RecoEcal/EgammaCoreTools/python/EcalSCDynamicDPhiParametersESProducer_cff.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms + +ecalSCDynamicDPhiParamsSource = cms.ESSource( + "EmptyESSource", + recordName = cms.string('EcalSCDynamicDPhiParametersRcd'), + iovIsRunNotTime = cms.bool(True), + firstValid = cms.vuint32(1) +) + +from RecoEcal.EgammaCoreTools.EcalSCDynamicDPhiParametersESProducer_cfi import ecalSCDynamicDPhiParametersESProducer + diff --git a/RecoEcal/EgammaCoreTools/python/EcalSCDynamicDPhiParametersESProducer_cfi.py b/RecoEcal/EgammaCoreTools/python/EcalSCDynamicDPhiParametersESProducer_cfi.py new file mode 100644 index 0000000000000..99e881ea11b35 --- /dev/null +++ b/RecoEcal/EgammaCoreTools/python/EcalSCDynamicDPhiParametersESProducer_cfi.py @@ -0,0 +1,49 @@ +import FWCore.ParameterSet.Config as cms + +ecalSCDynamicDPhiParametersESProducer = cms.ESProducer("EcalSCDynamicDPhiParametersESProducer", + # Parameters from the analysis by L. Zygala [https://indico.cern.ch/event/949294/contributions/3988389/attachments/2091573/3514649/2020_08_26_Clustering.pdf] + # dynamic dPhi parameters depending on cluster energy and seed crystal eta + dynamicDPhiParameterSets = cms.VPSet( + cms.PSet( + eMin = cms.double(0.), + etaMin = cms.double(2.), + yoffset = cms.double(0.0928887), + scale = cms.double(1.22321), + xoffset = cms.double(-0.260256), + width = cms.double(0.345852), + saturation = cms.double(0.12), + cutoff = cms.double(0.3) + ), + cms.PSet( + eMin = cms.double(0.), + etaMin = cms.double(1.75), + yoffset = cms.double(0.05643), + scale = cms.double(1.60429), + xoffset = cms.double(-0.642352), + width = cms.double(0.458106), + saturation = cms.double(0.12), + cutoff = cms.double(0.45) + ), + cms.PSet( + eMin = cms.double(0.), + etaMin = cms.double(1.479), + yoffset = cms.double(0.0497038), + scale = cms.double(0.975707), + xoffset = cms.double(-0.18149), + width = cms.double(0.431729), + saturation = cms.double(0.14), + cutoff = cms.double(0.55) + ), + cms.PSet( + eMin = cms.double(0.), + etaMin = cms.double(0.), + yoffset = cms.double(0.0280506), + scale = cms.double(0.946048), + xoffset = cms.double(-0.101172), + width = cms.double(0.432767), + saturation = cms.double(0.14), + cutoff = cms.double(0.6) + ) + ) +) + diff --git a/RecoEcal/EgammaCoreTools/src/Mustache.cc b/RecoEcal/EgammaCoreTools/src/Mustache.cc index 41d04a2a403bf..e5b1984c8ae3b 100644 --- a/RecoEcal/EgammaCoreTools/src/Mustache.cc +++ b/RecoEcal/EgammaCoreTools/src/Mustache.cc @@ -1,28 +1,21 @@ #include "RecoEcal/EgammaCoreTools/interface/Mustache.h" -#include "TMath.h" #include "TVector2.h" #include using namespace std; namespace reco { namespace MustacheKernel { - bool inMustache( - const float maxEta, const float maxPhi, const float ClustE, const float ClusEta, const float ClusPhi) { - //bool inMust=false; - //float eta0 = maxEta; - //float phi0 = maxPhi; - - constexpr float p00 = -0.107537; - constexpr float p01 = 0.590969; - constexpr float p02 = -0.076494; - constexpr float p10 = -0.0268843; - constexpr float p11 = 0.147742; - constexpr float p12 = -0.0191235; - - constexpr float w00 = -0.00681785; - constexpr float w01 = -0.00239516; - constexpr float w10 = 0.000699995; - constexpr float w11 = -0.00554331; + bool inMustache(const EcalMustacheSCParameters* params, + const float maxEta, + const float maxPhi, + const float ClustE, + const float ClusEta, + const float ClusPhi) { + const auto log10ClustE = std::log10(ClustE); + const auto parabola_params = params->parabolaParameters(log10ClustE, std::abs(ClusEta)); + if (!parabola_params) { + return false; + } const float sineta0 = std::sin(maxEta); const float eta0xsineta0 = maxEta * sineta0; @@ -33,114 +26,68 @@ namespace reco { //b comes from a fit to the width //and has a slight dependence on E on the upper edge // this only works because of fine tuning :-D - const float sqrt_log10_clustE = std::sqrt(std::log10(ClustE) + 1.1); - // we need to have this in two steps, so that we don't improperly shift - // the lower bound! - float b_upper = w10 * eta0xsineta0 + w11 / sqrt_log10_clustE; - float b_lower = w00 * eta0xsineta0 + w01 / sqrt_log10_clustE; - const float midpoint = 0.5 * (b_upper + b_lower); - b_upper -= midpoint; - b_lower -= midpoint; + const float sqrt_log10_clustE = std::sqrt(log10ClustE + params->sqrtLogClustETuning()); + const float b_upper = + parabola_params->w1Up[0] * eta0xsineta0 + parabola_params->w1Up[1] / sqrt_log10_clustE - + 0.5 * (parabola_params->w1Up[0] * eta0xsineta0 + parabola_params->w1Up[1] / sqrt_log10_clustE + + parabola_params->w0Up[0] * eta0xsineta0 + parabola_params->w0Up[1] / sqrt_log10_clustE); + const float b_lower = + parabola_params->w0Low[0] * eta0xsineta0 + parabola_params->w0Low[1] / sqrt_log10_clustE - + 0.5 * (parabola_params->w1Low[0] * eta0xsineta0 + parabola_params->w1Low[1] / sqrt_log10_clustE + + parabola_params->w0Low[0] * eta0xsineta0 + parabola_params->w0Low[1] / sqrt_log10_clustE); //the curvature comes from a parabolic //fit for many slices in eta given a //slice -0.1 < log10(Et) < 0.1 - const float curv_up = eta0xsineta0 * (p00 * eta0xsineta0 + p01) + p02; - const float curv_low = eta0xsineta0 * (p10 * eta0xsineta0 + p11) + p12; + const float curv_up = + eta0xsineta0 * (parabola_params->pUp[0] * eta0xsineta0 + parabola_params->pUp[1]) + parabola_params->pUp[2]; + const float curv_low = eta0xsineta0 * (parabola_params->pLow[0] * eta0xsineta0 + parabola_params->pLow[1]) + + parabola_params->pLow[2]; //solving for the curviness given the width of this particular point - const float a_upper = (1 / (4 * curv_up)) - fabs(b_upper); - const float a_lower = (1 / (4 * curv_low)) - fabs(b_lower); + const float a_upper = (1. / (4. * curv_up)) - std::abs(b_upper); + const float a_lower = (1. / (4. * curv_low)) - std::abs(b_lower); const double dphi = TVector2::Phi_mpi_pi(ClusPhi - maxPhi); const double dphi2 = dphi * dphi; // minimum offset is half a crystal width in either direction // because science. - const float upper_cut = (std::max((1. / (4. * a_upper)), 0.0) * dphi2 + std::max(b_upper, 0.0087f)) + 0.0087; - const float lower_cut = (std::max((1. / (4. * a_lower)), 0.0) * dphi2 + std::min(b_lower, -0.0087f)); - - //if(deta < upper_cut && deta > lower_cut) inMust=true; + constexpr float half_crystal_width = 0.0087; + const float upper_cut = + (std::max((1. / (4. * a_upper)), 0.0) * dphi2 + std::max(b_upper, half_crystal_width)) + half_crystal_width; + const float lower_cut = (std::max((1. / (4. * a_lower)), 0.0) * dphi2 + std::min(b_lower, -half_crystal_width)); const float deta = (1 - 2 * (maxEta < 0)) * (ClusEta - maxEta); // sign flip deta return (deta < upper_cut && deta > lower_cut); } - bool inDynamicDPhiWindow( - const float seedEta, const float seedPhi, const float ClustE, const float ClusEta, const float ClusPhi) { - // Parameters from the analysis by L. Zygala [https://indico.cern.ch/event/949294/contributions/3988389/attachments/2091573/3514649/2020_08_26_Clustering.pdf] - constexpr double yoffsetEB = 0.0280506; - constexpr double scaleEB = 0.946048; - constexpr double xoffsetEB = -0.101172; - constexpr double widthEB = 0.432767; - - constexpr double yoffsetEE_0 = 0.0497038; - constexpr double scaleEE_0 = 0.975707; - constexpr double xoffsetEE_0 = -0.18149; - constexpr double widthEE_0 = 0.431729; - - constexpr double yoffsetEE_1 = 0.05643; - constexpr double scaleEE_1 = 1.60429; - constexpr double xoffsetEE_1 = -0.642352; - constexpr double widthEE_1 = 0.458106; - - constexpr double yoffsetEE_2 = 0.0928887; - constexpr double scaleEE_2 = 1.22321; - constexpr double xoffsetEE_2 = -0.260256; - constexpr double widthEE_2 = 0.345852; - + bool inDynamicDPhiWindow(const EcalSCDynamicDPhiParameters* params, + const float seedEta, + const float seedPhi, + const float ClustE, + const float ClusEta, + const float ClusPhi) { const double absSeedEta = std::abs(seedEta); - const int etaBin = ((int)(absSeedEta >= 1.479) + (int)(absSeedEta >= 1.75) + (int)(absSeedEta >= 2.0)); const double logClustEt = std::log10(ClustE / std::cosh(ClusEta)); const double clusDphi = std::abs(TVector2::Phi_mpi_pi(seedPhi - ClusPhi)); - double yoffset, scale, xoffset, width, saturation, cutoff, maxdphi; - - switch (etaBin) { - case 0: // EB - yoffset = yoffsetEB; - scale = scaleEB; - xoffset = xoffsetEB; - width = 1.0 / widthEB; - saturation = 0.14; - cutoff = 0.60; - break; - case 1: // 1.479 -> 1.75 - yoffset = yoffsetEE_0; - scale = scaleEE_0; - xoffset = xoffsetEE_0; - width = 1.0 / widthEE_0; - saturation = 0.14; - cutoff = 0.55; - break; - case 2: // 1.75 -> 2.0 - yoffset = yoffsetEE_1; - scale = scaleEE_1; - xoffset = xoffsetEE_1; - width = 1.0 / widthEE_1; - saturation = 0.12; - cutoff = 0.45; - break; - case 3: // 2.0 and up - yoffset = yoffsetEE_2; - scale = scaleEE_2; - xoffset = xoffsetEE_2; - width = 1.0 / widthEE_2; - saturation = 0.12; - cutoff = 0.30; - break; - default: - throw cms::Exception("InValidEtaBin") - << "Calculated invalid eta bin = " << etaBin << " in \"inDynamicDPhiWindow\"" << std::endl; + const auto dynamicDPhiParams = params->dynamicDPhiParameters(ClustE, absSeedEta); + if (!dynamicDPhiParams) { + return false; } - maxdphi = yoffset + scale / (1 + std::exp((logClustEt - xoffset) * width)); - maxdphi = std::min(maxdphi, cutoff); - maxdphi = std::max(maxdphi, saturation); + auto maxdphi = dynamicDPhiParams->yoffset + + dynamicDPhiParams->scale / + (1. + std::exp((logClustEt - dynamicDPhiParams->xoffset) / dynamicDPhiParams->width)); + maxdphi = std::min(maxdphi, dynamicDPhiParams->cutoff); + maxdphi = std::max(maxdphi, dynamicDPhiParams->saturation); return clusDphi < maxdphi; } } // namespace MustacheKernel + Mustache::Mustache(const EcalMustacheSCParameters* mustache_params) : mustache_params_(mustache_params) {} + void Mustache::MustacheID(const reco::SuperCluster& sc, int& nclusters, float& EoutsideMustache) { MustacheID(sc.clustersBegin(), sc.clustersEnd(), nclusters, EoutsideMustache); } @@ -186,7 +133,7 @@ namespace reco { bool inMust = false; icl = begin; for (; icl != end; ++icl) { - inMust = MustacheKernel::inMustache(eta0, phi0, (*icl)->energy(), (*icl)->eta(), (*icl)->phi()); + inMust = MustacheKernel::inMustache(mustache_params_, eta0, phi0, (*icl)->energy(), (*icl)->eta(), (*icl)->phi()); nclusters += (int)!inMust; EoutsideMustache += (!inMust) * ((*icl)->energy()); @@ -217,8 +164,8 @@ namespace reco { float phi0 = (clusters[imax]).phi(); for (unsigned int k = 0; k < ncl; k++) { - bool inMust = - MustacheKernel::inMustache(eta0, phi0, (clusters[k]).energy(), (clusters[k]).eta(), (clusters[k]).phi()); + bool inMust = MustacheKernel::inMustache( + mustache_params_, eta0, phi0, (clusters[k]).energy(), (clusters[k]).eta(), (clusters[k]).phi()); //return indices of Clusters outside the Mustache if (!(inMust)) { outsideMust.push_back(k); diff --git a/RecoEcal/EgammaCoreTools/src/MustacheSCParametersHelper.cc b/RecoEcal/EgammaCoreTools/src/MustacheSCParametersHelper.cc new file mode 100644 index 0000000000000..c7c37ad40459d --- /dev/null +++ b/RecoEcal/EgammaCoreTools/src/MustacheSCParametersHelper.cc @@ -0,0 +1,53 @@ +// Implementation of the mustache parameters interface + +#include "RecoEcal/EgammaCoreTools/interface/MustacheSCParametersHelper.h" + +#include +#include + +using namespace reco; + +MustacheSCParametersHelper::MustacheSCParametersHelper(EcalMustacheSCParameters ¶ms, + const edm::ParameterSet &iConfig) + : parameters_(params) { + setSqrtLogClustETuning(iConfig.getParameter("sqrtLogClustETuning")); + + // parabola parameters + // clear the vector in case the EcalMustacheSCParameters had been initialised before + if (!parameters_.parabolaParametersCollection_.empty()) { + parameters_.parabolaParametersCollection_.clear(); + } + const auto parabolaPSets = iConfig.getParameter>("parabolaParameterSets"); + for (const auto &pSet : parabolaPSets) { + EcalMustacheSCParameters::ParabolaParameters parabolaParams = {pSet.getParameter("log10EMin"), + pSet.getParameter("etaMin"), + pSet.getParameter>("pUp"), + pSet.getParameter>("pLow"), + pSet.getParameter>("w0Up"), + pSet.getParameter>("w1Up"), + pSet.getParameter>("w0Low"), + pSet.getParameter>("w1Low")}; + addParabolaParameters(parabolaParams); + sortParabolaParametersCollection(); + } +} + +void MustacheSCParametersHelper::setSqrtLogClustETuning(const float sqrtLogClustETuning) { + parameters_.sqrtLogClustETuning_ = sqrtLogClustETuning; +} + +void MustacheSCParametersHelper::addParabolaParameters( + const EcalMustacheSCParameters::ParabolaParameters ¶bolaParams) { + parameters_.parabolaParametersCollection_.emplace_back(parabolaParams); +} + +void MustacheSCParametersHelper::sortParabolaParametersCollection() { + std::sort(parameters_.parabolaParametersCollection_.begin(), + parameters_.parabolaParametersCollection_.end(), + [](const EcalMustacheSCParameters::ParabolaParameters &p1, + const EcalMustacheSCParameters::ParabolaParameters &p2) { + const auto p1Mins = std::make_pair(p1.log10EMin, p1.etaMin); + const auto p2Mins = std::make_pair(p2.log10EMin, p2.etaMin); + return p1Mins < p2Mins; + }); +} diff --git a/RecoEcal/EgammaCoreTools/src/SCDynamicDPhiParametersHelper.cc b/RecoEcal/EgammaCoreTools/src/SCDynamicDPhiParametersHelper.cc new file mode 100644 index 0000000000000..bb743c7fa0588 --- /dev/null +++ b/RecoEcal/EgammaCoreTools/src/SCDynamicDPhiParametersHelper.cc @@ -0,0 +1,47 @@ +// Implementation of the SC dynamic dPhi parameters interface + +#include "RecoEcal/EgammaCoreTools/interface/SCDynamicDPhiParametersHelper.h" + +#include +#include + +using namespace reco; + +SCDynamicDPhiParametersHelper::SCDynamicDPhiParametersHelper(EcalSCDynamicDPhiParameters ¶ms, + const edm::ParameterSet &iConfig) + : parameters_(params) { + // dynamic dPhi parameters + // clear the vector in case the EcalMustacheSCParameters had been initialised before + if (!parameters_.dynamicDPhiParametersCollection_.empty()) { + parameters_.dynamicDPhiParametersCollection_.clear(); + } + const auto dynamicDPhiPSets = iConfig.getParameter>("dynamicDPhiParameterSets"); + for (const auto &pSet : dynamicDPhiPSets) { + EcalSCDynamicDPhiParameters::DynamicDPhiParameters dynDPhiParams({pSet.getParameter("eMin"), + pSet.getParameter("etaMin"), + pSet.getParameter("yoffset"), + pSet.getParameter("scale"), + pSet.getParameter("xoffset"), + pSet.getParameter("width"), + pSet.getParameter("saturation"), + pSet.getParameter("cutoff")}); + addDynamicDPhiParameters(dynDPhiParams); + sortDynamicDPhiParametersCollection(); + } +} + +void SCDynamicDPhiParametersHelper::addDynamicDPhiParameters( + const EcalSCDynamicDPhiParameters::DynamicDPhiParameters &dynDPhiParams) { + parameters_.dynamicDPhiParametersCollection_.emplace_back(dynDPhiParams); +} + +void SCDynamicDPhiParametersHelper::sortDynamicDPhiParametersCollection() { + std::sort(parameters_.dynamicDPhiParametersCollection_.begin(), + parameters_.dynamicDPhiParametersCollection_.end(), + [](const EcalSCDynamicDPhiParameters::DynamicDPhiParameters &p1, + const EcalSCDynamicDPhiParameters::DynamicDPhiParameters &p2) { + const auto p1Mins = std::make_pair(p1.eMin, p1.etaMin); + const auto p2Mins = std::make_pair(p2.eMin, p2.etaMin); + return p1Mins < p2Mins; + }); +} diff --git a/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc b/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc index e08b7717d7c76..ba243e4d5cd76 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFElectronTranslator.cc @@ -17,6 +17,8 @@ #include "DataFormats/ParticleFlowReco/interface/PFCluster.h" #include "DataFormats/ParticleFlowReco/interface/PFBlock.h" #include "DataFormats/EgammaReco/interface/BasicCluster.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" class DetId; namespace edm { @@ -129,6 +131,10 @@ class PFElectronTranslator : public edm::stream::EDProducer<> { std::map scMap_; std::map gsfMvaMap_; + // Mustache SC parameters + edm::ESGetToken ecalMustacheSCParametersToken_; + const EcalMustacheSCParameters* mustacheSCParams_; + bool emptyIsOk_; }; @@ -168,6 +174,8 @@ PFElectronTranslator::PFElectronTranslator(const edm::ParameterSet& iConfig) { else emptyIsOk_ = false; + ecalMustacheSCParametersToken_ = esConsumes(); + produces(PFBasicClusterCollection_); produces(PFPreshowerClusterCollection_); produces(PFSuperClusterCollection_); @@ -180,6 +188,8 @@ PFElectronTranslator::PFElectronTranslator(const edm::ParameterSet& iConfig) { PFElectronTranslator::~PFElectronTranslator() {} void PFElectronTranslator::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + mustacheSCParams_ = &iSetup.getData(ecalMustacheSCParametersToken_); + auto gsfElectronCores_p = std::make_unique(); auto gsfElectrons_p = std::make_unique(); @@ -664,7 +674,7 @@ void PFElectronTranslator::createGsfElectrons(const reco::PFCandidateCollection& myMvaInput.hadEnergy = pfCandidate.electronExtraRef()->hadEnergy(); // Mustache - reco::Mustache myMustache; + reco::Mustache myMustache(mustacheSCParams_); myMustache.MustacheID( *(myElectron.parentSuperCluster()), myMvaInput.nClusterOutsideMustache, myMvaInput.etOutsideMustache); diff --git a/RecoParticleFlow/PFProducer/plugins/PFPhotonTranslator.cc b/RecoParticleFlow/PFProducer/plugins/PFPhotonTranslator.cc index 4ca4f756aa5e0..9260271f43b00 100644 --- a/RecoParticleFlow/PFProducer/plugins/PFPhotonTranslator.cc +++ b/RecoParticleFlow/PFProducer/plugins/PFPhotonTranslator.cc @@ -21,6 +21,8 @@ #include "DataFormats/Common/interface/Handle.h" #include "DataFormats/ParticleFlowCandidate/interface/PFCandidatePhotonExtra.h" #include "DataFormats/ParticleFlowReco/interface/PFBlock.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" class CaloGeometry; class CaloTopology; @@ -132,6 +134,10 @@ class PFPhotonTranslator : public edm::stream::EDProducer<> { edm::ESHandle theCaloTopo_; edm::ESHandle theCaloGeom_; + // Mustache SC parameters + edm::ESGetToken ecalMustacheSCParametersToken_; + const EcalMustacheSCParameters *mustacheSCParams_; + bool emptyIsOk_; }; @@ -177,6 +183,8 @@ PFPhotonTranslator::PFPhotonTranslator(const edm::ParameterSet &iConfig) { else emptyIsOk_ = false; + ecalMustacheSCParametersToken_ = esConsumes(); + produces(PFBasicClusterCollection_); produces(PFPreshowerClusterCollection_); produces(PFSuperClusterCollection_); @@ -189,6 +197,7 @@ PFPhotonTranslator::~PFPhotonTranslator() {} void PFPhotonTranslator::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { //cout << "NEW EVENT"<(); @@ -996,7 +1005,7 @@ void PFPhotonTranslator::createPhotons(reco::VertexCollection &vertexCollection, reco::Photon::PflowIDVariables myPFVariables; - reco::Mustache myMustache; + reco::Mustache myMustache(mustacheSCParams_); myMustache.MustacheID( *(myPhoton.parentSuperCluster()), myPFVariables.nClusterOutsideMustache, myPFVariables.etOutsideMustache); myPFVariables.mva = pfPhotonMva_[iphot]; diff --git a/RecoParticleFlow/PFProducer/test/PFEGCandidateTreeMaker.cc b/RecoParticleFlow/PFProducer/test/PFEGCandidateTreeMaker.cc index d79467f8ae182..4f38db4218ce1 100644 --- a/RecoParticleFlow/PFProducer/test/PFEGCandidateTreeMaker.cc +++ b/RecoParticleFlow/PFProducer/test/PFEGCandidateTreeMaker.cc @@ -27,6 +27,10 @@ #include "DataFormats/Math/interface/deltaR.h" #include "DataFormats/HepMCCandidate/interface/GenParticle.h" #include "RecoEcal/EgammaCoreTools/interface/Mustache.h" +#include "CondFormats/EcalObjects/interface/EcalMustacheSCParameters.h" +#include "CondFormats/DataRecord/interface/EcalMustacheSCParametersRcd.h" +#include "CondFormats/EcalObjects/interface/EcalSCDynamicDPhiParameters.h" +#include "CondFormats/DataRecord/interface/EcalSCDynamicDPhiParametersRcd.h" #include "RecoParticleFlow/PFClusterTools/interface/PFEnergyCalibration.h" #include "TTree.h" @@ -73,7 +77,7 @@ class PFEGCandidateTreeMaker : public edm::EDAnalyzer { PFEGCandidateTreeMaker(const PSet&); ~PFEGCandidateTreeMaker() {} - void analyze(const edm::Event&, const edm::EventSetup&); + void analyze(const edm::Event&, const edm::EventSetup&) override; private: edm::Service _fs; @@ -89,6 +93,13 @@ class PFEGCandidateTreeMaker : public edm::EDAnalyzer { const reco::PFCandidateRef&, const edm::Handle&); bool getPFCandMatch(const reco::PFCandidate&, const edm::Handle&, const int); + + // SC parameters + edm::ESGetToken ecalMustacheSCParametersToken_; + const EcalMustacheSCParameters* mustacheSCParams_; + edm::ESGetToken ecalSCDynamicDPhiParametersToken_; + const EcalSCDynamicDPhiParameters* scDynamicDPhiParams_; + // the tree void setTreeArraysForSize(const size_t N_ECAL, const size_t N_PS); treeptr _tree; @@ -108,6 +119,9 @@ class PFEGCandidateTreeMaker : public edm::EDAnalyzer { }; void PFEGCandidateTreeMaker::analyze(const edm::Event& e, const edm::EventSetup& es) { + mustacheSCParams_ = &es.getData(ecalMustacheSCParametersToken_); + scDynamicDPhiParams_ = &es.getData(ecalSCDynamicDPhiParametersToken_); + edm::Handle vtcs; e.getByLabel(_vtxsrc, vtcs); if (vtcs.isValid()) @@ -258,9 +272,13 @@ void PFEGCandidateTreeMaker::processEGCandidateFillTree(const edm::Event& e, clusterDEtaToGen[iclus] = pclus->eta() - genmatch->eta(); } clusterInMustache[iclus] = (Int_t)reco::MustacheKernel::inMustache( - theseed->eta(), theseed->phi(), pclus->energy(), pclus->eta(), pclus->phi()); - clusterInDynDPhi[iclus] = (Int_t)reco::MustacheKernel::inDynamicDPhiWindow( - PFLayer::ECAL_BARREL == pclus->layer(), theseed->phi(), pclus->energy(), pclus->eta(), pclus->phi()); + mustacheSCParams_, theseed->eta(), theseed->phi(), pclus->energy(), pclus->eta(), pclus->phi()); + clusterInDynDPhi[iclus] = (Int_t)reco::MustacheKernel::inDynamicDPhiWindow(scDynamicDPhiParams_, + PFLayer::ECAL_BARREL == pclus->layer(), + theseed->phi(), + pclus->energy(), + pclus->eta(), + pclus->phi()); ++iclus; } // loop over all preshower clusters @@ -307,6 +325,9 @@ bool PFEGCandidateTreeMaker::getPFCandMatch(const reco::PFCandidate& cand, } PFEGCandidateTreeMaker::PFEGCandidateTreeMaker(const PSet& p) { + ecalMustacheSCParametersToken_ = esConsumes(); + ecalSCDynamicDPhiParametersToken_ = esConsumes(); + N_ECALClusters = 1; N_PSClusters = 1; _tree = _fs->make("SuperClusterTree", "Dump of all available SC info");