From 455267f4939c98871c46abb1f288b01e5c58fab6 Mon Sep 17 00:00:00 2001 From: Emanuele Di Marco Date: Wed, 25 Jan 2017 11:39:18 +0100 Subject: [PATCH] optional use of max-sample algo for gain-switch hits --- .../interface/EcalUncalibRecHitMultiFitAlgo.h | 2 ++ .../src/EcalUncalibRecHitMultiFitAlgo.cc | 26 ++++++++++++++----- .../EcalUncalibRecHitWorkerMultiFit.cc | 8 +++++- .../plugins/EcalUncalibRecHitWorkerMultiFit.h | 2 ++ .../python/ecalMultiFitUncalibRecHit_cfi.py | 2 ++ 5 files changed, 33 insertions(+), 7 deletions(-) diff --git a/RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitMultiFitAlgo.h b/RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitMultiFitAlgo.h index 2e21b404841e1..d1c19b1421177 100644 --- a/RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitMultiFitAlgo.h +++ b/RecoLocalCalo/EcalRecAlgos/interface/EcalUncalibRecHitMultiFitAlgo.h @@ -34,6 +34,7 @@ class EcalUncalibRecHitMultiFitAlgo void setSelectiveBadSampleCriteria(bool b) { _selectiveBadSampleCriteria = b; } void setAddPedestalUncertainty(double x) { _addPedestalUncertainty = x; } void setSimplifiedNoiseModelForGainSwitch(bool b) { _simplifiedNoiseModelForGainSwitch = b; } + void setGainSwitchUseMaxSample(bool b) { _gainSwitchUseMaxSample = b; } private: PulseChiSqSNNLS _pulsefunc; @@ -46,6 +47,7 @@ class EcalUncalibRecHitMultiFitAlgo bool _selectiveBadSampleCriteria; double _addPedestalUncertainty; bool _simplifiedNoiseModelForGainSwitch; + bool _gainSwitchUseMaxSample; BXVector _singlebx; }; diff --git a/RecoLocalCalo/EcalRecAlgos/src/EcalUncalibRecHitMultiFitAlgo.cc b/RecoLocalCalo/EcalRecAlgos/src/EcalUncalibRecHitMultiFitAlgo.cc index 878a8553da8dd..c83294d664625 100644 --- a/RecoLocalCalo/EcalRecAlgos/src/EcalUncalibRecHitMultiFitAlgo.cc +++ b/RecoLocalCalo/EcalRecAlgos/src/EcalUncalibRecHitMultiFitAlgo.cc @@ -13,7 +13,8 @@ EcalUncalibRecHitMultiFitAlgo::EcalUncalibRecHitMultiFitAlgo() : _mitigateBadSamples(false), _selectiveBadSampleCriteria(false), _addPedestalUncertainty(0.), - _simplifiedNoiseModelForGainSwitch(true) { + _simplifiedNoiseModelForGainSwitch(true), + _gainSwitchUseMaxSample(false){ _singlebx.resize(1); _singlebx << 0; @@ -105,10 +106,26 @@ EcalUncalibratedRecHit EcalUncalibRecHitMultiFitAlgo::makeRecHit(const EcalDataF } } - + + double amplitude, amperr, chisq; + bool status = false; + //special handling for gain switch, where sample before maximum is potentially affected by slew rate limitation //optionally apply a stricter criteria, assuming slew rate limit is only reached in case where maximum sample has gain switched but previous sample has not - //A floating negative single-sample offset is added to the fit + //option 1: use simple max-sample algorithm + if (hasGainSwitch && _gainSwitchUseMaxSample) { + EcalUncalibratedRecHit rh( dataFrame.id(), maxamplitude, pedval, 0., 0., flags ); + rh.setAmplitudeError(0.); + for (unsigned int ipulse=0; ipulse<_pulsefunc.BXs().rows(); ++ipulse) { + int bx = _pulsefunc.BXs().coeff(ipulse); + if (bx!=0) { + rh.setOutOfTimeAmplitude(bx+5, 0.0); + } + } + return rh; + } + + //option2: A floating negative single-sample offset is added to the fit //such that the affected sample is treated only as a lower limit for the true amplitude bool mitigateBadSample = _mitigateBadSamples && hasGainSwitch && iSampleMax>0; mitigateBadSample &= (!_selectiveBadSampleCriteria || (gainsNoise.coeff(iSampleMax-1)!=gainsNoise.coeff(iSampleMax)) ); @@ -116,9 +133,6 @@ EcalUncalibratedRecHit EcalUncalibRecHitMultiFitAlgo::makeRecHit(const EcalDataF badSamples[iSampleMax-1] = 1; } - double amplitude, amperr, chisq; - bool status = false; - //compute noise covariance matrix, which depends on the sample gains SampleMatrix noisecov; if (hasGainSwitch) { diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc index e044875650a05..89f6c54cbda2d 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc @@ -54,6 +54,8 @@ EcalUncalibRecHitWorkerMultiFit::EcalUncalibRecHitWorkerMultiFit(const edm::Para dynamicPedestalsEE_ = ps.getParameter("dynamicPedestalsEE"); mitigateBadSamplesEB_ = ps.getParameter("mitigateBadSamplesEB"); mitigateBadSamplesEE_ = ps.getParameter("mitigateBadSamplesEE"); + gainSwitchUseMaxSampleEB_ = ps.getParameter("gainSwitchUseMaxSampleEB"); + gainSwitchUseMaxSampleEE_ = ps.getParameter("gainSwitchUseMaxSampleEE"); selectiveBadSampleCriteriaEB_ = ps.getParameter("selectiveBadSampleCriteriaEB"); selectiveBadSampleCriteriaEE_ = ps.getParameter("selectiveBadSampleCriteriaEE"); addPedestalUncertaintyEB_ = ps.getParameter("addPedestalUncertaintyEB"); @@ -281,6 +283,7 @@ EcalUncalibRecHitWorkerMultiFit::run( const edm::Event & evt, multiFitMethod_.setPrefitMaxChiSq(prefitMaxChiSqEE_); multiFitMethod_.setDynamicPedestals(dynamicPedestalsEE_); multiFitMethod_.setMitigateBadSamples(mitigateBadSamplesEE_); + multiFitMethod_.setGainSwitchUseMaxSample(gainSwitchUseMaxSampleEE_); multiFitMethod_.setSelectiveBadSampleCriteria(selectiveBadSampleCriteriaEE_); multiFitMethod_.setAddPedestalUncertainty(addPedestalUncertaintyEE_); offsetTime = offtime->getEEValue(); @@ -293,11 +296,12 @@ EcalUncalibRecHitWorkerMultiFit::run( const edm::Event & evt, aPulseCov = &pulsecovariances->barrel(hashedIndex); multiFitMethod_.setDoPrefit(doPrefitEB_); multiFitMethod_.setPrefitMaxChiSq(prefitMaxChiSqEB_); - offsetTime = offtime->getEBValue(); multiFitMethod_.setDynamicPedestals(dynamicPedestalsEB_); multiFitMethod_.setMitigateBadSamples(mitigateBadSamplesEB_); + multiFitMethod_.setGainSwitchUseMaxSample(gainSwitchUseMaxSampleEB_); multiFitMethod_.setSelectiveBadSampleCriteria(selectiveBadSampleCriteriaEB_); multiFitMethod_.setAddPedestalUncertainty(addPedestalUncertaintyEB_); + offsetTime = offtime->getEBValue(); } double pedVec[3] = { aped->mean_x12, aped->mean_x6, aped->mean_x1 }; @@ -598,6 +602,8 @@ EcalUncalibRecHitWorkerMultiFit::getAlgoDescription() { edm::ParameterDescription("dynamicPedestalsEE", false, true) and edm::ParameterDescription("mitigateBadSamplesEB", false, true) and edm::ParameterDescription("mitigateBadSamplesEE", false, true) and + edm::ParameterDescription("gainSwitchUseMaxSampleEB", false, true) and + edm::ParameterDescription("gainSwitchUseMaxSampleEE", false, true) and edm::ParameterDescription("selectiveBadSampleCriteriaEB", false, true) and edm::ParameterDescription("selectiveBadSampleCriteriaEE", false, true) and edm::ParameterDescription("addPedestalUncertaintyEB", 0., true) and diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h index a046ced71e32e..f7f226fc215c8 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h @@ -94,6 +94,8 @@ class EcalUncalibRecHitWorkerMultiFit final : public EcalUncalibRecHitWorkerBase bool dynamicPedestalsEE_; bool mitigateBadSamplesEB_; bool mitigateBadSamplesEE_; + bool gainSwitchUseMaxSampleEB_; + bool gainSwitchUseMaxSampleEE_; bool selectiveBadSampleCriteriaEB_; bool selectiveBadSampleCriteriaEE_; double addPedestalUncertaintyEB_; diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py index 8ff4d62bb9609..f47cbe5d61a83 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py @@ -24,6 +24,8 @@ dynamicPedestalsEE = cms.bool(False), mitigateBadSamplesEB = cms.bool(False), mitigateBadSamplesEE = cms.bool(False), + gainSwitchUseMaxSampleEB = cms.bool(False), + gainSwitchUseMaxSampleEE = cms.bool(False), selectiveBadSampleCriteriaEB = cms.bool(False), selectiveBadSampleCriteriaEE = cms.bool(False), simplifiedNoiseModelForGainSwitch = cms.bool(True),