From b3c6a396596d7f7e3b49114473accca13c830f23 Mon Sep 17 00:00:00 2001 From: rselvati Date: Thu, 2 Apr 2020 20:23:55 +0200 Subject: [PATCH 01/10] porting to CMSSW_11_1_X --- .../EcalObjects/src/SerializationManual.h | 2 + CondFormats/EcalObjects/src/classes.h | 209 +++++++++--------- CondFormats/EcalObjects/src/classes_def.xml | 8 + DataFormats/EcalDigi/src/EBDataFrame.cc | 50 ++--- DataFormats/EcalDigi/src/classes.h | 3 + DataFormats/EcalDigi/src/classes_def.xml | 9 + .../python/SimCalorimetry_EventContent_cff.py | 1 - .../EcalSimAlgos/interface/EcalCoder.h | 2 +- .../EcalSimProducers/plugins/SealModule.cc | 3 +- .../python/ecalSimParameterMap_cff.py | 15 +- SimGeneral/MixingModule/python/aliases_cfi.py | 33 ++- 11 files changed, 198 insertions(+), 137 deletions(-) diff --git a/CondFormats/EcalObjects/src/SerializationManual.h b/CondFormats/EcalObjects/src/SerializationManual.h index 5efd2ebcc7440..123b08e020e3a 100644 --- a/CondFormats/EcalObjects/src/SerializationManual.h +++ b/CondFormats/EcalObjects/src/SerializationManual.h @@ -4,6 +4,7 @@ COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); +COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); @@ -16,3 +17,4 @@ COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondTowerObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondTowerObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondTowerObjectContainer); + diff --git a/CondFormats/EcalObjects/src/classes.h b/CondFormats/EcalObjects/src/classes.h index 265320eb1ddea..0d872ff0ec38f 100644 --- a/CondFormats/EcalObjects/src/classes.h +++ b/CondFormats/EcalObjects/src/classes.h @@ -1,3 +1,4 @@ +#include #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" #include "CondFormats/EcalObjects/interface/EcalCondTowerObjectContainer.h" @@ -64,162 +65,168 @@ #include "CondFormats/EcalObjects/interface/EcalTPGSpike.h" #include "CondFormats/EcalObjects/interface/EcalSRSettings.h" #include "CondFormats/EcalObjects/interface/EcalSimPulseShape.h" -#include +//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 - + 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 - + 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 - + 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 - + 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 + EcalContainer ec_eeDetId_ecalPedestal; + EcalContainer ec_ebDetId_ecalPedestal; + EcalCondObjectContainer pedmap; //typedef EcalPedestals - std::vector v_ecalTPGCrystalStatusCode; - EcalContainer ec_eeDetId_ecalTPGCrystalStatusCode; - EcalContainer ec_ebDetId_ecalTPGCrystalStatusCode; - EcalCondObjectContainer tpgCrystalStatus; //typedef EcalTPGCrystalStatus + //ECAL PH2: + std::vector v_ecalDTUPed; + EcalContainer ec_ebDetId_ecalLiteDTUPed; + 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 - + 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 - + 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 - + 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; + 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; + 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 - + 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; - + std::pair< EcalXtalGroupId, EcalTBWeights::EcalTDCId > wgpair; + std::map< std::pair< EcalXtalGroupId, EcalTBWeights::EcalTDCId > , EcalWeightSet > wgmap; + std::pair< const std::pair< EcalXtalGroupId, EcalTBWeights::EcalTDCId > , 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; - + std::map EcalTPGFineGrainEBMap ; + std::pair EcalTPGFineGrainEBMap_valuetype ; + + std::map< uint32_t, EcalTPGFineGrainStripEE::Item > EcalTPGFineGrainStripEEMap; + std::pair< const uint32_t, EcalTPGFineGrainStripEE::Item > EcalTPGFineGrainStripEEMap_valuetype; + EcalTPGLut lut; - std::map EcalTPGLutMap; - std::pair EcalTPGLutMap_valuetype; - + std::map< uint32_t, EcalTPGLut > EcalTPGLutMap; + std::pair< const uint32_t, EcalTPGLut > EcalTPGLutMap_valuetype; + EcalTPGWeights weightsweights; std::map EcalTPGWeightMap; std::pair EcalTPGWeightMap_valuetype; - - EcalFunParams - funParams; // typdefs: EcalClusterCrackCorrParameters, EcalClusterEnergyCorrectionObjectSpecificParameters, EcalClusterEnergyCorrectionParameters, EcalClusterEnergyUncertaintyParameters, EcalClusterLocalContCorrParameters - + + EcalFunParams funParams; // typdefs: EcalClusterCrackCorrParameters, EcalClusterEnergyCorrectionObjectSpecificParameters, EcalClusterEnergyCorrectionParameters, EcalClusterEnergyUncertaintyParameters, EcalClusterLocalContCorrParameters + EcalTPGFineGrainEBGroup fgrgroup; - + EcalTPGLutGroup lutgroup; - + EcalTPGWeightGroup wgroup; - + EcalTPGPhysicsConst::Item foo1; - std::map phConst; - std::pair phConst_valuetype; - + std::map< uint32_t, EcalTPGPhysicsConst::Item > phConst; + std::pair< const uint32_t, EcalTPGPhysicsConst::Item > phConst_valuetype; + EcalTPGTowerStatus towerstatus; - std::map tStatus; - std::pair tStatus_valuetype; + std::map< uint32_t, uint16_t > tStatus; + std::pair< const uint32_t, uint16_t > 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 + 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 + 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 + 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 67d8101caa54e..b977b995ae480 100644 --- a/CondFormats/EcalObjects/src/classes_def.xml +++ b/CondFormats/EcalObjects/src/classes_def.xml @@ -82,6 +82,14 @@ + + + + + + + + diff --git a/DataFormats/EcalDigi/src/EBDataFrame.cc b/DataFormats/EcalDigi/src/EBDataFrame.cc index c31e9f251a4d6..b2c96812b1610 100644 --- a/DataFormats/EcalDigi/src/EBDataFrame.cc +++ b/DataFormats/EcalDigi/src/EBDataFrame.cc @@ -1,34 +1,34 @@ #include "DataFormats/EcalDigi/interface/EBDataFrame.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include - -float EBDataFrame::spikeEstimator() const { - if (size() != 10) { - edm::LogError("InvalidNumberOfSamples") - << "This method only applies to signals sampled 10 times (" << size() << " samples found)"; - return 10.; - } - // skip faulty channels - if (sample(5).adc() == 0) - return 10.; - size_t imax = 0; - int maxAdc = 0; - for (int i = 0; i < size(); ++i) { - if (sample(i).adc() > maxAdc) { - imax = i; - maxAdc = sample(i).adc(); - } - } - // skip early signals - if (imax < 4) - return 10.; - float ped = 1. / 3. * (sample(0).adc() + sample(1).adc() + sample(2).adc()); - return 0.18 * (sample(4).adc() - ped) / (sample(5).adc() - ped) + (sample(6).adc() - ped) / (sample(5).adc() - ped); +#include +#warning [DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 +float EBDataFrame::spikeEstimator() const +{ + if ( size() != 10 ) { + edm::LogError("InvalidNumberOfSamples") << "This method only applies to signals sampled 10 times (" + << size() << " samples found)"; + return 10.; + } + // skip faulty channels + if ( sample(5).adc() == 0 ) return 10.; + size_t imax = 0; + int maxAdc = 0; + for ( int i = 0; i < size(); ++i ) { + if ( sample(i).adc() > maxAdc ) { + imax = i; + maxAdc = sample(i).adc(); + } + } + // skip early signals + if ( imax < 4 ) return 10.; + float ped = 1./3. * (sample(0).adc() + sample(1).adc() + sample(2).adc()); + return 0.18*(sample(4).adc()-ped)/(sample(5).adc()-ped) + (sample(6).adc()-ped)/(sample(5).adc()-ped); } + std::ostream& operator<<(std::ostream& s, const EBDataFrame& digi) { s << digi.id() << " " << digi.size() << " samples " << std::endl; - for (int i = 0; i < digi.size(); i++) + for (int i=0; i + + + + + + + @@ -91,6 +98,8 @@ + + diff --git a/SimCalorimetry/Configuration/python/SimCalorimetry_EventContent_cff.py b/SimCalorimetry/Configuration/python/SimCalorimetry_EventContent_cff.py index d159b7eee48a5..94d8df9329b03 100644 --- a/SimCalorimetry/Configuration/python/SimCalorimetry_EventContent_cff.py +++ b/SimCalorimetry/Configuration/python/SimCalorimetry_EventContent_cff.py @@ -1,5 +1,4 @@ import FWCore.ParameterSet.Config as cms - # This object modifies the event content for different scenarios SimCalorimetryFEVTDEBUG = cms.PSet( diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h index ec60ac2f2af2a..b9ffed023d5e6 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h @@ -1,4 +1,3 @@ - #ifndef EcalSimAlgos_EcalCoder_h #define EcalSimAlgos_EcalCoder_h 1 @@ -26,6 +25,7 @@ namespace CLHEP { */ class EcalCoder { public: + typedef CaloTSamples EcalSamples; typedef CorrelatedNoisifier Noisifier; diff --git a/SimCalorimetry/EcalSimProducers/plugins/SealModule.cc b/SimCalorimetry/EcalSimProducers/plugins/SealModule.cc index 43a5ed18e678d..8dd6a263419bd 100644 --- a/SimCalorimetry/EcalSimProducers/plugins/SealModule.cc +++ b/SimCalorimetry/EcalSimProducers/plugins/SealModule.cc @@ -1,7 +1,8 @@ #include "FWCore/Framework/interface/MakerMacros.h" #include "SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h" +#include "SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h" #include "SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer.h" #include "SimGeneral/MixingModule/interface/DigiAccumulatorMixModFactory.h" - DEFINE_DIGI_ACCUMULATOR(EcalDigiProducer); +DEFINE_DIGI_ACCUMULATOR(EcalDigiProducer_Ph2); DEFINE_DIGI_ACCUMULATOR(EcalTimeDigiProducer); diff --git a/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py b/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py index e265e6ea80c6c..caa82d8b31eae 100644 --- a/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py +++ b/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py @@ -10,7 +10,20 @@ simHitToPhotoelectronsBarrel = cms.double(2250.0), syncPhase = cms.bool(True), doPhotostatistics = cms.bool(True), + photoelectronsToAnalogBarrel = cms.double(0.000444444) +) + +ecal_sim_parameter_map_ph2 = cms.PSet( + #photoelectronsToAnalogEndcap = cms.double(0.000555555), + readoutFrameSize = cms.int32(16), + binOfMaximum = cms.int32(6), + #simHitToPhotoelectronsEndcap = cms.double(1800.0), + samplingFactor = cms.double(1.0), + timePhase = cms.double(0.0), + simHitToPhotoelectronsBarrel = cms.double(2250.0), + syncPhase = cms.bool(True), + doPhotostatistics = cms.bool(True), photoelectronsToAnalogBarrel = cms.double(0.000444444), - timeDependent = cms.bool(False) + #isPhase2 = cms.bool(True) ####################################################### NEW ) diff --git a/SimGeneral/MixingModule/python/aliases_cfi.py b/SimGeneral/MixingModule/python/aliases_cfi.py index ab7507921b55c..84a551dad60d5 100644 --- a/SimGeneral/MixingModule/python/aliases_cfi.py +++ b/SimGeneral/MixingModule/python/aliases_cfi.py @@ -1,5 +1,4 @@ import FWCore.ParameterSet.Config as cms - simCastorDigis = cms.EDAlias( mix = cms.VPSet( cms.PSet(type = cms.string('CastorDataFramesSorted')) @@ -7,9 +6,9 @@ ) simEcalUnsuppressedDigis = cms.EDAlias( mix = cms.VPSet( - cms.PSet(type = cms.string('EBDigiCollection')), - cms.PSet(type = cms.string('EEDigiCollection')), - cms.PSet(type = cms.string('ESDigiCollection')) + cms.PSet(type = cms.string('EBDigiCollection')), + cms.PSet(type = cms.string('EEDigiCollection')), + cms.PSet(type = cms.string('ESDigiCollection')) ) ) simHcalUnsuppressedDigis = cms.EDAlias( @@ -22,13 +21,16 @@ cms.PSet(type = cms.string('QIE11DataFrameHcalDataFrameContainer')) ) ) + _pixelCommon = cms.VPSet( cms.PSet(type = cms.string('PixelDigiedmDetSetVector')), cms.PSet(type = cms.string('PixelDigiSimLinkedmDetSetVector')) ) + simSiPixelDigis = cms.EDAlias( mix = _pixelCommon ) + simSiStripDigis = cms.EDAlias( mix = cms.VPSet( cms.PSet(type = cms.string('SiStripDigiedmDetSetVector')), @@ -36,6 +38,7 @@ cms.PSet(type = cms.string('StripDigiSimLinkedmDetSetVector')) ) ) + simHGCalUnsuppressedDigis = cms.EDAlias( mix = cms.VPSet( cms.PSet( @@ -55,6 +58,7 @@ ), ) ) + simHFNoseUnsuppressedDigis = cms.EDAlias( mix = cms.VPSet( cms.PSet( @@ -65,12 +69,27 @@ ) ) +#print "loading mix simAPV saturation" simAPVsaturation = cms.EDAlias( - mix = cms.VPSet( - cms.PSet(type = cms.string('bool')) - ) + mix = cms.VPSet( + cms.PSet(type = cms.string('bool')) + ) ) +# simAPVsaturation = cms.EDAlias( +# mixData = cms.VPSet( +# cms.PSet( +# type = cms.string('bool'), +# fromProductInstance = cms.string('siStripDigisDMSimulatedAPVDynamicGain'), +# toProductInstance = cms.string('SimulatedAPVDynamicGain'), +# ) +# ) +# ) + + + + + from Configuration.Eras.Modifier_run3_common_cff import run3_common run3_common.toModify(simCastorDigis, mix = None) From 28626e6af038a0feb335bc901679e805c172ecff Mon Sep 17 00:00:00 2001 From: rselvati Date: Thu, 2 Apr 2020 20:52:06 +0200 Subject: [PATCH 02/10] add Phase2 files --- .../CaloObjects/interface/CaloTSamples_Ph2.h | 34 ++ .../CaloObjects/src/CaloTSamples_Ph2.cc | 8 + .../interface/EcalCATIAGainRatiosRcd.h | 6 + .../interface/EcalLiteDTUPedestalsRcd.h | 6 + .../DataRecord/src/EcalCATIAGainRatiosRcd.cc | 4 + .../DataRecord/src/EcalLiteDTUPedestalsRcd.cc | 4 + .../interface/EcalCATIAGainRatios.h | 10 + .../EcalObjects/interface/EcalConstants.h | 21 + .../interface/EcalLiteDTUPedestals.h | 49 ++ .../src/T_EventSetup_EcalLiteDTUPedestals.cc | 19 + .../xml/EcalLiteDTUPedestals_default.xml | 8 + .../StandardSequences/python/Digi_Ph2_cff.py | 71 +++ .../interface/EcalDigiCollections_Ph2.h | 73 +++ .../python/SimCalorimetry_Ph2_cff.py | 11 + .../python/ecalDigiSequence_Ph2_cff.py | 28 ++ .../interface/EBHitResponse_Ph2.h | 109 +++++ .../EcalSimAlgos/interface/EcalCoder_Ph2.h | 102 ++++ .../interface/EcalCorrelatedNoiseMatrix_Ph2.h | 10 + .../interface/EcalDigitizerTraits_Ph2.h | 27 ++ .../interface/EcalElectronicsSim_Ph2.h | 58 +++ .../interface/EcalHitResponse_Ph2.h | 144 ++++++ .../interface/EcalSimParameterMap_Ph2.h | 39 ++ .../interface/EcalTDigitizer_Ph2.h | 71 +++ .../interface/EcalTDigitizer_Ph2.icc | 92 ++++ .../EcalSimAlgos/src/EBHitResponse_Ph2.cc | 355 ++++++++++++++ .../EcalSimAlgos/src/EcalCoder_Ph2.cc | 283 ++++++++++++ .../src/EcalCorrelatedNoiseMatrix_Ph2.cc | 12 + .../EcalSimAlgos/src/EcalDigitizers_Ph2.cc | 4 + .../src/EcalElectronicsSim_Ph2.cc | 37 ++ .../EcalSimAlgos/src/EcalHitResponse_Ph2.cc | 353 ++++++++++++++ .../src/EcalSimParameterMap_Ph2.cc | 49 ++ .../interface/EcalDigiProducer_Ph2.h | 123 +++++ .../interface/EcalTimeDigiProducer_Ph2.h | 63 +++ .../plugins/EcalCATIAGainRatiosESProducer.cc | 60 +++ .../plugins/EcalLiteDTUPedestalsESProducer.cc | 66 +++ .../python/ecalDigiParameters_Ph2_cff.py | 49 ++ .../python/ecalElectronicsSim_Ph2_cff.py | 13 + .../python/ecaldigi_Ph2_cfi.py | 3 + .../python/esCATIAGainProducer_cfi.py | 11 + .../esEcalLiteDTUPedestalsProducer_cfi.py | 11 + .../src/EcalDigiProducer_Ph2.cc | 434 ++++++++++++++++++ .../src/EcalTimeDigiProducer_Ph2.cc | 135 ++++++ ...ctron_cfi_py_GEN_IDEAL_withECALDigi_Ph1.py | 168 +++++++ ..._cfi_py_GEN_IDEAL_withECALDigi_newshape.py | 171 +++++++ .../test/simPulseShapePhaseII.db | Bin 0 -> 98304 bytes .../PhaseIAnalyzer/plugins/BuildFile.xml | 8 + .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc | 313 +++++++++++++ .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.h | 85 ++++ .../PhaseIAnalyzer/python/CfiFile_cfi.py | 5 + .../PhaseIAnalyzer/python/ConfFile_cfg.py | 33 ++ .../PhaseIAnalyzer/python/Digitizer1.root | Bin 0 -> 57745 bytes .../PhaseIIAnalyzer/plugins/BuildFile.xml | 8 + .../plugins/PhaseIIAnalyzer.cc | 307 +++++++++++++ .../PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h | 84 ++++ .../PhaseIIAnalyzer/python/CfiFile_cfi.py | 6 + .../PhaseIIAnalyzer/python/ConfFile_cfg.py | 39 ++ .../PhaseIIAnalyzer/python/Digitizer2.root | Bin 0 -> 54766 bytes .../MixingModule/python/aliases_Ph2_cfi.py | 119 +++++ .../MixingModule/python/digitizers_Ph2_cfi.py | 127 +++++ .../python/ecalDigitizer_Ph2_cfi.py | 28 ++ .../MixingModule/python/mixNoPU_Ph2_cfi.py | 25 + 61 files changed, 4591 insertions(+) create mode 100644 CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h create mode 100644 CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc create mode 100644 CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h create mode 100644 CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h create mode 100644 CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc create mode 100644 CondFormats/DataRecord/src/EcalLiteDTUPedestalsRcd.cc create mode 100644 CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h create mode 100644 CondFormats/EcalObjects/interface/EcalConstants.h create mode 100644 CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h create mode 100644 CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc create mode 100644 CondFormats/EcalObjects/xml/EcalLiteDTUPedestals_default.xml create mode 100644 Configuration/StandardSequences/python/Digi_Ph2_cff.py create mode 100644 DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h create mode 100644 SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py create mode 100644 SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h create mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalDigitizers_Ph2.cc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc create mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc create mode 100644 SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h create mode 100644 SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h create mode 100644 SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc create mode 100644 SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc create mode 100644 SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py create mode 100644 SimCalorimetry/EcalSimProducers/python/ecalElectronicsSim_Ph2_cff.py create mode 100644 SimCalorimetry/EcalSimProducers/python/ecaldigi_Ph2_cfi.py create mode 100644 SimCalorimetry/EcalSimProducers/python/esCATIAGainProducer_cfi.py create mode 100644 SimCalorimetry/EcalSimProducers/python/esEcalLiteDTUPedestalsProducer_cfi.py create mode 100644 SimCalorimetry/EcalSimProducers/src/EcalDigiProducer_Ph2.cc create mode 100644 SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc create mode 100644 SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_Ph1.py create mode 100644 SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_newshape.py create mode 100644 SimCalorimetry/EcalSimProducers/test/simPulseShapePhaseII.db create mode 100644 SimCalorimetry/PhaseIAnalyzer/plugins/BuildFile.xml create mode 100644 SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc create mode 100644 SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h create mode 100644 SimCalorimetry/PhaseIAnalyzer/python/CfiFile_cfi.py create mode 100644 SimCalorimetry/PhaseIAnalyzer/python/ConfFile_cfg.py create mode 100644 SimCalorimetry/PhaseIAnalyzer/python/Digitizer1.root create mode 100644 SimCalorimetry/PhaseIIAnalyzer/plugins/BuildFile.xml create mode 100644 SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc create mode 100644 SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h create mode 100644 SimCalorimetry/PhaseIIAnalyzer/python/CfiFile_cfi.py create mode 100644 SimCalorimetry/PhaseIIAnalyzer/python/ConfFile_cfg.py create mode 100644 SimCalorimetry/PhaseIIAnalyzer/python/Digitizer2.root create mode 100644 SimGeneral/MixingModule/python/aliases_Ph2_cfi.py create mode 100644 SimGeneral/MixingModule/python/digitizers_Ph2_cfi.py create mode 100644 SimGeneral/MixingModule/python/ecalDigitizer_Ph2_cfi.py create mode 100644 SimGeneral/MixingModule/python/mixNoPU_Ph2_cfi.py diff --git a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h new file mode 100644 index 0000000000000..f6d058368d8cf --- /dev/null +++ b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h @@ -0,0 +1,34 @@ +#ifndef CALOTSAMPLES_Pha2_H +#define CALOTSAMPLES_Pha2_H 1 + +#include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" + +/** \class CaloTSamples_Ph2 + +Class which represents the charge/voltage measurements of an event/channel +with the ADC decoding performed. + +*/ + +template +class CaloTSamples_Ph2 : public CaloTSamplesBase { +public: + enum { kCapacity = Tsize }; + + CaloTSamples_Ph2(); + CaloTSamples_Ph2(const CaloTSamples_Ph2 &cs); + CaloTSamples_Ph2(const DetId &id, uint32_t size = 0, uint32_t pre = 0); + ~CaloTSamples_Ph2() override; + + CaloTSamples_Ph2 &operator=(const CaloTSamples_Ph2 &cs); + + uint32_t capacity() const override; + +private: + Ttype *data(uint32_t i) override; + const Ttype *cdata(uint32_t i) const override; + + Ttype m_data[Tsize]; +}; + +#endif diff --git a/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc b/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc new file mode 100644 index 0000000000000..68d2b9c9d08d1 --- /dev/null +++ b/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc @@ -0,0 +1,8 @@ +#include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.icc" +#include "CalibFormats/CaloObjects/interface/CaloTSamples.icc" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +template class CaloTSamplesBase ; + +template class CaloTSamples ; +template class CaloTSamples ; diff --git a/CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h b/CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h new file mode 100644 index 0000000000000..a05b14aa67d07 --- /dev/null +++ b/CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h @@ -0,0 +1,6 @@ +#ifndef CondFormats_DataRecord_EcalCATIAGainRatiosRcd_H +#define CondFormats_DataRecord_EcalCATIAGainRatiosRcd_H + +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" +class EcalCATIAGainRatiosRcd : public edm::eventsetup::EventSetupRecordImplementation {}; +#endif diff --git a/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h b/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h new file mode 100644 index 0000000000000..2228c73fb777a --- /dev/null +++ b/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h @@ -0,0 +1,6 @@ +#ifndef ECALLITEDTUPEDESTALSRCD_H +#define ECALLITEDTUPEDESTALSRCD_H + +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" +class EcalLiteDTUPedestalsRcd : public edm::eventsetup::EventSetupRecordImplementation {}; +#endif diff --git a/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc b/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc new file mode 100644 index 0000000000000..120c8ac455917 --- /dev/null +++ b/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc @@ -0,0 +1,4 @@ +#include "CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h" +#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" + +EVENTSETUP_RECORD_REG(EcalCATIAGainRatiosRcd); diff --git a/CondFormats/DataRecord/src/EcalLiteDTUPedestalsRcd.cc b/CondFormats/DataRecord/src/EcalLiteDTUPedestalsRcd.cc new file mode 100644 index 0000000000000..ca644efc17fa3 --- /dev/null +++ b/CondFormats/DataRecord/src/EcalLiteDTUPedestalsRcd.cc @@ -0,0 +1,4 @@ +#include "CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h" +#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" + +EVENTSETUP_RECORD_REG(EcalLiteDTUPedestalsRcd); diff --git a/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h b/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h new file mode 100644 index 0000000000000..7f1d67c7a8da1 --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h @@ -0,0 +1,10 @@ +#ifndef _CondFormats_EcalObjects_EcalGainRatios_h_ +#define _CondFormats_EcalObjects_EcalGainRatios_h_ + +#include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" + +typedef float EcalCATIAGainRatio; +typedef EcalFloatCondObjectContainer EcalCATIAGainRatioMap; +typedef EcalCATIAGainRatioMap EcalCATIAGainRatios; + +#endif diff --git a/CondFormats/EcalObjects/interface/EcalConstants.h b/CondFormats/EcalObjects/interface/EcalConstants.h new file mode 100644 index 0000000000000..f28f54a3cc847 --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalConstants.h @@ -0,0 +1,21 @@ +//Namespaces for Phase1 and Phase2 +#ifndef EcalObject_EcalConstants_h +#define EcalObject_EcalConstants_h + +namespace ecalPh2 +{ + constexpr double BUNCHSPACE = 6.25; + constexpr int NGAINS = 2; + constexpr float gains[2] = {10.,1.}; + constexpr int sampleSize = 16; +} + + +namespace ecalPh1 +{ + constexpr double BUNCHSPACE = 25.; + constexpr int NGAINS = 4; + constexpr float gains[4] = {0.,12.,6.,1.}; + constexpr int sampleSize = 10; +} +#endif diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h new file mode 100644 index 0000000000000..794a458ed2b1d --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -0,0 +1,49 @@ +#ifndef EcalLiteDTUPedestals_h +#define EcalLiteDTUPedestals_h + + +#include "CondFormats/Serialization/interface/Serializable.h" +#include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" + +const int NGAINS=2; + +const int gainId1=1; +const int gainId10=0; + +class EcalLiteDTUPed { + + public: + double meanarray[2]={13.,8.}; + double rmsarray[2]={2.8,1.2}; + + int setMean(int i, float value){ + if(i>=NGAINS || i<0) return -1; + else + meanarray[i] = value; + return 1; + } + + + int setRMS(int i,float value){ + if(i>=NGAINS || i < 0) return -1; + else + rmsarray[i] = value; + return 1; + } + + float mean(int i) const { + return meanarray[i]; + } + + float rms(int i) const { + return rmsarray[i]; + } + + COND_SERIALIZABLE; +}; + +typedef EcalCondObjectContainer EcalLiteDTUPedestalsMap; +typedef EcalLiteDTUPedestalsMap::const_iterator EcalLiteDTUPedestalsMapIterator; +typedef EcalLiteDTUPedestalsMap EcalLiteDTUPedestals; + +#endif diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc new file mode 100644 index 0000000000000..f5a0fac4dc88c --- /dev/null +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc @@ -0,0 +1,19 @@ +// -*- C++ -*- +// +// Package: EDMProto +// Class : T_Context_Pedestals +// +// Implementation: +// create all the 'infrastructure' needed to get into the Context +// +// Author: Dario Soldi +// Created: Mon March 14 16:42:52 EDT 2019 +// + +// system include files + +// user include files +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(EcalLiteDTUPedestals); diff --git a/CondFormats/EcalObjects/xml/EcalLiteDTUPedestals_default.xml b/CondFormats/EcalObjects/xml/EcalLiteDTUPedestals_default.xml new file mode 100644 index 0000000000000..89bdb3db85e34 --- /dev/null +++ b/CondFormats/EcalObjects/xml/EcalLiteDTUPedestals_default.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/Configuration/StandardSequences/python/Digi_Ph2_cff.py b/Configuration/StandardSequences/python/Digi_Ph2_cff.py new file mode 100644 index 0000000000000..eb29b87bdb441 --- /dev/null +++ b/Configuration/StandardSequences/python/Digi_Ph2_cff.py @@ -0,0 +1,71 @@ +import FWCore.ParameterSet.Config as cms + +# +# Full-scale Digitization of the simulated hits +# in all CMS subdets : Tracker, ECAL, HCAl, Muon's; +# MixingModule (at least in zero-pileup mode) needs +# to be included to make Digi's operational, since +# it's required for ECAL/HCAL & Muon's +# Defined in a separate fragment +# +# Tracker Digis (Pixel + SiStrips) are now made in the mixing +# module, so the old "trDigi" sequence has been taken out. +# + +# Calorimetry Digis (Ecal + Hcal) - * unsuppressed * +# returns sequence "calDigi" + +from SimCalorimetry.Configuration.SimCalorimetry_Ph2_cff import * +# Muon Digis (CSC + DT + RPC) +# returns sequence "muonDigi" +# +from SimMuon.Configuration.SimMuon_cff import * +# +# TrackingParticle Producer is now part of the mixing module, so +# it is no longer run here. +# +from SimGeneral.Configuration.SimGeneral_cff import * + +# add updating the GEN information by default +from Configuration.StandardSequences.Generator_cff import * +from GeneratorInterface.Core.generatorSmeared_cfi import * +from SimGeneral.PileupInformation.genPUProtons_cfi import * + +doAllDigiTask = cms.Task(generatorSmeared, calDigiTask, muonDigiTask) +pdigiTask_nogen = cms.Task(generatorSmeared, cms.TaskPlaceholder("randomEngineStateProducer"), cms.TaskPlaceholder("mix"), doAllDigiTask, addPileupInfo, genPUProtons) +pdigiTask = cms.Task(pdigiTask_nogen, fixGenInfoTask) + +doAllDigi = cms.Sequence(doAllDigiTask) +pdigi = cms.Sequence(pdigiTask) +pdigi_valid = cms.Sequence(pdigiTask) +pdigi_nogen=cms.Sequence(pdigiTask_nogen) +pdigi_valid_nogen=cms.Sequence(pdigiTask_nogen) + +from GeneratorInterface.HiGenCommon.HeavyIon_cff import * +pdigiTask_hi = cms.Task(pdigiTask, heavyIon) +pdigiTask_hi_nogen = cms.Task(pdigiTask_nogen, genJetMETTask, heavyIon) +pdigi_hi=cms.Sequence(pdigiTask_hi) +pdigi_hi_nogen=cms.Sequence(pdigiTask_hi_nogen) + +from Configuration.Eras.Modifier_fastSim_cff import fastSim +def _fastSimDigis(process): + import FastSimulation.Configuration.DigiAliases_cff as DigiAliases + + # pretend these digis have been through digi2raw and raw2digi, by using the approprate aliases + # use an alias to make the mixed track collection available under the usual label + from FastSimulation.Configuration.DigiAliases_cff import loadDigiAliases + loadDigiAliases(process) +# no need for the aliases for premixing stage1 +modifyDigi_fastSimDigis = (fastSim & ~premix_stage1).makeProcessModifier(_fastSimDigis) + +#phase 2 common mods +def _modifyEnableHcalHardcode( theProcess ): + from CalibCalorimetry.HcalPlugins.Hcal_Conditions_forGlobalTag_cff import hcal_db_producer as _hcal_db_producer, es_hardcode as _es_hardcode, es_prefer_hcalHardcode as _es_prefer_hcalHardcode + theProcess.hcal_db_producer = _hcal_db_producer + theProcess.es_hardcode = _es_hardcode + theProcess.es_prefer_hcalHardcode = _es_prefer_hcalHardcode + +from Configuration.Eras.Modifier_hcalHardcodeConditions_cff import hcalHardcodeConditions +modifyEnableHcalHardcode_ = hcalHardcodeConditions.makeProcessModifier( _modifyEnableHcalHardcode ) + + diff --git a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h new file mode 100644 index 0000000000000..dc1d71efb0712 --- /dev/null +++ b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h @@ -0,0 +1,73 @@ +#ifndef DIGIECAL_ECALDIGICOLLECTION_PH2_H +#define DIGIECAL_ECALDIGICOLLECTION_PH2_H + +#include "DataFormats/EcalDigi/interface/EBDataFrame.h" +#include "DataFormats/EcalDigi/interface/EEDataFrame.h" +#include "DataFormats/EcalDigi/interface/ESDataFrame.h" +#include "DataFormats/EcalDigi/interface/EcalTimeDigi.h" +#include "DataFormats/EcalDigi/interface/EcalTriggerPrimitiveDigi.h" +#include "DataFormats/EcalDigi/interface/EcalEBTriggerPrimitiveDigi.h" +#include "DataFormats/EcalDigi/interface/EcalTrigPrimCompactColl.h" +#include "DataFormats/EcalDigi/interface/EcalPseudoStripInputDigi.h" +#include "DataFormats/EcalDigi/interface/EBSrFlag.h" +#include "DataFormats/EcalDigi/interface/EESrFlag.h" +#include "DataFormats/EcalDigi/interface/EcalPnDiodeDigi.h" +#include "DataFormats/EcalDigi/interface/EcalMatacqDigi.h" +#include "DataFormats/Common/interface/SortedCollection.h" + +#include "DataFormats/DetId/interface/DetId.h" +#include "DataFormats/EcalDetId/interface/EcalSubdetector.h" +#include "DataFormats/Common/interface/DataFrameContainer.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +class EcalDigiCollectionPh2 : public edm::DataFrameContainer { +public: + typedef edm::DataFrameContainer::size_type size_type; + static const size_type MAXSAMPLES = ecalPh2::sampleSize; + explicit EcalDigiCollectionPh2(size_type istride=MAXSAMPLES, int isubdet=0) : + edm::DataFrameContainer(istride, isubdet){} + void swap(DataFrameContainer& other) {this->DataFrameContainer::swap(other);} + +}; + +// make edm (and ecal client) happy +class EBDigiCollectionPh2 : public EcalDigiCollectionPh2 { +public: + typedef edm::DataFrameContainer::size_type size_type; + typedef EBDataFrame Digi; + typedef Digi::key_type DetId; + + EBDigiCollectionPh2(size_type istride=MAXSAMPLES) : + EcalDigiCollectionPh2(istride, EcalBarrel){} + void swap(EBDigiCollectionPh2& other) {this->EcalDigiCollectionPh2::swap(other);} + void push_back(const Digi& digi){ DataFrameContainer::push_back(digi.id(), digi.frame().begin()); } + void push_back(id_type iid){DataFrameContainer::push_back(iid);} + void push_back(id_type iid,data_type const* idata){DataFrameContainer::push_back(iid,idata);} + +}; + + + +// Free swap functions +inline +void swap(EcalDigiCollectionPh2& lhs, EcalDigiCollectionPh2& rhs) { + lhs.swap(rhs); +} + +inline +void swap(EBDigiCollectionPh2& lhs, EBDigiCollectionPh2& rhs) { + lhs.swap(rhs); +} + + +typedef edm::SortedCollection EcalTimeDigiCollection; +//DA ELIMINARE??? +typedef edm::SortedCollection EcalTrigPrimDigiCollection; +typedef edm::SortedCollection EcalEBTrigPrimDigiCollection; + +typedef edm::SortedCollection EcalPSInputDigiCollection; +typedef edm::SortedCollection EBSrFlagCollection; +typedef edm::SortedCollection EcalPnDiodeDigiCollection; +typedef edm::SortedCollection EcalMatacqDigiCollection; + +#endif diff --git a/SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py b/SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py new file mode 100644 index 0000000000000..ffbfa8302ca40 --- /dev/null +++ b/SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms +from SimCalorimetry.Configuration.ecalDigiSequence_Ph2_cff import * +from SimCalorimetry.Configuration.hcalDigiSequence_cff import * +from SimCalorimetry.Configuration.castorDigiSequence_cff import * + +calDigiTask = cms.Task(ecalDigiTask, hcalDigiTask, castorDigiTask) +calDigi = cms.Sequence(calDigiTask) + +# fastsim has no castor model +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toReplaceWith(calDigiTask, calDigiTask.copyAndExclude([castorDigiTask])) diff --git a/SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py b/SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py new file mode 100644 index 0000000000000..0a6f0466f9fb3 --- /dev/null +++ b/SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py @@ -0,0 +1,28 @@ +import FWCore.ParameterSet.Config as cms + +# unsuppressed digis simulation - fast preshower +from SimCalorimetry.EcalSimProducers.ecaldigi_Ph2_cfi import * +# ECAL Trigger Primitives (needed by SRP) +from SimCalorimetry.EcalTrigPrimProducers.ecalTriggerPrimitiveDigis_cff import * +# Selective Readout Processor producer +from SimCalorimetry.EcalSelectiveReadoutProducers.ecalDigis_cfi import * +# Preshower Zero suppression producer +from SimCalorimetry.EcalZeroSuppressionProducers.ecalPreshowerDigis_cfi import * +# simEcalUnsuppressedDigis is now done inside mixing module +#ecalDigiTask = cms.Task(simEcalTriggerPrimitiveDigis, simEcalDigis, simEcalPreshowerDigis) +ecalDigiTask = cms.Task() +ecalDigiSequence = cms.Sequence(ecalDigiTask) +# +# +## This is extra, since the configuration skips it anyway. Belts and suspenders. +#from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 +#premix_stage1.toReplaceWith(ecalDigiTask, ecalDigiTask.copyAndExclude([simEcalPreshowerDigis])) +# +#from SimCalorimetry.EcalEBTrigPrimProducers.ecalEBTriggerPrimitiveDigis_cff import * +#_phase2_ecalDigiTask = ecalDigiTask.copy() +#_phase2_ecalDigiTask.add(simEcalEBTriggerPrimitiveDigis) +# +#from Configuration.Eras.Modifier_phase2_common_cff import phase2_common +#phase2_common.toReplaceWith(ecalDigiTask,_phase2_ecalDigiTask) +# +# diff --git a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h new file mode 100644 index 0000000000000..df872e6110c2f --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h @@ -0,0 +1,109 @@ +#ifndef EcalSimAlgos_EBHitResponse_Ph2_h +#define EcalSimAlgos_EBHitResponse_Ph2_h + +#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" +#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" + +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + + +class APDSimParameters ; + +namespace CLHEP { + class HepRandomEngine; +} + +class EBHitResponse_Ph2 : public EcalHitResponse_Ph2 +{ + public: + + typedef CaloTSamples EBSamples ; + + typedef std::vector VecD ; + + enum { kNOffsets = 2000 } ; + + EBHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , + const CaloVShape* shape , + bool apdOnly , + const APDSimParameters* apdPars , + const CaloVShape* apdShape ) ; + + ~EBHitResponse_Ph2() override ; + + void initialize(CLHEP::HepRandomEngine*); + + virtual bool keepBlank() const { return false ; } + + void setIntercal( const EcalIntercalibConstantsMC* ical ) ; + + + void add( const PCaloHit& hit, CLHEP::HepRandomEngine* ) override; + + void initializeHits() override; + + void finalizeHits() override; + + void run( MixCollection& hits, CLHEP::HepRandomEngine* ) override; + + unsigned int samplesSize() const override; + + EcalSamples* operator[]( unsigned int i ) override; + + const EcalSamples* operator[]( unsigned int i ) const override; + + protected: + + unsigned int samplesSizeAll() const override; + + EcalSamples* vSamAll( unsigned int i ) override; + + const EcalSamples* vSamAll( unsigned int i ) const override; + + EcalSamples* vSam( unsigned int i ) override ; + + void putAPDSignal( const DetId& detId, double npe, double time ) ; + + private: + + const VecD& offsets() const { return m_timeOffVec ; } + + const double nonlFunc( double enr ) const { + return ( pelo > enr ? pext : + ( pehi > enr ? nonlFunc1( enr ) : + pfac*atan( log10( enr - pehi + 0.00001 ) ) + poff ) ) ; } + + const double nonlFunc1( double energy ) const { + const double enr ( log10(energy) ) ; + const double enr2 ( enr*enr ) ; + const double enr3 ( enr2*enr ) ; + return ( pcub*enr3 + pqua*enr2 + plin*enr + pcon ) ; } + + const APDSimParameters* apdParameters() const ; + const CaloVShape* apdShape() const ; + + double apdSignalAmplitude( const PCaloHit& hit, CLHEP::HepRandomEngine* ) const ; + + void findIntercalibConstant( const DetId& detId, + double& icalconst ) const ; + + const bool m_apdOnly ; + const APDSimParameters* m_apdPars ; + const CaloVShape* m_apdShape ; + const EcalIntercalibConstantsMC* m_intercal ; + + std::vector m_timeOffVec ; + + std::vector m_apdNpeVec ; + std::vector m_apdTimeVec ; + + const double pcub, pqua, plin, pcon, pelo, pehi, pasy, pext, poff, pfac ; + + std::vector m_vSam ; + + bool m_isInitialized; +}; +#endif + + diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h new file mode 100644 index 0000000000000..852462b25be66 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h @@ -0,0 +1,102 @@ +#ifndef EcalSimAlgos_EcalCoder_Ph2_h +#define EcalSimAlgos_EcalCoder_Ph2_h 1 + +#include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" +//#include "CondFormats/EcalObjects/interface/EcalPedestals.h" +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" +#include "CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + + +template class CorrelatedNoisifier ; +class EcalMGPASample; +class EcalDataFrame; +class DetId; +class EcalLiteDTUPed; + +#include + +namespace CLHEP { + class HepRandomEngine; +} + + +class EcalCoder_Ph2 { + public: + + typedef CaloTSamples_Ph2 EcalSamples; + + //typedef CaloTSamples_Ph2 EcalSamples ; + + typedef CorrelatedNoisifier Noisifier ; + + enum { NBITS = 12 , // number of available bits + MAXADC = 4095, // 2^12 -1, adc max range + NGAINS = 2 // number of electronic gains + }; + + /// ctor + EcalCoder_Ph2( bool addNoise , + bool PreMix1 , + Noisifier* ebCorrNoise0 , + Noisifier* ebCorrNoise1 = nullptr ) ; + + /// dtor + virtual ~EcalCoder_Ph2() ; + + /// can be fetched every event from the EventSetup + void setPedestals( const EcalLiteDTUPedestals* pedestals ) ; + + void setGainRatios( const EcalCATIAGainRatios* gainRatios ) ; + + void setFullScaleEnergy( double EBscale ) ; + + void setIntercalibConstants( const EcalIntercalibConstantsMC* ical ) ; + + + /// from EcalSamples to EcalDataFrame + virtual void analogToDigital( CLHEP::HepRandomEngine*, + const EcalSamples& clf , + EcalDataFrame& df ) const; + + private: + + /// limit on the energy scale due to the electronics range + double fullScaleEnergy( const DetId & did ) const ; + + /// produce the pulse-shape + void encode( const EcalSamples& ecalSamples , + EcalDataFrame& df, + CLHEP::HepRandomEngine* ) const ; + + + + void findPedestal( const DetId& detId , + int gainId , + double& pedestal , + double& width ) const ; + + void findGains( const DetId& detId, float theGains[] ) const ; + + void findIntercalibConstant( const DetId& detId , + double& icalconst ) const ; + + const EcalLiteDTUPedestals* m_peds ; + + const EcalCATIAGainRatios* m_gainRatios ; // the electronics gains + + const EcalIntercalibConstantsMC* m_intercals ; //record specific for simulation of gain variation in MC + + double m_maxEneEB ; // max attainable energy in the ecal barrel + + bool m_addNoise ; // whether add noise to the pedestals and the gains + bool m_PreMix1 ; // Follow necessary steps for PreMixing input + + const Noisifier* m_ebCorrNoise[NGAINS] ; + + +}; + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h new file mode 100644 index 0000000000000..10bceecb659b3 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h @@ -0,0 +1,10 @@ +#ifndef EcalSimAlgos_EcalCorrelatedNoiseMatrix_Ph2_h +#define EcalSimAlgos_EcalCorrelatedNoiseMatrix_Ph2_h + +#include "DataFormats/Math/interface/Error.h" +#include "CalibFormats/CaloObjects/interface/CaloSamples.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +typedef math::ErrorD::type EcalCorrMatrix_Ph2; + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h new file mode 100644 index 0000000000000..37cfe0a60d0be --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h @@ -0,0 +1,27 @@ +#ifndef EcalSimAlgos_EcalDigitizerTraits_Ph2_h +#define EcalSimAlgos_EcalDigitizerTraits_Ph2_h + +#include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h" +#include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame.h" +#include "DataFormats/EcalDigi/interface/EBDataFrame.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" +class EcalHitResponse ; + +class EBDigitizerTraits_Ph2 { + public: + /// the digis collection + typedef EBDigiCollectionPh2 DigiCollection; + /// the dataframes + typedef EBDataFrame Digi; + /// the electronics simulation + typedef EcalElectronicsSim_Ph2 ElectronicsSim_Ph2; + + typedef CaloTSamples_Ph2 EcalSamples ; + + static void fix( Digi& digi, edm::DataFrame df ) {}; +}; + +#endif + diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h new file mode 100644 index 0000000000000..5f1ab030414ec --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h @@ -0,0 +1,58 @@ +#ifndef EcalSimAlgos_EcalElectronicsSim_Ph2_h +#define EcalSimAlgos_EcalElectronicsSim_Ph2_h 1 + +#include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + + +class EcalCoder_Ph2; +class EcalDataFrame; +class EcalSimParameterMap_Ph2; + +namespace CLHEP { + class HepRandomEngine; +} + +/* \class EcalElectronicsSim_Ph2 + * \brief Converts CaloDataFrame in CaloTimeSample and vice versa. + * + */ + +class EcalElectronicsSim_Ph2 { +public: + typedef CaloTSamples_Ph2 EcalSamples; + //typedef CaloTSamples_Ph2 EcalSamples; + EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, + EcalCoder_Ph2* coder, + bool applyConstantTerm, + double rmsConstantTerm); + + ~EcalElectronicsSim_Ph2(); + + /// from EcalSamples to EcalDataFrame + void analogToDigital(CLHEP::HepRandomEngine*, EcalSamples& clf, EcalDataFrame& df) const; + + void newEvent() {} + + void setNoiseSignalGenerator(const CaloVNoiseSignalGenerator* noiseSignalGenerator) { + theNoiseSignalGenerator = noiseSignalGenerator; + } + +private: + /// input signal is in pe. Converted in GeV + void amplify(EcalSamples& clf, CLHEP::HepRandomEngine*) const; + + /// map of parameters + + const EcalSimParameterMap_Ph2* m_simMap; + + const CaloVNoiseSignalGenerator* theNoiseSignalGenerator; + + EcalCoder_Ph2* m_theCoder; + + const double m_thisCT; + const bool m_applyConstantTerm; +}; + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h new file mode 100644 index 0000000000000..83c60b0478923 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h @@ -0,0 +1,144 @@ +#ifndef EcalSimAlgos_EcalHitResponse_Ph2_h +#define EcalSimAlgos_EcalHitResponse_Ph2_h + +#include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" +#include "CalibFormats/CaloObjects/interface/CaloSamples.h" +#include "DataFormats/DetId/interface/DetId.h" +#include "SimDataFormats/CrossingFrame/interface/MixCollection.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" +#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" +#include "DataFormats/Provenance/interface/Timestamp.h" + +#include +#include + +typedef unsigned long long TimeValue_t; + +class CaloVShape ; +class CaloVSimParameterMap ; +class CaloVHitCorrection ; +class CaloVHitFilter ; +class CaloSimParameters ; +class CaloSubdetectorGeometry ; +class CaloVPECorrection ; +namespace CLHEP +{ + class HepRandomEngine ; +} + +class EcalHitResponse_Ph2 +{ + public: + + typedef CaloTSamplesBase EcalSamples ; + + typedef std::vector< unsigned int > VecInd ; + + typedef std::unordered_map CalibCache; + + EcalHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , + const CaloVShape* shape ) ; + + virtual ~EcalHitResponse_Ph2() ; + + void setBunchRange( int minBunch , + int maxBunch ) ; + + void setGeometry( const CaloSubdetectorGeometry* geometry ) ; + + void setPhaseShift( double phaseShift ) ; + + void setHitFilter( const CaloVHitFilter* filter) ; + + void setHitCorrection( const CaloVHitCorrection* hitCorrection) ; + + void setPECorrection( const CaloVPECorrection* peCorrection ) ; + + void setEventTime(const edm::TimeValue_t& iTime); + + void setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection); + + void add( const EcalSamples* pSam ) ; + + virtual void add( const PCaloHit& hit, CLHEP::HepRandomEngine* ) ; + + virtual void add( const CaloSamples& hit ) ; + + virtual void initializeHits() ; + + virtual void finalizeHits() ; + + virtual void run( MixCollection& hits, CLHEP::HepRandomEngine* ) ; + + virtual unsigned int samplesSize() const = 0 ; + + virtual EcalSamples* operator[]( unsigned int i ) = 0; + + virtual const EcalSamples* operator[]( unsigned int i ) const = 0; + + const EcalSamples* findDetId( const DetId& detId ) const ; + + bool withinBunchRange(int bunchCrossing) const ; + + protected: + + virtual unsigned int samplesSizeAll() const = 0 ; + + virtual EcalSamples* vSam( unsigned int i ) = 0 ; + + virtual EcalSamples* vSamAll( unsigned int i ) = 0 ; + + virtual const EcalSamples* vSamAll( unsigned int i ) const = 0 ; + + virtual void putAnalogSignal( const PCaloHit& inputHit, CLHEP::HepRandomEngine*) ; + + double findLaserConstant(const DetId& detId) const; + + EcalSamples* findSignal( const DetId& detId ) ; + + double analogSignalAmplitude( const DetId& id, double energy, CLHEP::HepRandomEngine* ); + + double timeOfFlight( const DetId& detId ) const ; + + double phaseShift() const ; + + void blankOutUsedSamples() ; + + const CaloSimParameters* params( const DetId& detId ) const ; + + const CaloVShape* shape() const ; + + const CaloSubdetectorGeometry* geometry() const ; + + int minBunch() const ; + + int maxBunch() const ; + + VecInd& index() ; + + const VecInd& index() const ; + + const CaloVHitFilter* hitFilter() const ; + + private: + + const CaloVSimParameterMap* m_parameterMap ; + const CaloVShape* m_shape ; + const CaloVHitCorrection* m_hitCorrection ; + const CaloVPECorrection* m_PECorrection ; + const CaloVHitFilter* m_hitFilter ; + const CaloSubdetectorGeometry* m_geometry ; + const EcalLaserDbService* m_lasercals ; + + int m_minBunch ; + int m_maxBunch ; + double m_phaseShift ; + + edm::TimeValue_t m_iTime; + bool m_useLCcorrection; + CalibCache m_laserCalibCache; + + VecInd m_index ; +}; + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h new file mode 100644 index 0000000000000..96cda8c36020e --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h @@ -0,0 +1,39 @@ +#ifndef EcalSimAlgos_EcalSimParameterMap_Ph2_h +#define EcalSimAlgos_EcalSimParameterMap_Ph2_h + +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" + + +/* \class EcalSimParametersMap + * \brief map of parameters for the ECAL (EE, EB, preshower) simulation + * + */ +class EcalSimParameterMap_Ph2 : public CaloVSimParameterMap +{ +public: + /// ctor + EcalSimParameterMap_Ph2(); + EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, + //double simHitToPhotoelectronsEndcap, + double photoelectronsToAnalogBarrel, + //double photoelectronsToAnalogEndcap, + double samplingFactor, double timePhase, + int readoutFrameSize, int binOfMaximum, + bool doPhotostatistics, bool syncPhase); + /// dtor + ~EcalSimParameterMap_Ph2() override {} + + /// return the sim parameters relative to the right subdet + const CaloSimParameters & simParameters(const DetId & id) const override; + +private: + /// EB + CaloSimParameters theBarrelParameters; + /// EE + //CaloSimParameters theEndcapParameters; + /// ES + CaloSimParameters theESParameters; +}; + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h new file mode 100644 index 0000000000000..7d06496e0aec2 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h @@ -0,0 +1,71 @@ +#ifndef EcalSimAlgos_EcalTDigitizer_Ph2_h +#define EcalSimAlgos_EcalTDigitizer_Ph2_h + +/** Turns hits into digis. Assumes that + there's an ElectroncsSim class with the + interface analogToDigital(CLHEP::HepRandomEngine*, const CaloSamples &, Digi &); +*/ + +#include "SimDataFormats/CrossingFrame/interface/MixCollection.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" +#include "DataFormats/DetId/interface/DetId.h" +#include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h" + +class EcalHitResponse_Ph2 ; +class EcalBaseSignalGenerator; + +namespace CLHEP { + class HepRandomEngine; +} + +template< class Traits > +class EcalTDigitizer_Ph2 +{ + public: + typedef typename Traits::ElectronicsSim_Ph2 ElectronicsSim_Ph2 ; + typedef typename Traits::Digi Digi ; + typedef typename Traits::DigiCollection DigiCollection ; + typedef typename Traits::EcalSamples EcalSamples ; + + EcalTDigitizer_Ph2< Traits >( EcalHitResponse_Ph2* hitResponse , + ElectronicsSim_Ph2* electronicsSim , + bool addNoise ) ; + + virtual ~EcalTDigitizer_Ph2< Traits >() ; + + void add(const std::vector & hits, int bunchCrossing, CLHEP::HepRandomEngine*); + + virtual void initializeHits(); + + virtual void run(DigiCollection& output, CLHEP::HepRandomEngine* ); + + virtual void run( MixCollection& input , + DigiCollection& output ) { + assert(0); + } + + void setNoiseSignalGenerator(EcalBaseSignalGenerator * noiseSignalGenerator); + + void addNoiseSignals(); + + protected: + + bool addNoise() const ; + + const EcalHitResponse_Ph2* hitResponse() const ; + + const ElectronicsSim_Ph2* elecSim() const ; + + private: + + EcalHitResponse_Ph2* m_hitResponse ; + ElectronicsSim_Ph2* m_electronicsSim ; + bool m_addNoise ; + + EcalBaseSignalGenerator * theNoiseSignalGenerator; + +}; + +#endif + diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc new file mode 100644 index 0000000000000..7c27ada77afef --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc @@ -0,0 +1,92 @@ +#ifndef EcalSimAlgos_EcalTDigitizer_Ph2_icc +#define EcalSimAlgos_EcalTDigitizer_Ph2_icc + +#include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h" +#include "CalibFormats/CaloObjects/interface/CaloSamples.h" + +template +EcalTDigitizer_Ph2::EcalTDigitizer_Ph2(EcalHitResponse_Ph2* hitResponse, ElectronicsSim_Ph2* electronicsSim, bool addNoise) + : m_hitResponse(hitResponse), + m_electronicsSim(electronicsSim), + m_addNoise(addNoise), + theNoiseSignalGenerator(nullptr) {} + +template +EcalTDigitizer_Ph2::~EcalTDigitizer_Ph2() {} + +template +void EcalTDigitizer_Ph2::add(const std::vector& hits, int bunchCrossing, CLHEP::HepRandomEngine* engine) { + if (m_hitResponse->withinBunchRange(bunchCrossing)) { + for (std::vector::const_iterator it = hits.begin(), itEnd = hits.end(); it != itEnd; ++it) { + m_hitResponse->add(*it, engine); + } + } +} + +template +void EcalTDigitizer_Ph2::initializeHits() { + m_hitResponse->initializeHits(); +} + +template +void EcalTDigitizer_Ph2::setNoiseSignalGenerator(EcalBaseSignalGenerator* noiseSignalGenerator) { + theNoiseSignalGenerator = noiseSignalGenerator; +} + +template +void EcalTDigitizer_Ph2::run(DigiCollection& output, CLHEP::HepRandomEngine* engine) { + m_hitResponse->finalizeHits(); + + if (theNoiseSignalGenerator != nullptr) { + addNoiseSignals(); + } + + m_electronicsSim->newEvent(); + + const unsigned int ssize(m_hitResponse->samplesSize()); + output.reserve(ssize); + + for (unsigned int i(0); i != ssize; ++i) { + EcalSamples& analogSignal(*static_cast((*m_hitResponse)[i])); + if (m_addNoise || // digitize if real or adding noise + !analogSignal.zero()) { + output.push_back(analogSignal.id().rawId()); + Digi digi(output.back()); // why does this work without & + m_electronicsSim->analogToDigital(engine, analogSignal, digi); + Traits::fix(digi, output.back()); + } + } +} + +template +void EcalTDigitizer_Ph2::addNoiseSignals() { + std::vector noiseSignals; + // noise signals need to be in units of photoelectrons. Fractional is OK + theNoiseSignalGenerator->fillEvent(); + theNoiseSignalGenerator->getNoiseSignals(noiseSignals); + for (typename std::vector::const_iterator signalItr = noiseSignals.begin(), + signalEnd = noiseSignals.end(); + signalItr != signalEnd; + ++signalItr) { + m_hitResponse->add(*signalItr); + } +} + +template +bool EcalTDigitizer_Ph2::addNoise() const { + return m_addNoise; +} + +template +const EcalHitResponse_Ph2* EcalTDigitizer_Ph2::hitResponse() const { + return m_hitResponse; +} + +template +const typename Traits::ElectronicsSim_Ph2* EcalTDigitizer_Ph2::elecSim() const { + return m_electronicsSim; +} + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc new file mode 100644 index 0000000000000..f8cc8b2f32005 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc @@ -0,0 +1,355 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitFilter.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVShape.h" +#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" +#include "CLHEP/Random/RandPoissonQ.h" +#include "CLHEP/Random/RandGaussQ.h" +#include "DataFormats/EcalDetId/interface/EBDetId.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" +#include "FWCore/Utilities/interface/isFinite.h" +#include "FWCore/Utilities/interface/Exception.h" + +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + + +using namespace ecalPh2; + +EBHitResponse_Ph2::EBHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , + const CaloVShape* shape , + bool apdOnly , + const APDSimParameters* apdPars = nullptr , + const CaloVShape* apdShape = nullptr ) : + + EcalHitResponse_Ph2( parameterMap, shape ) , + + m_apdOnly ( apdOnly ) , + m_apdPars ( apdPars ) , + m_apdShape ( apdShape ) , + m_timeOffVec ( kNOffsets, apdParameters()->timeOffset() ) , + pcub ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[0] ) , + pqua ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[1] ) , + plin ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[2] ) , + pcon ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[3] ) , + pelo ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[4] ) , + pehi ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[5] ) , + pasy ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[6] ) , + pext ( nullptr == apdPars ? 0 : nonlFunc1( pelo ) ) , + poff ( nullptr == apdPars ? 0 : nonlFunc1( pehi ) ) , + pfac ( nullptr == apdPars ? 0 : ( pasy - poff )*2./M_PI ), + m_isInitialized(false) +{ + const EBDetId detId ( EBDetId::detIdFromDenseIndex( 0 ) ) ; + const CaloSimParameters& parameters ( parameterMap->simParameters( detId ) ) ; + + const unsigned int rSize ( parameters.readoutFrameSize() ) ; + const unsigned int nPre ( parameters.binOfMaximum() - 1 ) ; + + const unsigned int size ( EBDetId::kSizeForDenseIndexing ) ; + + m_vSam.reserve( size ) ; + + for( unsigned int i ( 0 ) ; i != size ; ++i ) + { + m_vSam.emplace_back(CaloGenericDetId( detId.det(), detId.subdetId(), i ) , + rSize, nPre ); + } +} + +EBHitResponse_Ph2::~EBHitResponse_Ph2() +{ +} + +void +EBHitResponse_Ph2::initialize(CLHEP::HepRandomEngine* engine) +{ + m_isInitialized = true; + for( unsigned int i ( 0 ) ; i != kNOffsets ; ++i ) + { + m_timeOffVec[ i ] += + CLHEP::RandGaussQ::shoot(engine, 0, apdParameters()->timeOffWidth() ) ; + } +} + +const APDSimParameters* +EBHitResponse_Ph2::apdParameters() const +{ + assert ( nullptr != m_apdPars ) ; + return m_apdPars ; +} + +const CaloVShape* +EBHitResponse_Ph2::apdShape() const +{ + assert( nullptr != m_apdShape ) ; + return m_apdShape ; +} + +void +EBHitResponse_Ph2::putAPDSignal( const DetId& detId , + double npe , + double time ) +{ + const CaloSimParameters& parameters ( *params( detId ) ) ; + + const double energyFac ( 1./parameters.simHitToPhotoelectrons( detId ) ) ; + +// std::cout<<"******** Input APD Npe="<timeToRise() + - jitter + - offsets()[ EBDetId( detId ).denseIndex()%kNOffsets ] + - BUNCHSPACE*( parameters.binOfMaximum() + - phaseShift() ) ) ; + + double binTime ( tzero ) ; + + EcalSamples& result ( *findSignal( detId ) ); + + for( unsigned int bin ( 0 ) ; bin != result.size(); ++bin ) + { + result[bin] += (*apdShape())(binTime)*signal ; + binTime += BUNCHSPACE ; + } +} + +double +EBHitResponse_Ph2::apdSignalAmplitude( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) const +{ + int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); + assert( 1 == iddepth || 2 == iddepth ) ; + + double npe ( hit.energy()*( 2 == iddepth ? + apdParameters()->simToPELow() : + apdParameters()->simToPEHigh() ) ) ; + + // do we need to do Poisson statistics for the photoelectrons? + if( apdParameters()->doPEStats() && + !m_apdOnly ) { + + CLHEP::RandPoissonQ randPoissonQ(*engine, npe); + npe = randPoissonQ.fire(); + } + assert( nullptr != m_intercal ) ; + double fac ( 1 ) ; + findIntercalibConstant( hit.id(), fac ) ; + + npe *= fac ; + +// edm::LogError( "EBHitResponse_Ph2" ) << "--- # photoelectrons for " +/* std::cout << "--- # photoelectrons for " + << EBDetId( hit.id() ) + <<" is " << npe //; + <getMap() ) ; + EcalIntercalibConstantMCMap::const_iterator icalit ( icalMap.find( detId ) ) ; + if( icalit != icalMap.end() ) + { + thisconst = *icalit ; + if ( thisconst == 0. ) thisconst = 1. ; + } + else + { + edm::LogError("EBHitResponse_Ph2") << "No intercalib const found for xtal " + << detId.rawId() + << "! something wrong with EcalIntercalibConstants in your DB? "; + } + } + icalconst = thisconst ; +} + +void +EBHitResponse_Ph2::initializeHits() { + if( !index().empty() ) blankOutUsedSamples() ; + + const unsigned int bSize ( EBDetId::kSizeForDenseIndexing ) ; + + if( m_apdNpeVec.empty() ) + { + m_apdNpeVec = std::vector( bSize, (double)0.0 ) ; + m_apdTimeVec = std::vector( bSize, (double)0.0 ) ; + } +} + +void +EBHitResponse_Ph2::finalizeHits() { + const unsigned int bSize ( EBDetId::kSizeForDenseIndexing ) ; + if( apdParameters()->addToBarrel() || + m_apdOnly ) + { + for( unsigned int i ( 0 ) ; i != bSize ; ++i ) + { + if( 0 < m_apdNpeVec[i] ) + { + putAPDSignal( EBDetId::detIdFromDenseIndex( i ), + m_apdNpeVec[i] , + m_apdTimeVec[i] ) ; + + // now zero out for next time + m_apdNpeVec[i] = 0. ; + m_apdTimeVec[i] = 0. ; + } + } + } +} + +void +EBHitResponse_Ph2::add( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) +{ + if (!edm::isNotFinite( hit.time() ) && ( nullptr == hitFilter() || hitFilter()->accepts( hit ) ) ) { + int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); + if ( 0 == iddepth ) // for now take only nonAPD hits + { + if( !m_apdOnly ) putAnalogSignal( hit, engine ) ; + } + else // APD hits here + { + if( apdParameters()->addToBarrel() || + m_apdOnly ) + { + const unsigned int icell ( EBDetId( hit.id() ).denseIndex() ) ; + m_apdNpeVec[ icell ] += apdSignalAmplitude( hit, engine ) ; + if( 0 == m_apdTimeVec[ icell ] ) m_apdTimeVec[ icell ] = hit.time() ; + } + } + } +} + +void +EBHitResponse_Ph2::run( MixCollection& hits, CLHEP::HepRandomEngine* engine ) +{ + if( !index().empty() ) blankOutUsedSamples() ; + + const unsigned int bSize ( EBDetId::kSizeForDenseIndexing ) ; + + if( m_apdNpeVec.empty() ) + { + m_apdNpeVec = std::vector( bSize, (double)0.0 ) ; + m_apdTimeVec = std::vector( bSize, (double)0.0 ) ; + } + + for( MixCollection::MixItr hitItr ( hits.begin() ) ; + hitItr != hits.end() ; ++hitItr ) + { + const PCaloHit& hit ( *hitItr ) ; + const int bunch ( hitItr.bunch() ) ; + if( minBunch() <= bunch && + maxBunch() >= bunch && + !edm::isNotFinite( hit.time() ) && + ( nullptr == hitFilter() || + hitFilter()->accepts( hit ) ) ) + { + int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); + if( 0 == iddepth ) // for now take only nonAPD hits + { + if( !m_apdOnly ) putAnalogSignal( hit, engine ) ; + } + else // APD hits here + { + if( apdParameters()->addToBarrel() || + m_apdOnly ) + { + const unsigned int icell ( EBDetId( hit.id() ).denseIndex() ) ; + m_apdNpeVec[ icell ] += apdSignalAmplitude( hit, engine ) ; + if( 0 == m_apdTimeVec[ icell ] ) m_apdTimeVec[ icell ] = hit.time() ; + } + } + } + } + + if( apdParameters()->addToBarrel() || + m_apdOnly ) + { + for( unsigned int i ( 0 ) ; i != bSize ; ++i ) + { + if( 0 < m_apdNpeVec[i] ) + { + putAPDSignal( EBDetId::detIdFromDenseIndex( i ), + m_apdNpeVec[i] , + m_apdTimeVec[i] ) ; + + // now zero out for next time + m_apdNpeVec[i] = 0. ; + m_apdTimeVec[i] = 0. ; + } + } + } +} + +unsigned int +EBHitResponse_Ph2::samplesSize() const +{ + return m_vSam.size() ; +} + +unsigned int +EBHitResponse_Ph2::samplesSizeAll() const +{ + return m_vSam.size() ; +} + +const EcalHitResponse_Ph2::EcalSamples* +EBHitResponse_Ph2::operator[]( unsigned int i ) const +{ + return &m_vSam[ i ] ; +} + +EcalHitResponse_Ph2::EcalSamples* +EBHitResponse_Ph2::operator[]( unsigned int i ) +{ + return &m_vSam[ i ] ; +} + +EcalHitResponse_Ph2::EcalSamples* +EBHitResponse_Ph2::vSam( unsigned int i ) +{ + return &m_vSam[ i ] ; +} + +EcalHitResponse_Ph2::EcalSamples* +EBHitResponse_Ph2::vSamAll( unsigned int i ) +{ + return &m_vSam[ i ] ; +} + +const EcalHitResponse_Ph2::EcalSamples* +EBHitResponse_Ph2::vSamAll( unsigned int i ) const +{ + return &m_vSam[ i ] ; +} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc new file mode 100644 index 0000000000000..0f2c67ad800f8 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc @@ -0,0 +1,283 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.h" +#include "DataFormats/EcalDigi/interface/EcalMGPASample.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame.h" + +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +#include + +//#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" + +///////////////////// +//NOTE: +//TO BE CORRECTLY IMPLEMENTED! +//Simona Cometti, [20.03.20 12:05] +//[In reply to Dario Soldi] +//Allora nella versione 1 i samples a gain 1 erano solo 8 +//Centrati così: +//Quindi 2 samples prima e 5 dopo a quello saturato +//Nella versione 1.2 c'è la possibilità di avere 8 samples o 16 samples dal gain 1 +//Quando è selezionata l'opzione dei 16 samples: +//5 samples prima, il sample saturo e poi 10 samples dopo +const float DTUVersion = 1.0; + +EcalCoder_Ph2::EcalCoder_Ph2( bool addNoise , + bool PreMix1 , + EcalCoder_Ph2::Noisifier* ebCorrNoise0 , + EcalCoder_Ph2::Noisifier* ebCorrNoise1 ) : + m_peds ( nullptr ) , + m_gainRatios ( nullptr ) , + m_intercals ( nullptr ) , + // m_maxEneEB ( 1668.3 ) , // 4095(MAXADC)*12(gain 2)*0.035(GeVtoADC)*0.97 + m_maxEneEB ( 2000. ) , // Maximum for CATIA: LSB gain 10: 0.048 MeV + m_addNoise ( addNoise ) , + m_PreMix1 ( PreMix1 ) + +{ + m_ebCorrNoise[0] = ebCorrNoise0 ; + assert( nullptr != m_ebCorrNoise[0] ) ; + m_ebCorrNoise[1] = ebCorrNoise1 ; + +} + +EcalCoder_Ph2::~EcalCoder_Ph2() +{ +} + +void +EcalCoder_Ph2::setFullScaleEnergy( double EBscale ) +{ + // m_maxEneEB = EBscale ; + m_maxEneEB = 2000. ; //I don 't know where is setFullScaleEnergy first call + +} + + +void +EcalCoder_Ph2::setPedestals( const EcalLiteDTUPedestals* pedestals ) +{ + m_peds = pedestals ; +} + +void +EcalCoder_Ph2::setGainRatios( const EcalCATIAGainRatios* gainRatios ) +{ + m_gainRatios = gainRatios ; +} + +void +EcalCoder_Ph2::setIntercalibConstants( const EcalIntercalibConstantsMC* ical ) +{ + m_intercals = ical ; +} + +double +EcalCoder_Ph2::fullScaleEnergy( const DetId & detId ) const +{ + //return detId.subdetId() == EcalBarrel ? m_maxEneEB : m_maxEneEE ; + return m_maxEneEB ; +} + +void +EcalCoder_Ph2::analogToDigital( CLHEP::HepRandomEngine* engine, + const EcalSamples& clf , + EcalDataFrame& df ) const +{ + df.setSize( clf.size() ) ; + encode( clf, df, engine ); + +} + +void +EcalCoder_Ph2::encode( const EcalSamples& ecalSamples , + EcalDataFrame& df, + CLHEP::HepRandomEngine* engine ) const +{ + assert( nullptr != m_peds ) ; + + const unsigned int csize ( ecalSamples.size() ) ; + + + DetId detId = ecalSamples.id(); + double Emax = fullScaleEnergy(detId); + + //....initialisation + if ( ecalSamples[5] > 0. ) LogDebug("EcalCoder_Ph2") << "Input caloSample" << "\n" << ecalSamples; + + + //N Gains set to 2 in the .h + double pedestals[ecalPh2::NGAINS]; + double widths[ecalPh2::NGAINS]; + //float gains[ecalPh2::NGAINS]; + double LSB[ecalPh2::NGAINS]; + double trueRMS[ecalPh2::NGAINS]; + + + double icalconst = 1. ; + findIntercalibConstant( detId, icalconst ); + + + for( unsigned int igain ( 0 ); igain < NGAINS ; ++igain ) + { + // fill in the pedestal and width + + findPedestal( detId , + igain , + pedestals[igain] , + widths[igain] ) ; + //I insert an absolute value in the trueRMS + trueRMS[igain] = std::sqrt( std::fabs(widths[igain]*widths[igain] - 1./12.) ) ; + + // set nominal value first + //findGains( detId , gains ); + + LSB[igain]= Emax/(MAXADC*ecalPh2::gains[igain]); + + + } + + CaloSamples noiseframe[] = { CaloSamples( detId , csize ) , + CaloSamples( detId , csize ) , + } ; + + const Noisifier* noisy[NGAINS] = { m_ebCorrNoise[0],m_ebCorrNoise[1]} ; + + if( m_addNoise ){ + + #warning noise generation to be checked + noisy[0]->noisify( noiseframe[0], engine ) ; // high gain + //if( nullptr == noisy[1] ) noisy[0]->noisify( noiseframe[1] , + // engine, + // &noisy[0]->vecgau() ) ; // lwo gain + noisy[1]->noisify( noiseframe[1], engine ) ; // low gain + } + + + bool isSaturated[]={false,false}; + std::vector> adctrace(csize); + unsigned int saturatedSample[]={0,0}; + + for( unsigned int i ( 0 ) ; i != csize ; ++i ) adctrace[i].resize(NGAINS); + + for (unsigned int igain=0; igain MAXADC) { + adc = MAXADC; + isSaturated[igain] = true; + saturatedSample[igain] = i; + } + + if (isSaturated[0] && igain==0) { + break; // gain 0 (x10) channel is saturated, readout will use gain 1 (x10) + } + else adctrace[i][igain]=adc; + + if(ecalSamples[i]>0.) + { + // std::cout<<" igain = "<getMap().size(); + } + + + LogDebug("EcalCoder_Ph2") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" << "Mean = " << ped << " rms = " << width; +} + + +// void +// EcalCoder::findGains( const DetId & detId , float Gains[] ) const +// { + +// EcalCATIAGainRatioMap::const_iterator grit = m_gainRatios->getMap().find( detId ); +// Gains[1] = 1.; +// Gains[0] = Gains[1]*(*grit); + +// if ( (detId.subdetId() != EcalBarrel) && (detId.subdetId() != EcalEndcap) ) +// { +// edm::LogError("EcalCoder") << "Could not find gain ratios for " << detId.rawId() << " among the " << m_gainRatios->getMap().size(); +// } + +// } + +void +EcalCoder_Ph2::findIntercalibConstant( const DetId& detId, + double& icalconst ) const +{ + EcalIntercalibConstantMC thisconst = 1.; + // find intercalib constant for this xtal + const EcalIntercalibConstantMCMap &icalMap = m_intercals->getMap(); + EcalIntercalibConstantMCMap::const_iterator icalit = icalMap.find(detId); + if( icalit!=icalMap.end() ) + { + thisconst = (*icalit); + if ( icalconst == 0. ) { thisconst = 1.; } + } + else + { + edm::LogError("EcalCoder_Ph2") << "No intercalib const found for xtal " << detId.rawId() << "! something wrong with EcalIntercalibConstants in your DB? "; + } + icalconst = thisconst; +} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc new file mode 100644 index 0000000000000..d120016ba2191 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc @@ -0,0 +1,12 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h" +#include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.icc" + +template class CorrelatedNoisifier< EcalCorrMatrix_Ph2 > ; + +template +void +CorrelatedNoisifier< EcalCorrMatrix_Ph2 >::noisify(CaloSamples&, + CLHEP::HepRandomEngine*, + const std::vector* rangau ) const ; + + diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers_Ph2.cc new file mode 100644 index 0000000000000..4f11f9315fd47 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers_Ph2.cc @@ -0,0 +1,4 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc" + +template class EcalTDigitizer_Ph2; diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc new file mode 100644 index 0000000000000..2b54905be00e3 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc @@ -0,0 +1,37 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h" + +#include "CLHEP/Random/RandGaussQ.h" + +#include +#include +#include +#include +#include + +EcalElectronicsSim_Ph2::EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, + EcalCoder_Ph2* coder, + bool applyConstantTerm, + double rmsConstantTerm) + : m_simMap(parameterMap), m_theCoder(coder), m_thisCT(rmsConstantTerm), m_applyConstantTerm(applyConstantTerm) {} + +EcalElectronicsSim_Ph2::~EcalElectronicsSim_Ph2() {} + +void EcalElectronicsSim_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, + EcalElectronicsSim_Ph2::EcalSamples& clf, + EcalDataFrame& df) const { + //PG input signal is in pe. Converted in GeV + amplify(clf, engine); + + m_theCoder->analogToDigital(engine, clf, df); +} + +void EcalElectronicsSim_Ph2::amplify(EcalElectronicsSim_Ph2::EcalSamples& clf, CLHEP::HepRandomEngine* engine) const { + const double fac(m_simMap->simParameters(clf.id()).photoelectronsToAnalog()); + if (m_applyConstantTerm) { + clf *= fac * CLHEP::RandGaussQ::shoot(engine, 1.0, m_thisCT); + } else { + clf *= fac; + } +} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc new file mode 100644 index 0000000000000..1ea5c78bc0d83 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc @@ -0,0 +1,353 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVShape.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitCorrection.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitFilter.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVPECorrection.h" +#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" +#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h" +#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" +#include "DataFormats/EcalDetId/interface/ESDetId.h" +#include "CLHEP/Random/RandPoissonQ.h" +#include "FWCore/Utilities/interface/isFinite.h" + +#include "CLHEP/Units/GlobalPhysicalConstants.h" +#include "CLHEP/Units/GlobalSystemOfUnits.h" +#include + +#include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h" + + +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + + + +EcalHitResponse_Ph2::EcalHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , + const CaloVShape* shape ) : + m_parameterMap ( parameterMap ) , + m_shape ( shape ) , + m_hitCorrection ( nullptr ) , + m_PECorrection ( nullptr ) , + m_hitFilter ( nullptr ) , + m_geometry ( nullptr ) , + m_lasercals ( nullptr ) , + m_minBunch ( -32 ) , + m_maxBunch ( 10 ) , + m_phaseShift ( 1 ) , + m_iTime ( 0 ) , + m_useLCcorrection ( false ) +{ +} + +EcalHitResponse_Ph2::~EcalHitResponse_Ph2() +{ +} + +const CaloSimParameters* +EcalHitResponse_Ph2::params( const DetId& detId ) const +{ + assert( nullptr != m_parameterMap ) ; + return &m_parameterMap->simParameters( detId ) ; +} + +const CaloVShape* +EcalHitResponse_Ph2::shape() const +{ + assert( nullptr != m_shape ) ; + return m_shape ; +} + +const CaloSubdetectorGeometry* +EcalHitResponse_Ph2::geometry() const +{ + assert( nullptr != m_geometry ) ; + return m_geometry ; +} + +void +EcalHitResponse_Ph2::setBunchRange( int minBunch , + int maxBunch ) +{ + m_minBunch = minBunch ; + m_maxBunch = maxBunch ; +} + +void +EcalHitResponse_Ph2::setGeometry( const CaloSubdetectorGeometry* geometry ) +{ + m_geometry = geometry ; +} + +void +EcalHitResponse_Ph2::setPhaseShift( double phaseShift ) +{ + m_phaseShift = phaseShift ; +} + +double +EcalHitResponse_Ph2::phaseShift() const +{ + return m_phaseShift ; +} + +void +EcalHitResponse_Ph2::setHitFilter( const CaloVHitFilter* filter) +{ + m_hitFilter = filter ; +} + +void +EcalHitResponse_Ph2::setHitCorrection( const CaloVHitCorrection* hitCorrection) +{ + m_hitCorrection = hitCorrection ; +} + +void +EcalHitResponse_Ph2::setPECorrection( const CaloVPECorrection* peCorrection ) +{ + m_PECorrection = peCorrection ; +} + +void +EcalHitResponse_Ph2::setEventTime(const edm::TimeValue_t& iTime) +{ + m_iTime = iTime; + //clear the laser cache for each event time + CalibCache().swap(m_laserCalibCache); +} + +void +EcalHitResponse_Ph2::setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection) +{ + m_lasercals = laser; + m_useLCcorrection = useLCcorrection; +} + +void +EcalHitResponse_Ph2::blankOutUsedSamples() // blank out previously used elements +{ + const unsigned int size ( m_index.size() ) ; + + for( unsigned int i ( 0 ) ; i != size ; ++i ) + { + vSamAll( m_index[i] )->setZero() ; + } + m_index.erase( m_index.begin() , // done and make ready to start over + m_index.end() ) ; +} + +void +EcalHitResponse_Ph2::add( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) +{ + if (!edm::isNotFinite( hit.time() ) && ( nullptr == m_hitFilter || m_hitFilter->accepts( hit ) ) ) { + putAnalogSignal( hit, engine ) ; + } +} + +void +EcalHitResponse_Ph2::add( const CaloSamples& hit ) +{ + const DetId detId ( hit.id() ) ; + + EcalSamples& result ( *findSignal( detId ) ) ; + + const int rsize ( result.size() ) ; + + if(rsize != hit.size()) { + throw cms::Exception("EcalDigitization") + << "CaloSamples and EcalSamples have different sizes. Type Mismatach"; + } + + for( int bin ( 0 ) ; bin != rsize ; ++bin ) + { + result[ bin ] += hit[ bin ] ; + } + + std::cout << "rsize: " << rsize << " hit.size: " << hit.size() << "\n" << std::endl; //Not printed. Function apparently never used +} + + +bool +EcalHitResponse_Ph2::withinBunchRange(int bunchCrossing) const +{ + return(m_minBunch <= bunchCrossing && m_maxBunch >= bunchCrossing); +} + +void +EcalHitResponse_Ph2::initializeHits() +{ + blankOutUsedSamples() ; +} + +void +EcalHitResponse_Ph2::finalizeHits() +{ +} + +void +EcalHitResponse_Ph2::run( MixCollection& hits, CLHEP::HepRandomEngine* engine ) +{ + + + + blankOutUsedSamples() ; + + for( MixCollection::MixItr hitItr ( hits.begin() ) ; + hitItr != hits.end() ; ++hitItr ) + { + const PCaloHit& hit ( *hitItr ) ; + const int bunch ( hitItr.bunch() ) ; + if( withinBunchRange(bunch) && + !edm::isNotFinite( hit.time() ) && + ( nullptr == m_hitFilter || + m_hitFilter->accepts( hit ) ) ) putAnalogSignal( hit, engine ) ; + } + +} + +void +EcalHitResponse_Ph2::putAnalogSignal( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) +{ + + //const EBShape* sh=dynamic_cast (shape()); + //EBShape* csh = const_cast(sh); + //std::cout << " Cast result" << csh << std::endl; + //if (csh) csh->m_shape_print("newshape.txt"); + + const DetId detId ( hit.id() ) ; + + const CaloSimParameters* parameters ( params( detId ) ) ; + + const double signal ( analogSignalAmplitude( detId, hit.energy(), engine ) ) ; //Signal amplitude in number of photoelectrons (npe) + + double time = hit.time(); + + if(m_hitCorrection) { + time += m_hitCorrection->delay( hit, engine ) ; + } + + const double jitter ( time - timeOfFlight( detId ) ) ; + + const double tzero = ( shape()->timeToRise() + + parameters->timePhase() + - jitter + - ecalPh2::BUNCHSPACE*( parameters->binOfMaximum() - m_phaseShift ) ) ; + double binTime ( tzero ) ; + + EcalSamples& result ( *findSignal( detId ) ) ; + + const unsigned int rsize ( result.size() ) ; + + EBDetId ebid(detId); + + if (hit.energy() > 1.0){ + + for( unsigned int bin ( 0 ) ; bin != rsize ; ++bin ){ + + result[ bin ] += (*shape())( binTime )*signal ; + + binTime += ecalPh2::BUNCHSPACE; + } + } +} + +double +EcalHitResponse_Ph2::findLaserConstant(const DetId& detId) const +{ + const edm::Timestamp& evtTimeStamp = edm::Timestamp(m_iTime); + return (m_lasercals->getLaserCorrection(detId, evtTimeStamp)); +} + +EcalHitResponse_Ph2::EcalSamples* +EcalHitResponse_Ph2::findSignal( const DetId& detId ) +{ + const unsigned int di ( CaloGenericDetId( detId ).denseIndex() ) ; + EcalSamples* result ( vSamAll( di ) ) ; + + if( result->zero() ) m_index.push_back( di ) ; + return result ; +} + +double +EcalHitResponse_Ph2::analogSignalAmplitude( const DetId& detId, double energy, CLHEP::HepRandomEngine* engine ) +{ + const CaloSimParameters& parameters ( *params( detId ) ) ; + + // OK, the "energy" in the hit could be a real energy, deposited energy, + // or pe count. This factor converts to photoelectrons + + double lasercalib = 1.; + if(m_useLCcorrection == true && detId.subdetId() != 3) { + auto cache = m_laserCalibCache.find(detId); + if( cache != m_laserCalibCache.end() ) { + lasercalib = cache->second; + } else { + lasercalib = 1.0/findLaserConstant(detId); + m_laserCalibCache.emplace(detId,lasercalib); + } + } + + double npe ( energy*lasercalib*parameters.simHitToPhotoelectrons( detId ) ) ; + + // do we need to doPoisson statistics for the photoelectrons? Yes, otherwise we just get the "mean value" + if( parameters.doPhotostatistics() ) { + npe = CLHEP::RandPoissonQ::shoot(engine, npe); + } + if( nullptr != m_PECorrection ) npe = m_PECorrection->correctPE( detId, npe, engine ) ; + + return npe ; +} + +double +EcalHitResponse_Ph2::timeOfFlight( const DetId& detId ) const +{ + auto cellGeometry ( geometry()->getGeometry( detId ) ) ; + assert( nullptr != cellGeometry ) ; + return cellGeometry->getPosition().mag()*cm/c_light ; // Units of c_light: mm/ns +} + +void +EcalHitResponse_Ph2::add( const EcalSamples* pSam ) +{ + EcalSamples& sam ( *findSignal( pSam->id() ) ) ; + sam += (*pSam) ; +} + +int +EcalHitResponse_Ph2::minBunch() const +{ + return m_minBunch ; +} + +int +EcalHitResponse_Ph2::maxBunch() const +{ + return m_maxBunch ; +} + +EcalHitResponse_Ph2::VecInd& +EcalHitResponse_Ph2::index() +{ + return m_index ; +} + +const EcalHitResponse_Ph2::VecInd& +EcalHitResponse_Ph2::index() const +{ + return m_index ; +} + +const CaloVHitFilter* +EcalHitResponse_Ph2::hitFilter() const +{ + return m_hitFilter ; +} + +const EcalHitResponse_Ph2::EcalSamples* +EcalHitResponse_Ph2::findDetId( const DetId& detId ) const +{ + const unsigned int di ( CaloGenericDetId( detId ).denseIndex() ) ; + return vSamAll( di ) ; +} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc new file mode 100644 index 0000000000000..14bea503c0d0e --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc @@ -0,0 +1,49 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h" +#include "DataFormats/DetId/interface/DetId.h" +#include "DataFormats/EcalDetId/interface/EcalSubdetector.h" +#include + +/** Relevant constants are: + 4.5 photoelectrons per MeV (J. Nash's slides) + APD gain 50, but analog signal stays in GeV + Account for excess noise factor + */ + +EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2() : + theBarrelParameters(2250., 1./2250., 1., 0, 16, 6, true, true), + //theEndcapParameters(1800., 1./1800., 1., 0, 16, 6, true, true), + theESParameters(1., 1., 1., 20., 3, 2, false, true) +{} + +EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, + //double simHitToPhotoelectronsEndcap, + double photoelectronsToAnalogBarrel, + //double photoelectronsToAnalogEndcap, + double samplingFactor, double timePhase, + int readoutFrameSize, int binOfMaximum, + bool doPhotostatistics, bool syncPhase) : + theBarrelParameters(simHitToPhotoelectronsBarrel, photoelectronsToAnalogBarrel, + samplingFactor, timePhase, + readoutFrameSize, binOfMaximum, doPhotostatistics, syncPhase), + //theEndcapParameters(simHitToPhotoelectronsEndcap, photoelectronsToAnalogEndcap, + //samplingFactor, timePhase, + //readoutFrameSize, binOfMaximum, doPhotostatistics, syncPhase), + theESParameters(1., 1., 1., 20., 3, 2, false, syncPhase) +{} + + /* + CaloSimParameters(double simHitToPhotoelectrons, double photoelectronsToAnalog, + double samplingFactor, double timePhase, + int readoutFrameSize, int binOfMaximum, + bool doPhotostatistics, bool syncPhase) + */ + +const CaloSimParameters & EcalSimParameterMap_Ph2::simParameters(const DetId & detId) const +{ + if (EcalSubdetector(detId.subdetId()) == EcalBarrel) + return theBarrelParameters; + //else if (EcalSubdetector(detId.subdetId()) == EcalEndcap) + //return theEndcapParameters; + else + return theESParameters; +} diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h new file mode 100644 index 0000000000000..f3d9a916d4f20 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h @@ -0,0 +1,123 @@ +#ifndef SimCalorimetry_EcalSimProducers_EcalDigiProducer_Ph2_h +#define SimCalorimetry_EcalSimProducers_EcalDigiProducer_Ph2_h + +#include "SimCalorimetry/EcalSimAlgos/interface/APDShape.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h" +#include "DataFormats/Math/interface/Error.h" +#include "FWCore/Framework/interface/ProducesCollector.h" +#include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h" + +#include "SimCalorimetry/CaloSimAlgos/interface/CaloTDigitizer.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h" +#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" + + +#include + +typedef EcalTDigitizer_Ph2 EBDigitizer_Ph2 ; + + +class APDSimParameters ; +class EBHitResponse_Ph2 ; +class CaloHitResponse ; +class EcalSimParameterMap_Ph2 ; +class EcalCoder_Ph2 ; +class EcalElectronicsSim_Ph2 ; +class EcalBaseSignalGenerator; +class CaloGeometry ; +class EBDigiCollectionPh2 ; +class PileUpEventPrincipal ; + +namespace edm { + class ConsumesCollector; + class ProducerBase; + class Event; + class EventSetup; + template class Handle; + class ParameterSet; + class StreamID; +} + +namespace CLHEP { + class HepRandomEngine; +} + +class EcalDigiProducer_Ph2 : public DigiAccumulatorMixMod { + public: + + EcalDigiProducer_Ph2( const edm::ParameterSet& params , edm::ProducesCollector producesCollector, edm::ConsumesCollector& iC); + EcalDigiProducer_Ph2( const edm::ParameterSet& params , edm::ConsumesCollector& iC); + ~EcalDigiProducer_Ph2() override; + + void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override; + void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override; + void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) override; + void beginRun(edm::Run const& run, edm::EventSetup const& setup) override; + + void setEBNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator); + + private: + + virtual void cacheEBDigis( const EBDigiCollectionPh2* ebDigiPtr ) const { } + + typedef edm::Handle > HitsHandle; + void accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing); + + void checkGeometry(const edm::EventSetup& eventSetup) ; + + void updateGeometry() ; + + void checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup) ; + + APDShape m_APDShape ; + EBShape m_EBShape ; + + const std::string m_EBdigiCollection ; + const std::string m_hitsProducerTag ; + + bool m_useLCcorrection; + + const bool m_apdSeparateDigi ; + + const double m_EBs25notCont ; + + const unsigned int m_readoutFrameSize ; + protected: + std::unique_ptr m_ParameterMap ; + private: + const std::string m_apdDigiTag ; + std::unique_ptr m_apdParameters ; + + std::unique_ptr m_APDResponse ; + protected: + std::unique_ptr m_EBResponse ; + private: + + + const bool m_PreMix1 ; + const bool m_PreMix2 ; + + const bool m_doEB; + + + std::unique_ptr m_APDDigitizer ; + std::unique_ptr m_BarrelDigitizer ; + + std::unique_ptr m_ElectronicsSim ; + std::unique_ptr m_Coder ; + + std::unique_ptr m_APDElectronicsSim ; + std::unique_ptr m_APDCoder ; + + const CaloGeometry* m_Geometry ; + + std::array< std::unique_ptr >, 2 > m_EBCorrNoise ; + + CLHEP::HepRandomEngine* randomEngine_ = nullptr; +}; + +#endif diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h b/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h new file mode 100644 index 0000000000000..c32309b836371 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h @@ -0,0 +1,63 @@ +#ifndef SimCalorimetry_EcalSimProducers_EcalTimeDigiProducer_Ph2_h +#define SimCalorimetry_EcalSimProducers_EcalTimeDigiProducer_Ph2_h + + +#include "DataFormats/Math/interface/Error.h" + +#include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h" +#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" +#include "FWCore/Utilities/interface/EDGetToken.h" +#include "FWCore/Framework/interface/ProducesCollector.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" + +#include + +class ESDigitizer ; + +class CaloGeometry ; +class EcalSimParameterMap_Ph2 ; +class PileUpEventPrincipal ; +class EcalTimeMapDigitizer; + +namespace edm { + class Event; + class EventSetup; + template class Handle; + class ParameterSet; +} + +class EcalTimeDigiProducer_Ph2 : public DigiAccumulatorMixMod { + public: + + EcalTimeDigiProducer_Ph2( const edm::ParameterSet& params , edm::ProducesCollector, edm::ConsumesCollector&); + ~EcalTimeDigiProducer_Ph2() override; + + void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override; + void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override; + + private: + + typedef edm::Handle > HitsHandle; + void accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing); + + void checkGeometry(const edm::EventSetup& eventSetup) ; + + void updateGeometry() ; + + const std::string m_EBdigiCollection ; + const edm::InputTag m_hitsProducerTagEB ; + const edm::EDGetTokenT > m_hitsProducerTokenEB ; + + private: + int m_timeLayerEB; + const CaloGeometry* m_Geometry ; + + EcalTimeMapDigitizer* m_BarrelDigitizer; + +}; + +#endif diff --git a/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc b/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc new file mode 100644 index 0000000000000..a0d86602af74a --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc @@ -0,0 +1,60 @@ +#include +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/Framework/interface/ESProductHost.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h" +#include "CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h" +#include "CondFormats/EcalObjects/src/classes.h" +// +// class declaration +// +const int kEBChannels = 61200; + +class EcalCATIAGainRatiosESProducer : public edm::ESProducer { + +public: + + EcalCATIAGainRatiosESProducer(const edm::ParameterSet& iConfig); + + typedef std::shared_ptr ReturnType; + + ReturnType produce(const EcalCATIAGainRatiosRcd& iRecord); + + +private: + edm::ParameterSet pset_; +}; + +EcalCATIAGainRatiosESProducer::EcalCATIAGainRatiosESProducer(const edm::ParameterSet& iConfig) : + pset_(iConfig) { + //the following line is needed to tell the framework what + // data is being produced + //std::cout<<"*********Creating EcalCATIAGainRatiosESProducer"<(); + + //std::cout<<"**********Set EB Values "<setValue(myEBDetId.rawId(), val); + } + + //std::cout<size()< +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/Framework/interface/ESProductHost.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h" +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "CondFormats/EcalObjects/src/classes.h" +// +// class declaration +// +const int kEBChannels = 61200; + +class EcalLiteDTUPedestalsESProducer : public edm::ESProducer { + +public: + + EcalLiteDTUPedestalsESProducer(const edm::ParameterSet& iConfig); + + typedef std::shared_ptr ReturnType; + + ReturnType produce(const EcalLiteDTUPedestalsRcd& iRecord); + + +private: + edm::ParameterSet pset_; +}; + +EcalLiteDTUPedestalsESProducer::EcalLiteDTUPedestalsESProducer(const edm::ParameterSet& iConfig) : + pset_(iConfig) { + //the following line is needed to tell the framework what + // data is being produced + //std::cout<<"*********Creating EcalLiteDTUPedestalsESProducer"<(); + + //std::cout<<"**********Set EB Values "<insert(std::make_pair(myEBDetId,ped)); + } + + //std::cout<size()<(m_apdDigiTag); + + producesCollector.produces(m_EBdigiCollection); + +} + +// version for Pre-Mixing, for use outside of MixingModule +EcalDigiProducer_Ph2::EcalDigiProducer_Ph2( const edm::ParameterSet& params, edm::ConsumesCollector& iC) : + DigiAccumulatorMixMod(), + m_APDShape ( true ) , + m_EBShape ( true ) , + + m_EBdigiCollection ( params.getParameter("EBdigiCollectionPh2") ) , + + m_hitsProducerTag ( params.getParameter("hitsProducer" ) ) , + m_useLCcorrection ( params.getUntrackedParameter("UseLCcorrection") ) , + m_apdSeparateDigi ( params.getParameter ("apdSeparateDigi") ) , + + m_EBs25notCont ( params.getParameter ("EBs25notContainment") ) , + + + m_readoutFrameSize ( params.getParameter ("readoutFrameSize") ) , + m_ParameterMap ( new EcalSimParameterMap_Ph2( + params.getParameter ("simHitToPhotoelectronsBarrel") , + params.getParameter ("photoelectronsToAnalogBarrel") , + params.getParameter ("samplingFactor") , + params.getParameter ("timePhase") , + m_readoutFrameSize , + params.getParameter ("binOfMaximum") , + params.getParameter ("doPhotostatistics") , + params.getParameter ("syncPhase") ) ) , + + m_apdDigiTag ( params.getParameter ("apdDigiTag" ) ) , + m_apdParameters ( new APDSimParameters( + params.getParameter ("apdAddToBarrel" ) , + m_apdSeparateDigi , + params.getParameter ("apdSimToPELow" ) , + params.getParameter ("apdSimToPEHigh" ) , + params.getParameter ("apdTimeOffset" ) , + params.getParameter ("apdTimeOffWidth" ) , + params.getParameter ("apdDoPEStats" ) , + m_apdDigiTag , + params.getParameter > ( "apdNonlParms" ) ) ) , + + m_APDResponse ( !m_apdSeparateDigi ? nullptr : + new EBHitResponse_Ph2( m_ParameterMap.get() , + &m_EBShape , + true , + m_apdParameters.get() , + &m_APDShape ) ) , + + m_EBResponse ( new EBHitResponse_Ph2( m_ParameterMap.get() , + &m_EBShape , + false , // barrel + m_apdParameters.get() , + &m_APDShape ) ) , + + m_PreMix1 ( params.getParameter ("EcalPreMixStage1") ) , + m_PreMix2 ( params.getParameter ("EcalPreMixStage2") ) , + + + + m_doEB ( params.getParameter ("doEB" ) ) , + + + m_APDDigitizer ( nullptr ) , + m_BarrelDigitizer ( nullptr ) , + m_ElectronicsSim ( nullptr ) , + m_Coder ( nullptr ) , + m_APDElectronicsSim ( nullptr ) , + m_APDCoder ( nullptr ) , + m_Geometry ( nullptr ) , + m_EBCorrNoise ( { {nullptr, nullptr} } ) + +{ + //std::cout<<"[EcalDigiProducer_Ph2] Constructing producer"<< "frameSize: " << m_readoutFrameSize<< std::endl; + if ( m_doEB ) iC.consumes >(edm::InputTag(m_hitsProducerTag, "EcalHitsEB")); + + + const std::vector ebCorMatG10Ph2 = params.getParameter< std::vector >("EBCorrNoiseMatrixG10Ph2"); + const std::vector ebCorMatG01Ph2 = params.getParameter< std::vector >("EBCorrNoiseMatrixG01Ph2"); + + const bool applyConstantTerm = params.getParameter ("applyConstantTerm"); + const double rmsConstantTerm = params.getParameter ("ConstantTerm"); + + const bool addNoise = params.getParameter ("doENoise"); + const bool cosmicsPhase = params.getParameter ("cosmicsPhase"); + const double cosmicsShift = params.getParameter ("cosmicsShift"); + +//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + // further phase for cosmics studies + if( cosmicsPhase ) + { + if( m_doEB ) m_EBResponse->setPhaseShift( 1. + cosmicsShift ) ; + + } + + EcalCorrMatrix_Ph2 ebMatrix[ 2 ] ; + + + //std::cout<<"[EcalDigiProducer_Ph2] Check size10: "< fabs( ebCorMatG10Ph2[0] - 1.0 ) ) ; + assert( 1.e-7 > fabs( ebCorMatG01Ph2[0] - 1.0 ) ) ; + + //std::cout<<"[EcalDigiProducer_Ph2] Check row of cor and col mat"<= ebCorMatG10Ph2[row] ) ; + assert( 0 == row || 1. >= ebCorMatG01Ph2[row] ) ; + + // std::cout<<"row "<( ebMatrix[0] ) ); + m_EBCorrNoise[1].reset( new CorrelatedNoisifier( ebMatrix[1] ) ); + + + //std::cout<<"[EcalDigiProducer_Ph2] More reset"< rng; + randomEngine_ = &rng->getEngine(event.streamID()); + + checkGeometry( eventSetup ); + checkCalibrations( event, eventSetup ); + if( m_doEB ) { + m_BarrelDigitizer->initializeHits(); + if(m_apdSeparateDigi) { + m_APDDigitizer->initializeHits(); + } + } + +} + +void +EcalDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { + if(m_doEB && ebHandle.isValid()) { + m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_); + + if(m_apdSeparateDigi) { + m_APDDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_); + } + } +} + +void +EcalDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) { + // Step A: Get Inputs + edm::Handle > ebHandle; + if(m_doEB) { + m_EBShape.setEventSetup(eventSetup); // need to set the eventSetup here, otherwise pre-mixing module will not wrk + m_APDShape.setEventSetup(eventSetup); // + edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB"); + e.getByLabel(ebTag, ebHandle); + } + + accumulateCaloHits(ebHandle, 0); +} + +void +EcalDigiProducer_Ph2::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& eventSetup, edm::StreamID const& streamID) { + // Step A: Get Inputs + edm::Handle > ebHandle; + if(m_doEB) { + edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB"); + e.getByLabel(ebTag, ebHandle); + } + accumulateCaloHits(ebHandle, e.bunchCrossing()); +} + +void +EcalDigiProducer_Ph2::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) { + // Step B: Create empty output + std::unique_ptr apdResult ( !m_apdSeparateDigi || !m_doEB ? nullptr : + new EBDigiCollectionPh2() ) ; + std::unique_ptr barrelResult ( new EBDigiCollectionPh2() ) ; + + // run the algorithm + + if( m_doEB ) { + //std::cout << " EcalDigiProducer_Ph2 ::finalize, running digitizer " + //<< event.run() << " " << event.id() << std::endl; + + m_BarrelDigitizer->run( *barrelResult, randomEngine_ ) ; + cacheEBDigis( &*barrelResult ) ; + + + + edm::LogInfo("DigiInfo") << "EB Digis: " << barrelResult->size() ; + + if( m_apdSeparateDigi ) { + m_APDDigitizer->run( *apdResult, randomEngine_ ) ; + edm::LogInfo("DigiInfo") << "APD Digis: " << apdResult->size() ; + } + } + + // Step D: Put outputs into event + if( m_apdSeparateDigi ) { + //event.put(std::move(apdResult), m_apdDigiTag ) ; + } + + event.put(std::move(barrelResult), m_EBdigiCollection ) ; + + randomEngine_ = nullptr; // to prevent access outside event +} + +void +EcalDigiProducer_Ph2::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) +{ + edm::Service rng; + if ( ! rng.isAvailable() ) { + throw cms::Exception("Configuration") << + "RandomNumberGenerator service is not available.\n" + "You must add the service in the configuration file\n" + "or remove the module that requires it."; + } + CLHEP::HepRandomEngine* engine = &rng->getEngine(lumi.index()); + + if( m_doEB ) { + if( nullptr != m_APDResponse ) m_APDResponse->initialize(engine); + m_EBResponse->initialize(engine); + } +} + +void +EcalDigiProducer_Ph2::checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup ) +{ + // Pedestals from event setup + + edm::ESHandle dbPed ; + eventSetup.get().get( dbPed ) ; + const EcalLiteDTUPedestals* pedestals ( dbPed.product() ) ; + + m_Coder->setPedestals( pedestals ) ; + if( nullptr != m_APDCoder ) m_APDCoder->setPedestals( pedestals ) ; + + // Ecal Intercalibration Constants + edm::ESHandle pIcal ; + eventSetup.get().get( pIcal ) ; + const EcalIntercalibConstantsMC* ical ( pIcal.product() ) ; + + m_Coder->setIntercalibConstants( ical ) ; + if( nullptr != m_APDCoder) m_APDCoder->setIntercalibConstants( ical ) ; + + m_EBResponse->setIntercal( ical ) ; + if( nullptr != m_APDResponse ) m_APDResponse->setIntercal( ical ) ; + + // Ecal LaserCorrection Constants + edm::ESHandle laser; + eventSetup.get().get(laser); + const edm::TimeValue_t eventTimeValue = event.time().value(); + + m_EBResponse->setEventTime(eventTimeValue); + m_EBResponse->setLaserConstants(laser.product(), m_useLCcorrection); + + + // ADC -> GeV Scale + edm::ESHandle pAgc; + eventSetup.get().get(pAgc); + const EcalADCToGeVConstant* agc = pAgc.product(); + + // Gain Ratios + edm::ESHandle pRatio; + eventSetup.get().get(pRatio); + const EcalCATIAGainRatios* gr = pRatio.product(); + m_Coder->setGainRatios( gr ); + if( nullptr != m_APDCoder) m_APDCoder->setGainRatios( gr ); + + + + const double EBscale ( + ( agc->getEBValue())*ecalPh2::gains[1]*(m_Coder->MAXADC)*m_EBs25notCont ) ; + + LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEBValue() + << "\n" << " notCont = " << m_EBs25notCont + << "\n" << " saturation for EB = " << EBscale + << ", " << m_EBs25notCont ; + + + m_Coder->setFullScaleEnergy( EBscale ) ; + if( nullptr != m_APDCoder ) m_APDCoder->setFullScaleEnergy( EBscale ) ; + +} + +void +EcalDigiProducer_Ph2::checkGeometry( const edm::EventSetup & eventSetup ) +{ + // TODO find a way to avoid doing this every event + edm::ESHandle hGeometry ; + eventSetup.get().get( hGeometry ) ; + + const CaloGeometry* pGeometry = &*hGeometry; + + if( pGeometry != m_Geometry ) + { + m_Geometry = pGeometry; + updateGeometry(); + } +} + +void +EcalDigiProducer_Ph2::updateGeometry() +{ + if( m_doEB ) { + if( nullptr != m_APDResponse ) m_APDResponse->setGeometry( + m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ; + m_EBResponse->setGeometry( + m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ; + } + } + +void EcalDigiProducer_Ph2::setEBNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator) { + //noiseGenerator->setParameterMap(theParameterMap); + if(nullptr != m_BarrelDigitizer) m_BarrelDigitizer->setNoiseSignalGenerator(noiseGenerator); +} + + +void EcalDigiProducer_Ph2::beginRun(edm::Run const& run, edm::EventSetup const& setup) { + m_EBShape.setEventSetup(setup); + m_APDShape.setEventSetup(setup); +} diff --git a/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc b/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc new file mode 100644 index 0000000000000..e5cb363e1eae7 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc @@ -0,0 +1,135 @@ +#include "FWCore/Framework/interface/Event.h" +#include "SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalTimeMapDigitizer.h" + +#include "CalibFormats/CaloObjects/interface/CaloSamples.h" + +#include "Geometry/CaloGeometry/interface/CaloGeometry.h" +#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" +#include "Geometry/Records/interface/CaloGeometryRecord.h" +#include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h" + +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/Common/interface/Handle.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h" + + +//#define ecal_time_debug 1 + +EcalTimeDigiProducer_Ph2::EcalTimeDigiProducer_Ph2( const edm::ParameterSet& params, edm::ProducesCollector producesCollector, edm::ConsumesCollector& sumes) : + DigiAccumulatorMixMod(), + m_EBdigiCollection ( params.getParameter("EBtimeDigiCollection") ) , + m_hitsProducerTagEB ( params.getParameter("hitsProducerEB" ) ) , + m_hitsProducerTokenEB ( sumes.consumes >( m_hitsProducerTagEB) ) , + m_timeLayerEB ( params.getParameter ("timeLayerBarrel") ), + m_Geometry ( nullptr ) +{ + producesCollector.produces(m_EBdigiCollection); + + m_BarrelDigitizer = new EcalTimeMapDigitizer(EcalBarrel); + +#ifdef ecal_time_debug + std::cout << "[EcalTimeDigiProducer_Ph2]::Create EB " << m_EBdigiCollection << " collection and digitizer" << std::endl; +#endif + + m_BarrelDigitizer->setTimeLayerId(m_timeLayerEB); + +} + +EcalTimeDigiProducer_Ph2::~EcalTimeDigiProducer_Ph2() +{ +} + +void +EcalTimeDigiProducer_Ph2::initializeEvent(edm::Event const& event, edm::EventSetup const& eventSetup) { + checkGeometry( eventSetup ); + // checkCalibrations( event, eventSetup ); + // here the methods to clean the maps + m_BarrelDigitizer->initializeMap(); + +} + +void +EcalTimeDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { + // accumulate the simHits and do the averages in a given layer per bunch crossing + if(ebHandle.isValid()) { + m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing); + } + +} + +void +EcalTimeDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) { + // Step A: Get Inputs + edm::Handle > ebHandle; + e.getByToken(m_hitsProducerTokenEB, ebHandle); + +#ifdef ecal_time_debug + std::cout << "[EcalTimeDigiProducer_Ph2]::Accumulate Hits HS event" << std::endl; +#endif + + accumulateCaloHits(ebHandle, 0); +} + +void +EcalTimeDigiProducer_Ph2::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& eventSetup, edm::StreamID const&) { + edm::Handle > ebHandle; + e.getByLabel(m_hitsProducerTagEB, ebHandle); + + +#ifdef ecal_time_debug + std::cout << "[EcalTimeDigiProducer_Ph2]::Accumulate Hits for BC " << e.bunchCrossing() << std::endl; +#endif + accumulateCaloHits(ebHandle, e.bunchCrossing()); +} + +void +EcalTimeDigiProducer_Ph2::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) { + std::unique_ptr barrelResult ( new EcalTimeDigiCollection() ) ; + +#ifdef ecal_time_debug + std::cout << "[EcalTimeDigiProducer_Ph2]::finalizeEvent" << std::endl; +#endif + + // here basically just put everything in the final collections + m_BarrelDigitizer->run( *barrelResult ) ; + +#ifdef ecal_time_debug + std::cout << "[EcalTimeDigiProducer_Ph2]::EB Digi size " << barrelResult->size() << std::endl; +#endif + + edm::LogInfo("TimeDigiInfo") << "EB time Digis: " << barrelResult->size() ; + +#ifdef ecal_time_debug + std::cout << "[EcalTimeDigiProducer_Ph2]::putting collections into the event " << std::endl; +#endif + + event.put( std::move(barrelResult), m_EBdigiCollection ) ; +} + +void +EcalTimeDigiProducer_Ph2::checkGeometry( const edm::EventSetup & eventSetup ) +{ + // TODO find a way to avoid doing this every event + edm::ESHandle hGeometry ; + eventSetup.get().get( hGeometry ) ; + + const CaloGeometry* pGeometry = &*hGeometry; + + if( pGeometry != m_Geometry ) + { + m_Geometry = pGeometry; + updateGeometry(); + } +} + +void +EcalTimeDigiProducer_Ph2::updateGeometry() +{ + m_BarrelDigitizer->setGeometry( + m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ;} diff --git a/SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_Ph1.py b/SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_Ph1.py new file mode 100644 index 0000000000000..3328646be4c20 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_Ph1.py @@ -0,0 +1,168 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: SingleElectronPt10_pythia8_cfi.py -s GEN,SIM,DIGI --conditions auto:mc --datatier GEN-SIM-RAW --eventcontent RECOSIM -n 10 --no_exec --python_filename SingleElectronPt10_cfi_py_GEN_IDEAL.py +import FWCore.ParameterSet.Config as cms + +from Configuration.StandardSequences.Eras import eras + +process = cms.Process('DIGI')#,eras.phase2_common) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.Geometry.GeometrySimDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('Configuration.StandardSequences.Generator_cff') +process.load('IOMC.EventVertexGenerators.VtxSmearedRealistic50ns13TeVCollision_cfi') +process.load('GeneratorInterface.Core.genFilterSummary_cff') +process.load('Configuration.StandardSequences.SimIdeal_cff') +process.load('Configuration.StandardSequences.Digi_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) +) + +# Input source +process.source = cms.Source("EmptySource") + +process.options = cms.untracked.PSet( + SkipEvent = cms.untracked.vstring('ProductNotFound') +) + + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('SingleElectronPt10_pythia8_cfi.py nevts:10'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.RECOSIMoutput = cms.OutputModule("PoolOutputModule", + SelectEvents = cms.untracked.PSet( + SelectEvents = cms.vstring('generation_step') + ), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('GEN-SIM-RAW'), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('SingleElectronPt10_pythia8_cfi_py_GEN_SIM_DIGI_Pt10_Ph1.root'), +# outputCommands = process.RECOSIMEventContent.outputCommands, + outputCommands = cms.untracked.vstring('keep *', + 'drop *_mix_*_*'), + splitLevel = cms.untracked.int32(1) +) + +#process.RECOSIMoutput.outputCommands.append('keep EBDigiCollection_ecalDigis_*_*') + + + +# Additional output definition + + +# Other statements +process.genstepfilter.triggerConditions=cms.vstring("generation_step") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:mc', '') + +process.generator = cms.EDFilter("Pythia8PtGun", + PGunParameters = cms.PSet( + AddAntiParticle = cms.bool(True), + MaxEta = cms.double(1.43), + MaxPhi = cms.double(3.14159265359), + #MaxPt = cms.double(300.01), + MaxPt = cms.double(1110.01), + MinEta = cms.double(1.42), + MinPhi = cms.double(-3.14159265359), + #MinPt = cms.double(299.99), + MinPt = cms.double(1109.99), + ParticleID = cms.vint32(11) + ), + PythiaParameters = cms.PSet( + parameterSets = cms.vstring() + ), + Verbosity = cms.untracked.int32(0), + firstRun = cms.untracked.uint32(1), + psethack = cms.string('single electron pt 10') +) + + +# Path and EndPath definitions +process.generation_step = cms.Path(process.pgen) +process.simulation_step = cms.Path(process.psim) +process.digitisation_step = cms.Path(process.pdigi) +process.genfiltersummary_step = cms.EndPath(process.genFilterSummary) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.RECOSIMoutput_step = cms.EndPath(process.RECOSIMoutput) + + + +##CondCore.CondDB.CondDB_cfi +#from CondCore.DBCommon.CondDBSetup_cfi import * +##from CondCore.CondDB.CondDB_cfi import * +#process.ecalConditions = cms.ESSource("PoolDBESSource", CondDBSetup, +# connect = cms.string('frontier://FrontierProd/CMS_COND_31X_ECAL'), +# #connect = cms.string('oracle://cms_orcoff_prep/CMS_COND_ECAL'), +# #authpath = cms.string('/afs/cern.ch/cms/DB/conddb'), +# connect = cms.string('sqlite_file:/afs/cern.ch/user/d/dsoldi/work/CMS/CMSEcal_Phase2_Ultimate/CMSSW_10_6_1/src/SimCalorimetry/EcalSimProducers/test/simPulseShapePhaseII.db'), +# +# toGet = cms.VPSet( # overide Global Tag use EcalTBWeights_EBEE_offline +# cms.PSet( +# record = cms.string('EcalSimPulseShapeRcd') , +# tag = cms.string('EcalSimPulseShape_default_mc') +# ) +# ) +#) +#process.es_prefer_ecalPulseShape = cms.ESPrefer("PoolDBESSource","ecalConditions") +# +#process.EcalCATIAGainRatiosESProducer = cms.ESProducer( +# "EcalCATIAGainRatiosESProducer", +# ComponentName = cms.string('testGainProducer') +#) +# +#process.EcalLiteDTUPedestalsESProducer = cms.ESProducer( +# "EcalLiteDTUPedestalsESProducer", +# ComponentName = cms.string('testPedestalProducer') +#) + +#LOGGER: +process.MessageLogger.cout = cms.untracked.PSet( + threshold = cms.untracked.string("DEBUG"), + default = cms.untracked.PSet( limit = cms.untracked.int32(0) ), + FwkReport = cms.untracked.PSet( limit = cms.untracked.int32(-1) ), +) + + +#process.es_prefer_EcalCATIAGainRatioESProducer = cms.ESPrefer("EcalCATIAGainRatioESProducer","EcalCATIAGainRatioESProducer") + +# Schedule definition +process.schedule = cms.Schedule(process.generation_step,process.genfiltersummary_step,process.simulation_step,process.digitisation_step,process.endjob_step,process.RECOSIMoutput_step) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) +# filter all path with the production filter sequence +for path in process.paths: + getattr(process,path)._seq = process.generator * getattr(process,path)._seq + + +# Customisation from command line + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion + + + + + + + diff --git a/SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_newshape.py b/SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_newshape.py new file mode 100644 index 0000000000000..685e978c6e3aa --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/test/SingleElectron_cfi_py_GEN_IDEAL_withECALDigi_newshape.py @@ -0,0 +1,171 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: SingleElectronPt10_pythia8_cfi.py -s GEN,SIM,DIGI --conditions auto:mc --datatier GEN-SIM-RAW --eventcontent RECOSIM -n 10 --no_exec --python_filename SingleElectronPt10_cfi_py_GEN_IDEAL.py +import FWCore.ParameterSet.Config as cms + +from Configuration.StandardSequences.Eras import eras + +process = cms.Process('DIGI',eras.phase2_common) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('SimCalorimetry.EcalSimProducers.esCATIAGainProducer_cfi') +process.load('SimCalorimetry.EcalSimProducers.esEcalLiteDTUPedestalsProducer_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_Ph2_cfi') +process.load('Configuration.StandardSequences.GeometryRecoDB_cff') +process.load('Configuration.Geometry.GeometrySimDB_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('Configuration.StandardSequences.Generator_cff') +process.load('IOMC.EventVertexGenerators.VtxSmearedRealistic50ns13TeVCollision_cfi') +process.load('Calibration.EcalCalibAlgos.ecalPedestalPCLHarvester_cfi') +process.load('GeneratorInterface.Core.genFilterSummary_cff') +process.load('Configuration.StandardSequences.SimIdeal_cff') +process.load('Configuration.StandardSequences.Digi_Ph2_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(3) +) + +# Input source +process.source = cms.Source("EmptySource") + +process.options = cms.untracked.PSet( + SkipEvent = cms.untracked.vstring('ProductNotFound') +) + + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('SingleElectronPt10_pythia8_cfi.py nevts:10'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.RECOSIMoutput = cms.OutputModule("PoolOutputModule", + SelectEvents = cms.untracked.PSet( + SelectEvents = cms.vstring('generation_step') + ), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('GEN-SIM-RAW'), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('SingleElectronPt10_pythia8_cfi_py_GEN_SIM_DIGI_Pt10.root'), +# outputCommands = process.RECOSIMEventContent.outputCommands, + outputCommands = cms.untracked.vstring('keep *', + 'drop *_mix_*_*'), + splitLevel = cms.untracked.int32(1) +) + +#process.RECOSIMoutput.outputCommands.append('keep EBDigiCollection_ecalDigis_*_*') + + + +# Additional output definition + + +# Other statements +process.genstepfilter.triggerConditions=cms.vstring("generation_step") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:mc', '') + +process.generator = cms.EDFilter("Pythia8PtGun", + PGunParameters = cms.PSet( + AddAntiParticle = cms.bool(True), + MaxEta = cms.double(1.43), + MaxPhi = cms.double(3.14159265359), + #MaxPt = cms.double(300.01), + MaxPt = cms.double(10.01), + MinEta = cms.double(1.42), + MinPhi = cms.double(-3.14159265359), + #MinPt = cms.double(299.99), + MinPt = cms.double(9.99), + ParticleID = cms.vint32(11) + ), + PythiaParameters = cms.PSet( + parameterSets = cms.vstring() + ), + Verbosity = cms.untracked.int32(0), + firstRun = cms.untracked.uint32(1), + psethack = cms.string('single electron pt 10') +) + + +# Path and EndPath definitions +process.generation_step = cms.Path(process.pgen) +process.simulation_step = cms.Path(process.psim) +process.digitisation_step = cms.Path(process.pdigi) +process.genfiltersummary_step = cms.EndPath(process.genFilterSummary) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.RECOSIMoutput_step = cms.EndPath(process.RECOSIMoutput) + + + +#CondCore.CondDB.CondDB_cfi +from CondCore.DBCommon.CondDBSetup_cfi import * +#from CondCore.CondDB.CondDB_cfi import * +process.ecalConditions = cms.ESSource("PoolDBESSource", CondDBSetup, + #connect = cms.string('frontier://FrontierProd/CMS_COND_31X_ECAL'), + #connect = cms.string('oracle://cms_orcoff_prep/CMS_COND_ECAL'), + #authpath = cms.string('/afs/cern.ch/cms/DB/conddb'), + connect = cms.string('sqlite_file:simPulseShapePhaseII.db'), + + toGet = cms.VPSet( # overide Global Tag use EcalTBWeights_EBEE_offline + cms.PSet( + record = cms.string('EcalSimPulseShapeRcd') , + tag = cms.string('EcalSimPulseShape_default_mc') + ) + ) +) +process.es_prefer_ecalPulseShape = cms.ESPrefer("PoolDBESSource","ecalConditions") + +process.EcalCATIAGainRatiosESProducer = cms.ESProducer( + "EcalCATIAGainRatiosESProducer", + ComponentName = cms.string('testGainProducer') +) + +process.EcalLiteDTUPedestalsESProducer = cms.ESProducer( + "EcalLiteDTUPedestalsESProducer", + ComponentName = cms.string('testPedestalProducer') +) + +#LOGGER: +process.MessageLogger.cout = cms.untracked.PSet( + threshold = cms.untracked.string("DEBUG"), + default = cms.untracked.PSet( limit = cms.untracked.int32(0) ), + FwkReport = cms.untracked.PSet( limit = cms.untracked.int32(-1) ), +) + + +#process.es_prefer_EcalCATIAGainRatioESProducer = cms.ESPrefer("EcalCATIAGainRatioESProducer","EcalCATIAGainRatioESProducer") + +# Schedule definition +process.schedule = cms.Schedule(process.generation_step,process.genfiltersummary_step,process.simulation_step,process.digitisation_step,process.endjob_step,process.RECOSIMoutput_step) +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) +# filter all path with the production filter sequence +for path in process.paths: + getattr(process,path)._seq = process.generator * getattr(process,path)._seq + + +# Customisation from command line + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion + + + + + + + diff --git a/SimCalorimetry/EcalSimProducers/test/simPulseShapePhaseII.db b/SimCalorimetry/EcalSimProducers/test/simPulseShapePhaseII.db new file mode 100644 index 0000000000000000000000000000000000000000..cb5f462c0aa47f8a5869e3098a5a8b5f05e59ed6 GIT binary patch literal 98304 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 literal 0 HcmV?d00001 diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/BuildFile.xml b/SimCalorimetry/PhaseIAnalyzer/plugins/BuildFile.xml new file mode 100644 index 0000000000000..07215bd4b10a5 --- /dev/null +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/BuildFile.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc new file mode 100644 index 0000000000000..d747f37cd7049 --- /dev/null +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc @@ -0,0 +1,313 @@ +// -*- C++ -*- +// +// Package: PhaseI/PhaseIAnalyzer +// Class: PhaseIAnalyzer +// +/**\class PhaseIAnalyzer PhaseIAnalyzer.cc PhaseI/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Dario Soldi +// Created: Tue, 16 Jan 2018 11:56:05 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/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +//My includes +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" +#include "CondFormats/EcalObjects/interface/EcalPedestals.h" +#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h" +#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsMCRcd.h" +#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" + +#include "PhaseIAnalyzer.h" + +#include "DataFormats/EcalDetId/interface/EBDetId.h" +#include "DataFormats/EcalDetId/interface/EEDetId.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" + +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "SimDataFormats/Track/interface/SimTrack.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +using namespace std; +using namespace edm; + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) +{ +//now do what ever initialization is needed +usesResource("TFileService"); + + digiTagEB_= iConfig.getParameter("BarrelDigis"); + + digiTokenEB_ = consumes(digiTagEB_); + + //Files: + edm::Service fs; + //Histograms + + for(int isample=0;isample<16;isample++) { + EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC",isample), 950 , 100 , 2000 ); + EBGainHisto[isample] = fs->make(Form("GainEB_%d", isample), Form("Gain Barrel sample %d;Gain",isample) , 5 , 0 , 4 ); + } + SingleChannelE = fs->make("SingleChannelE", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); + SingleChannelELow = fs->make("SingleChannelELow", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); + + Char_t histo[200]; + + sprintf (histo, "EcalDigiTaskBarrelOccupancy" ) ; + meEBDigiOccupancy_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelOccupancyHigh" ) ; + meEBDigiOccupancyHigh_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelOccupancyLow" ) ; + meEBDigiOccupancyLow_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelOccupancyMid" ) ; + meEBDigiOccupancyMid_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelDigisMultiplicity" ) ; + meEBDigiMultiplicity_ = fs->make(histo, histo, 612, 0., 61200); + + + for (int i = 0; i < ecalPh2::sampleSize ; i++ ) { + + sprintf (histo, "EcalDigiTaskBarrelAnalogPulse%02d", i+1) ; + meEBDigiADCAnalog_[i] = fs->make(histo, histo, 4000, 0., 400.); + + sprintf (histo, "EcalDigiTaskBarrelADCPulse%02dGain0_Saturated", i+1) ; + meEBDigiADCgS_[i] = fs->make(histo, histo, 4096, -0.5, 4095.5); + sprintf (histo, "EcalDigiTaskBarrelGainPulse%02d", i+1) ; + meEBDigiGain_[i] = fs->make(histo, histo, 4, 0, 4); + + } + + sprintf (histo, "EcalDigiTaskBarrelPedestalForPreSample" ) ; + meEBPedestal_ = fs->make(histo, histo, 4096, -0.5, 4095.5) ; + + sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt100ADC" ) ; + meEBMaximumgt100ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + + sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt10ADC" ) ; + meEBMaximumgt10ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + + // sprintf (histo, "EcalDigiTask Barrel ADC counts after gain switch" ) ; + //meEBnADCafterSwitch_ = fs->makehisto, histo, 10, 0., 10.) ; + + + +} + + +PhaseIAnalyzer::~PhaseIAnalyzer() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + + //LogInfo("PhaseI") << "new event "; + + Handle pDigiEB; + iEvent.getByToken(digiTokenEB_,pDigiEB); + + // edm::ESHandle ical; + // iSetup.get().get(ical); + // const EcalIntercalibConstantsMC* ical_map = ical.product(); + // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); + // cout << "intercalib: " << (*itical) << endl; + + const int MAXSAMPLES=ecalPh1::sampleSize; + + std::vector ebAnalogSignal ; + std::vector ebADCCounts ; + std::vector ebADCGains_temp ; + std::vector ebADCGains ; + + + ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES); + ebADCCounts.reserve(EBDataFrame::MAXSAMPLES); + ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); + ebADCGains.reserve(EBDataFrame::MAXSAMPLES); + + //Take Pedestals: + // edm::ESHandle peds; + // iSetup.get().get(peds); + // const EcalLiteDTUPedestals* myped = peds.product(); + // int cnt=0; + // for( EcalLiteDTUPedestals::const_iterator it = myped->barrelItems().begin(); it != myped->barrelItems().end(); ++it) + // { + // std::cout << "EcalPedestal: " << " BARREL " << cnt << " " + // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); + // std::cout << std::endl; + // ++cnt; + // } + + int nDigis=0; + int LowGain(0),MidGain(0),HighGain(0); + int maxADCValue=0; + + for (EBDigiCollection::const_iterator pDigi=pDigiEB->begin(); pDigi!=pDigiEB->end(); ++pDigi) + { + LowGain=0; + MidGain=0; + HighGain=0; + maxADCValue=0; + + EBDataFrame digi( *pDigi ); + int nrSamples = digi.size(); + cout<<"NSamples found: "<>12; + ebAnalogSignal[sample] = (ebADCCounts[sample]*gainConv_[(int)ebADCGains[sample]]*barrelADCtoGeV_); + + if(ebADCCounts[sample] > maxADCValue) maxADCValue = ebADCCounts[sample]; + + if( ebid.iphi()==333 and ebid.ieta()==83) SingleChannelE -> SetBinContent(sample,ebADCCounts[sample]); + + if( ebid.iphi()==334 and ebid.ieta()==83) { + SingleChannelELow -> SetBinContent(sample,ebADCCounts[sample]); + } + + if( ebADCGains[sample]==3) LowGain=1; + if( ebADCGains[sample]==2) MidGain=1; + if( ebADCGains[sample]==1) HighGain=1; + + + if(ebADCCounts[sample]>250) { + cout<<"Channel: "< 250) { + meEBDigiOccupancy_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + if(HighGain==1) meEBDigiOccupancyHigh_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + if(MidGain==1) meEBDigiOccupancyMid_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + if(LowGain==1) meEBDigiOccupancyLow_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + + } + + }//end digi + + +} + + +// ------------ method called once each job just before starting event loop ------------ +void +PhaseIAnalyzer::beginJob() +{ +} + +// ------------ method called once each job just after ending the event loop ------------ +void +PhaseIAnalyzer::endJob() +{ +} + + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +void +PhaseIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descriptions.addDefault(desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(PhaseIAnalyzer); diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h new file mode 100644 index 0000000000000..f8f332cc4e9a4 --- /dev/null +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h @@ -0,0 +1,85 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" +#include "TH1.h" +#include "TH2.h" +#include "SimDataFormats/Track/interface/SimTrack.h" +#include +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +using namespace std; +// +// class declaration +// + +class PhaseIAnalyzer : public edm::one::EDAnalyzer { + public: + explicit PhaseIAnalyzer(const edm::ParameterSet&); + ~PhaseIAnalyzer(); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + + private: + virtual void beginJob() ; + void analyze(const edm::Event&, const edm::EventSetup&) override ; + virtual void endJob() ; + + edm::InputTag digiTagEB_; + + edm::EDGetTokenT digiTokenEB_; + + + edm::InputTag hitTagEB_; + + + edm::EDGetTokenT> hitTokenEB_; + + + edm::InputTag trackTag_; + edm::EDGetTokenT> trackToken_; + + //Histograms + TH1I *EBEnergyHisto[ecalPh2::sampleSize]; +TH1I *EBGainHisto[ecalPh2::sampleSize]; + + + TH2D* meEBDigiOccupancy_; + TH2D* meEBDigiOccupancyHigh_; + TH2D* meEBDigiOccupancyMid_; + TH2D* meEBDigiOccupancyLow_; + + TH1D* meEBDigiMultiplicity_; + + TH1D* meEBDigiADCGlobal_; + + TH1I* SingleChannelE; + TH1I* SingleChannelELow; + + TH1D* meEBDigiADCAnalog_[ecalPh2::sampleSize]; + TH1D* meEBDigiADCgS_[ecalPh2::sampleSize]; + TH1D* meEBDigiGain_[ecalPh2::sampleSize]; + + + TH1D* meEBPedestal_; + +TH1D* meEBMaximumgt100ADC_; + + TH1D* meEBMaximumgt10ADC_; + + TH1D* meEBnADCafterSwitch_; + + + + + + + + + + +}; diff --git a/SimCalorimetry/PhaseIAnalyzer/python/CfiFile_cfi.py b/SimCalorimetry/PhaseIAnalyzer/python/CfiFile_cfi.py new file mode 100644 index 0000000000000..be67c535ef270 --- /dev/null +++ b/SimCalorimetry/PhaseIAnalyzer/python/CfiFile_cfi.py @@ -0,0 +1,5 @@ +import FWCore.ParameterSet.Config as cms + +phaseI = cms.EDAnalyzer('PhaseIAnalyzer', + BarrelDigis=cms.InputTag('simEcalUnsuppressedDigis','','DIGI') +) diff --git a/SimCalorimetry/PhaseIAnalyzer/python/ConfFile_cfg.py b/SimCalorimetry/PhaseIAnalyzer/python/ConfFile_cfg.py new file mode 100644 index 0000000000000..bc2cfc24e21f7 --- /dev/null +++ b/SimCalorimetry/PhaseIAnalyzer/python/ConfFile_cfg.py @@ -0,0 +1,33 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("PhaseI") + +#Print out: +process.load("FWCore.MessageLogger.MessageLogger_cfi") +process.MessageLogger.cerr.threshold = 'INFO' +process.MessageLogger.categories.append('PhaseIAnalyzer') +process.MessageLogger.cerr.INFO = cms.untracked.PSet( + limit = cms.untracked.int32(-1) +) +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + + + +#Max event +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +#input: +process.source = cms.Source("PoolSource", + + fileNames = cms.untracked.vstring('file:../../../SimCalorimetry/EcalSimProducers/test/SingleElectronPt10_pythia8_cfi_py_GEN_SIM_DIGI_Pt10_Ph1.root'), + + ) + +process.phaseI = cms.EDAnalyzer('PhaseIAnalyzer') +process.TFileService = cms.Service("TFileService", + fileName = cms.string('Digitizer1.root') + ) +process.load("SimCalorimetry.PhaseIAnalyzer.CfiFile_cfi") + +#Running process: +process.p = cms.Path(process.phaseI) diff --git a/SimCalorimetry/PhaseIAnalyzer/python/Digitizer1.root b/SimCalorimetry/PhaseIAnalyzer/python/Digitizer1.root new file mode 100644 index 0000000000000000000000000000000000000000..8b7745bde7fa1015778089c7fc8680ca1fb9428d GIT binary patch literal 57745 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 HbP59iSXgH> literal 0 HcmV?d00001 diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/BuildFile.xml b/SimCalorimetry/PhaseIIAnalyzer/plugins/BuildFile.xml new file mode 100644 index 0000000000000..07215bd4b10a5 --- /dev/null +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/BuildFile.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc new file mode 100644 index 0000000000000..b0e1116fe4a95 --- /dev/null +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -0,0 +1,307 @@ +// -*- C++ -*- +// +// Package: PhaseII/PhaseIIAnalyzer +// Class: PhaseIIAnalyzer +// +/**\class PhaseIIAnalyzer PhaseIIAnalyzer.cc PhaseII/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Dario Soldi +// Created: Tue, 16 Jan 2018 11:56:05 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/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +//My includes +#include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" +#include "CondFormats/EcalObjects/interface/EcalPedestals.h" +#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h" +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h" +#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsMCRcd.h" +#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" + +#include "PhaseIIAnalyzer.h" + +#include "DataFormats/EcalDetId/interface/EBDetId.h" +#include "DataFormats/EcalDetId/interface/EEDetId.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" + +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "SimDataFormats/Track/interface/SimTrack.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +using namespace std; +using namespace edm; + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) +{ + //now do what ever initialization is needed + usesResource("TFileService"); + + digiTagEB_= iConfig.getParameter("BarrelDigis"); + + digiTokenEB_ = consumes(digiTagEB_); + + //Files: + edm::Service fs; + //Histograms + + for(int isample=0;isample<16;isample++) { + EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC",isample), 950 , 100 , 2000 ); + EBGainHisto[isample] = fs->make(Form("GainEB_%d", isample), Form("Gain Barrel sample %d;Gain",isample) , 5 , 0 , 4 ); + } + + SingleChannelE = fs->make("SingleChannelE", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); + SingleChannelELow = fs->make("SingleChannelELow", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); + + Char_t histo[200]; + + sprintf (histo, "EcalDigiTaskBarrelOccupancy" ) ; + meEBDigiOccupancy_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelOccupancyHigh" ) ; + meEBDigiOccupancyHigh_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelOccupancyLow" ) ; + meEBDigiOccupancyLow_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); + + sprintf (histo, "EcalDigiTaskBarrelDigisMultiplicity" ) ; + meEBDigiMultiplicity_ = fs->make(histo, histo, 612, 0., 61200); + + + for (int i = 0; i < ecalPh2::sampleSize ; i++ ) { + + sprintf (histo, "EcalDigiTaskBarrelAnalogPulse%02d", i+1) ; + meEBDigiADCAnalog_[i] = fs->make(histo, histo, 4000, 0., 400.); + + sprintf (histo, "EcalDigiTaskBarrelADCPulse%02dGain0_Saturated", i+1) ; + meEBDigiADCgS_[i] = fs->make(histo, histo, 4096, -0.5, 4095.5); + sprintf (histo, "EcalDigiTaskBarrelGainPulse%02d", i+1) ; + meEBDigiGain_[i] = fs->make(histo, histo, 4, 0, 4); + + } + + sprintf (histo, "EcalDigiTaskBarrelPedestalForPreSample" ) ; + meEBPedestal_ = fs->make(histo, histo, 4096, -0.5, 4095.5) ; + + sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt100ADC" ) ; + meEBMaximumgt100ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + + sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt10ADC" ) ; + meEBMaximumgt10ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + + // sprintf (histo, "EcalDigiTask Barrel ADC counts after gain switch" ) ; + //meEBnADCafterSwitch_ = fs->makehisto, histo, 10, 0., 10.) ; + + +} + + +PhaseIIAnalyzer::~PhaseIIAnalyzer() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + + //LogInfo("PhaseII") << "new event "; + + Handle pDigiEB; + iEvent.getByToken(digiTokenEB_,pDigiEB); + + // edm::ESHandle ical; + // iSetup.get().get(ical); + // const EcalIntercalibConstantsMC* ical_map = ical.product(); + // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); + // cout << "intercalib: " << (*itical) << endl; + + const int MAXSAMPLES=ecalPh2::sampleSize; + + std::vector ebAnalogSignal ; + std::vector ebADCCounts ; + std::vector ebADCGains_temp ; + std::vector ebADCGains ; + + + ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES); + ebADCCounts.reserve(EBDataFrame::MAXSAMPLES); + ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); + ebADCGains.reserve(EBDataFrame::MAXSAMPLES); + + //Take Pedestals: + // edm::ESHandle peds; + // iSetup.get().get(peds); + // const EcalLiteDTUPedestals* myped = peds.product(); + // int cnt=0; + // for( EcalLiteDTUPedestals::const_iterator it = myped->barrelItems().begin(); it != myped->barrelItems().end(); ++it) + // { + // std::cout << "EcalPedestal: " << " BARREL " << cnt << " " + // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); + // std::cout << std::endl; + // ++cnt; + // } + + int nDigis=0; + int maxADCValue=0; + int LowGain=0; + for (EBDigiCollectionPh2::const_iterator pDigi=pDigiEB->begin(); pDigi!=pDigiEB->end(); ++pDigi) + { + maxADCValue=0; + LowGain=1; + + EBDataFrame digi( *pDigi ); + int nrSamples = digi.size(); + EBDetId ebid = digi.id () ; + nDigis++; + + edm::ESHandle peds; + iSetup.get().get(peds); + const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); + // EcalLiteDTUPedestalsMap::const_iterator itped = DTUpeds_map->getMap().find(ebid); + // cout << "mean dei piedistalli: " << (*itped).mean(0) << " rms: " << (*itped).rms(0) << endl; + + double Emax = 0. ; + int Pmax = 0 ; + double pedestalPreSample = 0.; + double pedestalPreSampleAnalog = 0.; + int countsAfterGainSwitch = -1; + double higherGain = 1.; + + + for (int sample = 0 ; sample < nrSamples; ++sample) + { + ebAnalogSignal[sample] = 0.; + ebADCCounts[sample] = 0.; + ebADCGains_temp[sample] = 0.; + ebADCGains[sample] = 0.; + } + + double gainConv_[2]={10,1}; + // saturated channels + double barrelADCtoGeV_ = 0.048; //GeV + + // EcalIntercalibConstantsMC* ical = + + // EcalIntercalibConstantMCMap &icalMap = + + for (int sample = 0 ; sample < nrSamples; ++sample) + { + + int thisSample = digi[sample]; + + ebADCCounts[sample] = (thisSample&0xFFF); + ebADCGains[sample] = (thisSample&(0x3<<12))>>12; + ebAnalogSignal[sample] = (ebADCCounts[sample]*gainConv_[(int)ebADCGains[sample]]*barrelADCtoGeV_); + + if(ebADCCounts[sample] > maxADCValue) maxADCValue = ebADCCounts[sample]; + + if( ebADCGains[sample]==0) LowGain=1; + else LowGain=0; + + if( ebid.iphi()==333 and ebid.ieta()==83) { + SingleChannelE -> SetBinContent(sample,ebADCCounts[sample]); + } + if( ebid.iphi()==334 and ebid.ieta()==83) { + SingleChannelELow -> SetBinContent(sample,ebADCCounts[sample]); + } + if(ebADCCounts[sample]>40) { + cout<<"Channel: "< 27.5) { + meEBDigiOccupancy_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + if(LowGain==0) meEBDigiOccupancyHigh_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + else meEBDigiOccupancyLow_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + + } + + if(0==1)cout<<"P max "< +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +using namespace std; +// +// class declaration +// + +class PhaseIIAnalyzer : public edm::one::EDAnalyzer { + public: + explicit PhaseIIAnalyzer(const edm::ParameterSet&); + ~PhaseIIAnalyzer(); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + + private: + virtual void beginJob() ; + void analyze(const edm::Event&, const edm::EventSetup&) override ; + virtual void endJob() ; + + edm::InputTag digiTagEB_; + + edm::EDGetTokenT digiTokenEB_; + + + edm::InputTag hitTagEB_; + + + edm::EDGetTokenT> hitTokenEB_; + + + edm::InputTag trackTag_; + edm::EDGetTokenT> trackToken_; + + //Histograms + TH1I *EBEnergyHisto[ecalPh2::sampleSize]; +TH1I *EBGainHisto[ecalPh2::sampleSize]; + + + TH2D* meEBDigiOccupancy_; + TH2D* meEBDigiOccupancyHigh_; + TH2D* meEBDigiOccupancyLow_; + + TH1D* meEBDigiMultiplicity_; + + TH1D* meEBDigiADCGlobal_; + + TH1I* SingleChannelE; + TH1I* SingleChannelELow; + + TH1D* meEBDigiADCAnalog_[ecalPh2::sampleSize]; + TH1D* meEBDigiADCgS_[ecalPh2::sampleSize]; + TH1D* meEBDigiGain_[ecalPh2::sampleSize]; + + + TH1D* meEBPedestal_; + +TH1D* meEBMaximumgt100ADC_; + + TH1D* meEBMaximumgt10ADC_; + + TH1D* meEBnADCafterSwitch_; + + TF1 *f; + + + + + + + + +}; diff --git a/SimCalorimetry/PhaseIIAnalyzer/python/CfiFile_cfi.py b/SimCalorimetry/PhaseIIAnalyzer/python/CfiFile_cfi.py new file mode 100644 index 0000000000000..241782d96afd4 --- /dev/null +++ b/SimCalorimetry/PhaseIIAnalyzer/python/CfiFile_cfi.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +phaseII = cms.EDAnalyzer('PhaseIIAnalyzer', + BarrelDigis=cms.InputTag('simEcalUnsuppressedDigis','','DIGI'), + record = cms.string('EcalLiteDTUPedestalsRcd') +) diff --git a/SimCalorimetry/PhaseIIAnalyzer/python/ConfFile_cfg.py b/SimCalorimetry/PhaseIIAnalyzer/python/ConfFile_cfg.py new file mode 100644 index 0000000000000..7c2362a4ddd48 --- /dev/null +++ b/SimCalorimetry/PhaseIIAnalyzer/python/ConfFile_cfg.py @@ -0,0 +1,39 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("PhaseII") + +#Print out: +process.load("FWCore.MessageLogger.MessageLogger_cfi") +process.MessageLogger.cerr.threshold = 'INFO' +process.MessageLogger.categories.append('PhaseIIAnalyzer') +process.MessageLogger.cerr.INFO = cms.untracked.PSet( + limit = cms.untracked.int32(-1) +) +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + + + +#Max event +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +#input: +process.source = cms.Source("PoolSource", + + fileNames = cms.untracked.vstring('file:../../../SimCalorimetry/EcalSimProducers/test/SingleElectronPt10_pythia8_cfi_py_GEN_SIM_DIGI_Pt10.root'), + + ) + +process.load('SimCalorimetry.EcalSimProducers.esEcalLiteDTUPedestalsProducer_cfi') +process.EcalLiteDTUPedestalsESProducer = cms.ESProducer( + "EcalLiteDTUPedestalsESProducer", + ComponentName = cms.string('testPedestalProducer') +) + +process.phaseII = cms.EDAnalyzer('PhaseIIAnalyzer') +process.TFileService = cms.Service("TFileService", + fileName = cms.string('Digitizer2.root') + ) +process.load("SimCalorimetry.PhaseIIAnalyzer.CfiFile_cfi") + +#Running process: +process.p = cms.Path(process.phaseII) diff --git a/SimCalorimetry/PhaseIIAnalyzer/python/Digitizer2.root b/SimCalorimetry/PhaseIIAnalyzer/python/Digitizer2.root new file mode 100644 index 0000000000000000000000000000000000000000..76328445a4d5070da92dcaac21deb5785c64b3f8 GIT binary patch literal 54766 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 dhOahozb{xi(qRjSpIfj1>x_ Date: Fri, 3 Apr 2020 10:51:40 +0200 Subject: [PATCH 03/10] fix to PhaseII Analyzer --- .../plugins/PhaseIIAnalyzer.cc | 44 +++++++++---------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc index b0e1116fe4a95..58c0c76caa44c 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -4,9 +4,7 @@ // Class: PhaseIIAnalyzer // /**\class PhaseIIAnalyzer PhaseIIAnalyzer.cc PhaseII/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc - Description: [one line class summary] - Implementation: [Notes on implementation] */ @@ -187,17 +185,21 @@ PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup int nDigis=0; int maxADCValue=0; int LowGain=0; + double gainConv_[2]={10,1}; + double barrelADCtoGeV_ = 0.048; //GeV + + for (EBDigiCollectionPh2::const_iterator pDigi=pDigiEB->begin(); pDigi!=pDigiEB->end(); ++pDigi) { maxADCValue=0; - LowGain=1; + LowGain=0; EBDataFrame digi( *pDigi ); int nrSamples = digi.size(); EBDetId ebid = digi.id () ; nDigis++; - edm::ESHandle peds; + edm::ESHandle peds; iSetup.get().get(peds); const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); // EcalLiteDTUPedestalsMap::const_iterator itped = DTUpeds_map->getMap().find(ebid); @@ -219,43 +221,40 @@ PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup ebADCGains[sample] = 0.; } - double gainConv_[2]={10,1}; - // saturated channels - double barrelADCtoGeV_ = 0.048; //GeV - // EcalIntercalibConstantsMC* ical = // EcalIntercalibConstantMCMap &icalMap = for (int sample = 0 ; sample < nrSamples; ++sample) { - + int thisSample = digi[sample]; - + ebADCCounts[sample] = (thisSample&0xFFF); ebADCGains[sample] = (thisSample&(0x3<<12))>>12; ebAnalogSignal[sample] = (ebADCCounts[sample]*gainConv_[(int)ebADCGains[sample]]*barrelADCtoGeV_); if(ebADCCounts[sample] > maxADCValue) maxADCValue = ebADCCounts[sample]; - if( ebADCGains[sample]==0) LowGain=1; - else LowGain=0; - + if( ebADCGains[sample]==1) LowGain=1; + + if( ebid.iphi()==333 and ebid.ieta()==83) { SingleChannelE -> SetBinContent(sample,ebADCCounts[sample]); } - if( ebid.iphi()==334 and ebid.ieta()==83) { + if( ebid.iphi()==333 and ebid.ieta()==83) { SingleChannelELow -> SetBinContent(sample,ebADCCounts[sample]); } - if(ebADCCounts[sample]>40) { + if(ebADCCounts[sample] > 27) { cout<<"Channel: "< 27.5) { + cout<<"Filling Histo: "<SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); if(LowGain==0) meEBDigiOccupancyHigh_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); - else meEBDigiOccupancyLow_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + else meEBDigiOccupancyLow_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); } From e0acded9879b0779640aadae1ec67eec014676ae Mon Sep 17 00:00:00 2001 From: rselvati Date: Fri, 3 Apr 2020 19:08:14 +0200 Subject: [PATCH 04/10] fix some style issues --- .../CaloObjects/src/CaloTSamples_Ph2.cc | 6 +- .../DataRecord/src/EcalCATIAGainRatiosRcd.cc | 2 +- .../EcalObjects/interface/EcalConstants.h | 21 +- .../interface/EcalLiteDTUPedestals.h | 35 +- .../EcalObjects/src/SerializationManual.h | 1 - .../src/T_EventSetup_EcalLiteDTUPedestals.cc | 2 +- CondFormats/EcalObjects/src/classes.h | 207 +++--- .../interface/EcalDigiCollections_Ph2.h | 34 +- DataFormats/EcalDigi/src/EBDataFrame.cc | 50 +- DataFormats/EcalDigi/src/classes.h | 2 - .../interface/EBHitResponse_Ph2.h | 117 ++-- .../EcalSimAlgos/interface/EcalCoder.h | 1 - .../EcalSimAlgos/interface/EcalCoder_Ph2.h | 96 ++- .../interface/EcalDigitizerTraits_Ph2.h | 19 +- .../interface/EcalElectronicsSim_Ph2.h | 7 +- .../interface/EcalHitResponse_Ph2.h | 147 ++--- .../interface/EcalSimParameterMap_Ph2.h | 23 +- .../interface/EcalTDigitizer_Ph2.h | 60 +- .../interface/EcalTDigitizer_Ph2.icc | 8 +- .../EcalSimAlgos/src/EBHitResponse_Ph2.cc | 476 ++++++-------- .../EcalSimAlgos/src/EcalCoder_Ph2.cc | 410 ++++++------ .../src/EcalCorrelatedNoiseMatrix_Ph2.cc | 12 +- .../src/EcalElectronicsSim_Ph2.cc | 10 +- .../EcalSimAlgos/src/EcalHitResponse_Ph2.cc | 401 +++++------- .../src/EcalSimParameterMap_Ph2.cc | 63 +- .../interface/EcalDigiProducer_Ph2.h | 126 ++-- .../interface/EcalTimeDigiProducer_Ph2.h | 57 +- .../plugins/EcalCATIAGainRatiosESProducer.cc | 15 +- .../plugins/EcalLiteDTUPedestalsESProducer.cc | 30 +- .../src/EcalDigiProducer_Ph2.cc | 607 ++++++++---------- .../src/EcalTimeDigiProducer_Ph2.cc | 107 ++- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc | 338 +++++----- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.h | 74 +-- .../plugins/PhaseIIAnalyzer.cc | 284 ++++---- .../PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h | 72 +-- 35 files changed, 1720 insertions(+), 2200 deletions(-) diff --git a/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc b/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc index 68d2b9c9d08d1..0479197cc8de5 100644 --- a/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc +++ b/CalibFormats/CaloObjects/src/CaloTSamples_Ph2.cc @@ -2,7 +2,7 @@ #include "CalibFormats/CaloObjects/interface/CaloTSamples.icc" #include "CondFormats/EcalObjects/interface/EcalConstants.h" -template class CaloTSamplesBase ; +template class CaloTSamplesBase; -template class CaloTSamples ; -template class CaloTSamples ; +template class CaloTSamples; +template class CaloTSamples; diff --git a/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc b/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc index 120c8ac455917..d59977b155288 100644 --- a/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc +++ b/CondFormats/DataRecord/src/EcalCATIAGainRatiosRcd.cc @@ -1,4 +1,4 @@ #include "CondFormats/DataRecord/interface/EcalCATIAGainRatiosRcd.h" #include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" - + EVENTSETUP_RECORD_REG(EcalCATIAGainRatiosRcd); diff --git a/CondFormats/EcalObjects/interface/EcalConstants.h b/CondFormats/EcalObjects/interface/EcalConstants.h index f28f54a3cc847..cb504df53d94f 100644 --- a/CondFormats/EcalObjects/interface/EcalConstants.h +++ b/CondFormats/EcalObjects/interface/EcalConstants.h @@ -2,20 +2,17 @@ #ifndef EcalObject_EcalConstants_h #define EcalObject_EcalConstants_h -namespace ecalPh2 -{ - constexpr double BUNCHSPACE = 6.25; +namespace ecalPh2 { + constexpr double BUNCHSPACE = 6.25; constexpr int NGAINS = 2; - constexpr float gains[2] = {10.,1.}; + constexpr float gains[2] = {10., 1.}; constexpr int sampleSize = 16; -} +} // namespace ecalPh2 - -namespace ecalPh1 -{ - constexpr double BUNCHSPACE = 25.; - constexpr int NGAINS = 4; - constexpr float gains[4] = {0.,12.,6.,1.}; +namespace ecalPh1 { + constexpr double BUNCHSPACE = 25.; + constexpr int NGAINS = 4; + constexpr float gains[4] = {0., 12., 6., 1.}; constexpr int sampleSize = 10; -} +} // namespace ecalPh1 #endif diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h index 794a458ed2b1d..0eea76667f47f 100644 --- a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -1,43 +1,38 @@ #ifndef EcalLiteDTUPedestals_h #define EcalLiteDTUPedestals_h - #include "CondFormats/Serialization/interface/Serializable.h" #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" -const int NGAINS=2; +const int NGAINS = 2; -const int gainId1=1; -const int gainId10=0; +const int gainId1 = 1; +const int gainId10 = 0; -class EcalLiteDTUPed { +class EcalLiteDTUPed { +public: + double meanarray[2] = {13., 8.}; + double rmsarray[2] = {2.8, 1.2}; - public: - double meanarray[2]={13.,8.}; - double rmsarray[2]={2.8,1.2}; - - int setMean(int i, float value){ - if(i>=NGAINS || i<0) return -1; + int setMean(int i, float value) { + if (i >= NGAINS || i < 0) + return -1; else meanarray[i] = value; return 1; } - - int setRMS(int i,float value){ - if(i>=NGAINS || i < 0) return -1; + int setRMS(int i, float value) { + if (i >= NGAINS || i < 0) + return -1; else rmsarray[i] = value; return 1; } - float mean(int i) const { - return meanarray[i]; - } + float mean(int i) const { return meanarray[i]; } - float rms(int i) const { - return rmsarray[i]; - } + float rms(int i) const { return rmsarray[i]; } COND_SERIALIZABLE; }; diff --git a/CondFormats/EcalObjects/src/SerializationManual.h b/CondFormats/EcalObjects/src/SerializationManual.h index 123b08e020e3a..7b00af632211d 100644 --- a/CondFormats/EcalObjects/src/SerializationManual.h +++ b/CondFormats/EcalObjects/src/SerializationManual.h @@ -17,4 +17,3 @@ COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondTowerObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondTowerObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondTowerObjectContainer); - diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc index f5a0fac4dc88c..768ececabe40d 100644 --- a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc @@ -2,7 +2,7 @@ // // Package: EDMProto // Class : T_Context_Pedestals -// +// // Implementation: // create all the 'infrastructure' needed to get into the Context // diff --git a/CondFormats/EcalObjects/src/classes.h b/CondFormats/EcalObjects/src/classes.h index 0d872ff0ec38f..cbf507c143274 100644 --- a/CondFormats/EcalObjects/src/classes.h +++ b/CondFormats/EcalObjects/src/classes.h @@ -66,167 +66,168 @@ #include "CondFormats/EcalObjects/interface/EcalSRSettings.h" #include "CondFormats/EcalObjects/interface/EcalSimPulseShape.h" //ECAL PH2: - #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" - #include "CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h" +#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 - + 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 - + 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 - + 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 - + 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 + EcalContainer ec_eeDetId_ecalPedestal; + EcalContainer ec_ebDetId_ecalPedestal; + EcalCondObjectContainer pedmap; //typedef EcalPedestals //ECAL PH2: std::vector v_ecalDTUPed; - EcalContainer ec_ebDetId_ecalLiteDTUPed; - EcalCondObjectContainer pedmapDTU; //typedef EcalPedestals + EcalContainer ec_ebDetId_ecalLiteDTUPed; + EcalCondObjectContainer pedmapDTU; //typedef EcalPedestals std::vector v_ecalTPGCrystalStatusCode; - EcalContainer ec_eeDetId_ecalTPGCrystalStatusCode; - EcalContainer ec_ebDetId_ecalTPGCrystalStatusCode; - EcalCondObjectContainer tpgCrystalStatus; //typedef EcalTPGCrystalStatus - + 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 - + 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 - + 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 - + 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; + 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; + 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 - + 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< EcalXtalGroupId, EcalTBWeights::EcalTDCId > wgpair; - std::map< std::pair< EcalXtalGroupId, EcalTBWeights::EcalTDCId > , EcalWeightSet > wgmap; - std::pair< const std::pair< EcalXtalGroupId, EcalTBWeights::EcalTDCId > , EcalWeightSet > wgmapvalue; - + 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< uint32_t, EcalTPGFineGrainStripEE::Item > EcalTPGFineGrainStripEEMap; - std::pair< const uint32_t, EcalTPGFineGrainStripEE::Item > EcalTPGFineGrainStripEEMap_valuetype; - + std::map EcalTPGFineGrainEBMap; + std::pair EcalTPGFineGrainEBMap_valuetype; + + std::map EcalTPGFineGrainStripEEMap; + std::pair EcalTPGFineGrainStripEEMap_valuetype; + EcalTPGLut lut; - std::map< uint32_t, EcalTPGLut > EcalTPGLutMap; - std::pair< const uint32_t, EcalTPGLut > EcalTPGLutMap_valuetype; - + std::map EcalTPGLutMap; + std::pair EcalTPGLutMap_valuetype; + EcalTPGWeights weightsweights; std::map EcalTPGWeightMap; std::pair EcalTPGWeightMap_valuetype; - - EcalFunParams funParams; // typdefs: EcalClusterCrackCorrParameters, EcalClusterEnergyCorrectionObjectSpecificParameters, EcalClusterEnergyCorrectionParameters, EcalClusterEnergyUncertaintyParameters, EcalClusterLocalContCorrParameters - + + EcalFunParams + funParams; // typdefs: EcalClusterCrackCorrParameters, EcalClusterEnergyCorrectionObjectSpecificParameters, EcalClusterEnergyCorrectionParameters, EcalClusterEnergyUncertaintyParameters, EcalClusterLocalContCorrParameters + EcalTPGFineGrainEBGroup fgrgroup; - + EcalTPGLutGroup lutgroup; - + EcalTPGWeightGroup wgroup; - + EcalTPGPhysicsConst::Item foo1; - std::map< uint32_t, EcalTPGPhysicsConst::Item > phConst; - std::pair< const uint32_t, EcalTPGPhysicsConst::Item > phConst_valuetype; - + std::map phConst; + std::pair phConst_valuetype; + EcalTPGTowerStatus towerstatus; - std::map< uint32_t, uint16_t > tStatus; - std::pair< const uint32_t, uint16_t > tStatus_valuetype; + 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 + 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 + 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 + EcalContainer ec_eeDetId_ecalPulseSymmCovariance; + EcalContainer ec_ebDetId_ecalPulseSymmCovariance; + EcalCondObjectContainer ecalSPCmap; //typedef EcalPulseSymmCovariance EcalSimPulseShape ecal_sim_pulse_shapes; }; -} +} // namespace CondFormats_EcalObjects diff --git a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h index dc1d71efb0712..b5c604e2d0a25 100644 --- a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h +++ b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h @@ -24,41 +24,29 @@ class EcalDigiCollectionPh2 : public edm::DataFrameContainer { public: typedef edm::DataFrameContainer::size_type size_type; static const size_type MAXSAMPLES = ecalPh2::sampleSize; - explicit EcalDigiCollectionPh2(size_type istride=MAXSAMPLES, int isubdet=0) : - edm::DataFrameContainer(istride, isubdet){} - void swap(DataFrameContainer& other) {this->DataFrameContainer::swap(other);} - + explicit EcalDigiCollectionPh2(size_type istride = MAXSAMPLES, int isubdet = 0) + : edm::DataFrameContainer(istride, isubdet) {} + void swap(DataFrameContainer& other) { this->DataFrameContainer::swap(other); } }; // make edm (and ecal client) happy -class EBDigiCollectionPh2 : public EcalDigiCollectionPh2 { +class EBDigiCollectionPh2 : public EcalDigiCollectionPh2 { public: typedef edm::DataFrameContainer::size_type size_type; typedef EBDataFrame Digi; typedef Digi::key_type DetId; - EBDigiCollectionPh2(size_type istride=MAXSAMPLES) : - EcalDigiCollectionPh2(istride, EcalBarrel){} - void swap(EBDigiCollectionPh2& other) {this->EcalDigiCollectionPh2::swap(other);} - void push_back(const Digi& digi){ DataFrameContainer::push_back(digi.id(), digi.frame().begin()); } - void push_back(id_type iid){DataFrameContainer::push_back(iid);} - void push_back(id_type iid,data_type const* idata){DataFrameContainer::push_back(iid,idata);} - + EBDigiCollectionPh2(size_type istride = MAXSAMPLES) : EcalDigiCollectionPh2(istride, EcalBarrel) {} + void swap(EBDigiCollectionPh2& other) { this->EcalDigiCollectionPh2::swap(other); } + void push_back(const Digi& digi) { DataFrameContainer::push_back(digi.id(), digi.frame().begin()); } + void push_back(id_type iid) { DataFrameContainer::push_back(iid); } + void push_back(id_type iid, data_type const* idata) { DataFrameContainer::push_back(iid, idata); } }; - - // Free swap functions -inline -void swap(EcalDigiCollectionPh2& lhs, EcalDigiCollectionPh2& rhs) { - lhs.swap(rhs); -} - -inline -void swap(EBDigiCollectionPh2& lhs, EBDigiCollectionPh2& rhs) { - lhs.swap(rhs); -} +inline void swap(EcalDigiCollectionPh2& lhs, EcalDigiCollectionPh2& rhs) { lhs.swap(rhs); } +inline void swap(EBDigiCollectionPh2& lhs, EBDigiCollectionPh2& rhs) { lhs.swap(rhs); } typedef edm::SortedCollection EcalTimeDigiCollection; //DA ELIMINARE??? diff --git a/DataFormats/EcalDigi/src/EBDataFrame.cc b/DataFormats/EcalDigi/src/EBDataFrame.cc index b2c96812b1610..acd83dc03ce91 100644 --- a/DataFormats/EcalDigi/src/EBDataFrame.cc +++ b/DataFormats/EcalDigi/src/EBDataFrame.cc @@ -1,34 +1,34 @@ #include "DataFormats/EcalDigi/interface/EBDataFrame.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include -#warning [DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 -float EBDataFrame::spikeEstimator() const -{ - if ( size() != 10 ) { - edm::LogError("InvalidNumberOfSamples") << "This method only applies to signals sampled 10 times (" - << size() << " samples found)"; - return 10.; - } - // skip faulty channels - if ( sample(5).adc() == 0 ) return 10.; - size_t imax = 0; - int maxAdc = 0; - for ( int i = 0; i < size(); ++i ) { - if ( sample(i).adc() > maxAdc ) { - imax = i; - maxAdc = sample(i).adc(); - } - } - // skip early signals - if ( imax < 4 ) return 10.; - float ped = 1./3. * (sample(0).adc() + sample(1).adc() + sample(2).adc()); - return 0.18*(sample(4).adc()-ped)/(sample(5).adc()-ped) + (sample(6).adc()-ped)/(sample(5).adc()-ped); +#include +#warning[DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 +float EBDataFrame::spikeEstimator() const { + if (size() != 10) { + edm::LogError("InvalidNumberOfSamples") + << "This method only applies to signals sampled 10 times (" << size() << " samples found)"; + return 10.; + } + // skip faulty channels + if (sample(5).adc() == 0) + return 10.; + size_t imax = 0; + int maxAdc = 0; + for (int i = 0; i < size(); ++i) { + if (sample(i).adc() > maxAdc) { + imax = i; + maxAdc = sample(i).adc(); + } + } + // skip early signals + if (imax < 4) + return 10.; + float ped = 1. / 3. * (sample(0).adc() + sample(1).adc() + sample(2).adc()); + return 0.18 * (sample(4).adc() - ped) / (sample(5).adc() - ped) + (sample(6).adc() - ped) / (sample(5).adc() - ped); } - std::ostream& operator<<(std::ostream& s, const EBDataFrame& digi) { s << digi.id() << " " << digi.size() << " samples " << std::endl; - for (int i=0; i EBSamples ; - - typedef std::vector VecD ; - - enum { kNOffsets = 2000 } ; +class EBHitResponse_Ph2 : public EcalHitResponse_Ph2 { +public: + typedef CaloTSamples EBSamples; - EBHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , - const CaloVShape* shape , - bool apdOnly , - const APDSimParameters* apdPars , - const CaloVShape* apdShape ) ; + typedef std::vector VecD; - ~EBHitResponse_Ph2() override ; + enum { kNOffsets = 2000 }; - void initialize(CLHEP::HepRandomEngine*); + EBHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, + const CaloVShape* shape, + bool apdOnly, + const APDSimParameters* apdPars, + const CaloVShape* apdShape); - virtual bool keepBlank() const { return false ; } + ~EBHitResponse_Ph2() override; - void setIntercal( const EcalIntercalibConstantsMC* ical ) ; + void initialize(CLHEP::HepRandomEngine*); + virtual bool keepBlank() const { return false; } - void add( const PCaloHit& hit, CLHEP::HepRandomEngine* ) override; + void setIntercal(const EcalIntercalibConstantsMC* ical); - void initializeHits() override; + void add(const PCaloHit& hit, CLHEP::HepRandomEngine*) override; - void finalizeHits() override; + void initializeHits() override; - void run( MixCollection& hits, CLHEP::HepRandomEngine* ) override; + void finalizeHits() override; - unsigned int samplesSize() const override; + void run(MixCollection& hits, CLHEP::HepRandomEngine*) override; - EcalSamples* operator[]( unsigned int i ) override; + unsigned int samplesSize() const override; - const EcalSamples* operator[]( unsigned int i ) const override; + EcalSamples* operator[](unsigned int i) override; - protected: + const EcalSamples* operator[](unsigned int i) const override; - unsigned int samplesSizeAll() const override; +protected: + unsigned int samplesSizeAll() const override; - EcalSamples* vSamAll( unsigned int i ) override; + EcalSamples* vSamAll(unsigned int i) override; - const EcalSamples* vSamAll( unsigned int i ) const override; + const EcalSamples* vSamAll(unsigned int i) const override; - EcalSamples* vSam( unsigned int i ) override ; + EcalSamples* vSam(unsigned int i) override; - void putAPDSignal( const DetId& detId, double npe, double time ) ; + void putAPDSignal(const DetId& detId, double npe, double time); - private: +private: + const VecD& offsets() const { return m_timeOffVec; } - const VecD& offsets() const { return m_timeOffVec ; } + const double nonlFunc(double enr) const { + return (pelo > enr ? pext : (pehi > enr ? nonlFunc1(enr) : pfac * atan(log10(enr - pehi + 0.00001)) + poff)); + } - const double nonlFunc( double enr ) const { - return ( pelo > enr ? pext : - ( pehi > enr ? nonlFunc1( enr ) : - pfac*atan( log10( enr - pehi + 0.00001 ) ) + poff ) ) ; } + const double nonlFunc1(double energy) const { + const double enr(log10(energy)); + const double enr2(enr * enr); + const double enr3(enr2 * enr); + return (pcub * enr3 + pqua * enr2 + plin * enr + pcon); + } - const double nonlFunc1( double energy ) const { - const double enr ( log10(energy) ) ; - const double enr2 ( enr*enr ) ; - const double enr3 ( enr2*enr ) ; - return ( pcub*enr3 + pqua*enr2 + plin*enr + pcon ) ; } + const APDSimParameters* apdParameters() const; + const CaloVShape* apdShape() const; - const APDSimParameters* apdParameters() const ; - const CaloVShape* apdShape() const ; + double apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEngine*) const; - double apdSignalAmplitude( const PCaloHit& hit, CLHEP::HepRandomEngine* ) const ; + void findIntercalibConstant(const DetId& detId, double& icalconst) const; - void findIntercalibConstant( const DetId& detId, - double& icalconst ) const ; + const bool m_apdOnly; + const APDSimParameters* m_apdPars; + const CaloVShape* m_apdShape; + const EcalIntercalibConstantsMC* m_intercal; - const bool m_apdOnly ; - const APDSimParameters* m_apdPars ; - const CaloVShape* m_apdShape ; - const EcalIntercalibConstantsMC* m_intercal ; + std::vector m_timeOffVec; - std::vector m_timeOffVec ; + std::vector m_apdNpeVec; + std::vector m_apdTimeVec; - std::vector m_apdNpeVec ; - std::vector m_apdTimeVec ; + const double pcub, pqua, plin, pcon, pelo, pehi, pasy, pext, poff, pfac; - const double pcub, pqua, plin, pcon, pelo, pehi, pasy, pext, poff, pfac ; + std::vector m_vSam; - std::vector m_vSam ; - - bool m_isInitialized; + bool m_isInitialized; }; #endif - - diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h index b9ffed023d5e6..0fe9792fef649 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h @@ -25,7 +25,6 @@ namespace CLHEP { */ class EcalCoder { public: - typedef CaloTSamples EcalSamples; typedef CorrelatedNoisifier Noisifier; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h index 852462b25be66..d66654f3c4708 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h @@ -9,94 +9,76 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" - -template class CorrelatedNoisifier ; +template +class CorrelatedNoisifier; class EcalMGPASample; class EcalDataFrame; class DetId; class EcalLiteDTUPed; -#include +#include namespace CLHEP { class HepRandomEngine; } - class EcalCoder_Ph2 { - public: +public: + typedef CaloTSamples_Ph2 EcalSamples; + + //typedef CaloTSamples_Ph2 EcalSamples ; - typedef CaloTSamples_Ph2 EcalSamples; + typedef CorrelatedNoisifier Noisifier; - //typedef CaloTSamples_Ph2 EcalSamples ; - - typedef CorrelatedNoisifier Noisifier ; + enum { + NBITS = 12, // number of available bits + MAXADC = 4095, // 2^12 -1, adc max range + NGAINS = 2 // number of electronic gains + }; - enum { NBITS = 12 , // number of available bits - MAXADC = 4095, // 2^12 -1, adc max range - NGAINS = 2 // number of electronic gains - }; + /// ctor + EcalCoder_Ph2(bool addNoise, bool PreMix1, Noisifier* ebCorrNoise0, Noisifier* ebCorrNoise1 = nullptr); - /// ctor - EcalCoder_Ph2( bool addNoise , - bool PreMix1 , - Noisifier* ebCorrNoise0 , - Noisifier* ebCorrNoise1 = nullptr ) ; + /// dtor + virtual ~EcalCoder_Ph2(); - /// dtor - virtual ~EcalCoder_Ph2() ; + /// can be fetched every event from the EventSetup + void setPedestals(const EcalLiteDTUPedestals* pedestals); - /// can be fetched every event from the EventSetup - void setPedestals( const EcalLiteDTUPedestals* pedestals ) ; + void setGainRatios(const EcalCATIAGainRatios* gainRatios); - void setGainRatios( const EcalCATIAGainRatios* gainRatios ) ; + void setFullScaleEnergy(double EBscale); - void setFullScaleEnergy( double EBscale ) ; + void setIntercalibConstants(const EcalIntercalibConstantsMC* ical); - void setIntercalibConstants( const EcalIntercalibConstantsMC* ical ) ; - + /// from EcalSamples to EcalDataFrame + virtual void analogToDigital(CLHEP::HepRandomEngine*, const EcalSamples& clf, EcalDataFrame& df) const; - /// from EcalSamples to EcalDataFrame - virtual void analogToDigital( CLHEP::HepRandomEngine*, - const EcalSamples& clf , - EcalDataFrame& df ) const; - - private: +private: + /// limit on the energy scale due to the electronics range + double fullScaleEnergy(const DetId& did) const; - /// limit on the energy scale due to the electronics range - double fullScaleEnergy( const DetId & did ) const ; + /// produce the pulse-shape + void encode(const EcalSamples& ecalSamples, EcalDataFrame& df, CLHEP::HepRandomEngine*) const; - /// produce the pulse-shape - void encode( const EcalSamples& ecalSamples , - EcalDataFrame& df, - CLHEP::HepRandomEngine* ) const ; + void findPedestal(const DetId& detId, int gainId, double& pedestal, double& width) const; - + void findGains(const DetId& detId, float theGains[]) const; - void findPedestal( const DetId& detId , - int gainId , - double& pedestal , - double& width ) const ; - - void findGains( const DetId& detId, float theGains[] ) const ; + void findIntercalibConstant(const DetId& detId, double& icalconst) const; - void findIntercalibConstant( const DetId& detId , - double& icalconst ) const ; - - const EcalLiteDTUPedestals* m_peds ; - - const EcalCATIAGainRatios* m_gainRatios ; // the electronics gains + const EcalLiteDTUPedestals* m_peds; - const EcalIntercalibConstantsMC* m_intercals ; //record specific for simulation of gain variation in MC + const EcalCATIAGainRatios* m_gainRatios; // the electronics gains - double m_maxEneEB ; // max attainable energy in the ecal barrel - - bool m_addNoise ; // whether add noise to the pedestals and the gains - bool m_PreMix1 ; // Follow necessary steps for PreMixing input + const EcalIntercalibConstantsMC* m_intercals; //record specific for simulation of gain variation in MC - const Noisifier* m_ebCorrNoise[NGAINS] ; + double m_maxEneEB; // max attainable energy in the ecal barrel + bool m_addNoise; // whether add noise to the pedestals and the gains + bool m_PreMix1; // Follow necessary steps for PreMixing input + const Noisifier* m_ebCorrNoise[NGAINS]; }; #endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h index 37cfe0a60d0be..90cc1910d564b 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h @@ -7,21 +7,20 @@ #include "DataFormats/EcalDigi/interface/EcalDataFrame.h" #include "DataFormats/EcalDigi/interface/EBDataFrame.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" -class EcalHitResponse ; +class EcalHitResponse; class EBDigitizerTraits_Ph2 { - public: - /// the digis collection +public: + /// the digis collection typedef EBDigiCollectionPh2 DigiCollection; - /// the dataframes - typedef EBDataFrame Digi; - /// the electronics simulation - typedef EcalElectronicsSim_Ph2 ElectronicsSim_Ph2; + /// the dataframes + typedef EBDataFrame Digi; + /// the electronics simulation + typedef EcalElectronicsSim_Ph2 ElectronicsSim_Ph2; - typedef CaloTSamples_Ph2 EcalSamples ; + typedef CaloTSamples_Ph2 EcalSamples; - static void fix( Digi& digi, edm::DataFrame df ) {}; + static void fix(Digi& digi, edm::DataFrame df){}; }; #endif - diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h index 5f1ab030414ec..0c4a1ef38c43a 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h @@ -5,7 +5,6 @@ #include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" - class EcalCoder_Ph2; class EcalDataFrame; class EcalSimParameterMap_Ph2; @@ -24,9 +23,9 @@ class EcalElectronicsSim_Ph2 { typedef CaloTSamples_Ph2 EcalSamples; //typedef CaloTSamples_Ph2 EcalSamples; EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, - EcalCoder_Ph2* coder, - bool applyConstantTerm, - double rmsConstantTerm); + EcalCoder_Ph2* coder, + bool applyConstantTerm, + double rmsConstantTerm); ~EcalElectronicsSim_Ph2(); diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h index 83c60b0478923..f871997f01eb9 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h @@ -14,131 +14,124 @@ typedef unsigned long long TimeValue_t; -class CaloVShape ; -class CaloVSimParameterMap ; -class CaloVHitCorrection ; -class CaloVHitFilter ; -class CaloSimParameters ; -class CaloSubdetectorGeometry ; -class CaloVPECorrection ; -namespace CLHEP -{ - class HepRandomEngine ; +class CaloVShape; +class CaloVSimParameterMap; +class CaloVHitCorrection; +class CaloVHitFilter; +class CaloSimParameters; +class CaloSubdetectorGeometry; +class CaloVPECorrection; +namespace CLHEP { + class HepRandomEngine; } -class EcalHitResponse_Ph2 -{ - public: +class EcalHitResponse_Ph2 { +public: + typedef CaloTSamplesBase EcalSamples; - typedef CaloTSamplesBase EcalSamples ; + typedef std::vector VecInd; - typedef std::vector< unsigned int > VecInd ; + typedef std::unordered_map CalibCache; - typedef std::unordered_map CalibCache; + EcalHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape); - EcalHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , - const CaloVShape* shape ) ; + virtual ~EcalHitResponse_Ph2(); - virtual ~EcalHitResponse_Ph2() ; + void setBunchRange(int minBunch, int maxBunch); - void setBunchRange( int minBunch , - int maxBunch ) ; + void setGeometry(const CaloSubdetectorGeometry* geometry); - void setGeometry( const CaloSubdetectorGeometry* geometry ) ; + void setPhaseShift(double phaseShift); - void setPhaseShift( double phaseShift ) ; + void setHitFilter(const CaloVHitFilter* filter); - void setHitFilter( const CaloVHitFilter* filter) ; + void setHitCorrection(const CaloVHitCorrection* hitCorrection); - void setHitCorrection( const CaloVHitCorrection* hitCorrection) ; + void setPECorrection(const CaloVPECorrection* peCorrection); - void setPECorrection( const CaloVPECorrection* peCorrection ) ; + void setEventTime(const edm::TimeValue_t& iTime); - void setEventTime(const edm::TimeValue_t& iTime); + void setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection); - void setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection); + void add(const EcalSamples* pSam); - void add( const EcalSamples* pSam ) ; + virtual void add(const PCaloHit& hit, CLHEP::HepRandomEngine*); - virtual void add( const PCaloHit& hit, CLHEP::HepRandomEngine* ) ; + virtual void add(const CaloSamples& hit); - virtual void add( const CaloSamples& hit ) ; + virtual void initializeHits(); - virtual void initializeHits() ; + virtual void finalizeHits(); - virtual void finalizeHits() ; + virtual void run(MixCollection& hits, CLHEP::HepRandomEngine*); - virtual void run( MixCollection& hits, CLHEP::HepRandomEngine* ) ; + virtual unsigned int samplesSize() const = 0; - virtual unsigned int samplesSize() const = 0 ; + virtual EcalSamples* operator[](unsigned int i) = 0; - virtual EcalSamples* operator[]( unsigned int i ) = 0; + virtual const EcalSamples* operator[](unsigned int i) const = 0; - virtual const EcalSamples* operator[]( unsigned int i ) const = 0; + const EcalSamples* findDetId(const DetId& detId) const; - const EcalSamples* findDetId( const DetId& detId ) const ; + bool withinBunchRange(int bunchCrossing) const; - bool withinBunchRange(int bunchCrossing) const ; +protected: + virtual unsigned int samplesSizeAll() const = 0; - protected: + virtual EcalSamples* vSam(unsigned int i) = 0; - virtual unsigned int samplesSizeAll() const = 0 ; + virtual EcalSamples* vSamAll(unsigned int i) = 0; - virtual EcalSamples* vSam( unsigned int i ) = 0 ; + virtual const EcalSamples* vSamAll(unsigned int i) const = 0; - virtual EcalSamples* vSamAll( unsigned int i ) = 0 ; + virtual void putAnalogSignal(const PCaloHit& inputHit, CLHEP::HepRandomEngine*); - virtual const EcalSamples* vSamAll( unsigned int i ) const = 0 ; + double findLaserConstant(const DetId& detId) const; - virtual void putAnalogSignal( const PCaloHit& inputHit, CLHEP::HepRandomEngine*) ; + EcalSamples* findSignal(const DetId& detId); - double findLaserConstant(const DetId& detId) const; + double analogSignalAmplitude(const DetId& id, double energy, CLHEP::HepRandomEngine*); - EcalSamples* findSignal( const DetId& detId ) ; + double timeOfFlight(const DetId& detId) const; - double analogSignalAmplitude( const DetId& id, double energy, CLHEP::HepRandomEngine* ); + double phaseShift() const; - double timeOfFlight( const DetId& detId ) const ; + void blankOutUsedSamples(); - double phaseShift() const ; + const CaloSimParameters* params(const DetId& detId) const; - void blankOutUsedSamples() ; + const CaloVShape* shape() const; - const CaloSimParameters* params( const DetId& detId ) const ; + const CaloSubdetectorGeometry* geometry() const; - const CaloVShape* shape() const ; + int minBunch() const; - const CaloSubdetectorGeometry* geometry() const ; + int maxBunch() const; - int minBunch() const ; + VecInd& index(); - int maxBunch() const ; + const VecInd& index() const; - VecInd& index() ; + const CaloVHitFilter* hitFilter() const; - const VecInd& index() const ; +private: + const CaloVSimParameterMap* m_parameterMap; + const CaloVShape* m_shape; + const CaloVHitCorrection* m_hitCorrection; + const CaloVPECorrection* m_PECorrection; + const CaloVHitFilter* m_hitFilter; + const CaloSubdetectorGeometry* m_geometry; + const EcalLaserDbService* m_lasercals; - const CaloVHitFilter* hitFilter() const ; + int m_minBunch; + int m_maxBunch; + double m_phaseShift; - private: + edm::TimeValue_t m_iTime; + bool m_useLCcorrection; + CalibCache m_laserCalibCache; - const CaloVSimParameterMap* m_parameterMap ; - const CaloVShape* m_shape ; - const CaloVHitCorrection* m_hitCorrection ; - const CaloVPECorrection* m_PECorrection ; - const CaloVHitFilter* m_hitFilter ; - const CaloSubdetectorGeometry* m_geometry ; - const EcalLaserDbService* m_lasercals ; - - int m_minBunch ; - int m_maxBunch ; - double m_phaseShift ; - - edm::TimeValue_t m_iTime; - bool m_useLCcorrection; - CalibCache m_laserCalibCache; - - VecInd m_index ; + VecInd m_index; }; #endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h index 96cda8c36020e..8562d2960422c 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h @@ -4,28 +4,29 @@ #include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" - /* \class EcalSimParametersMap * \brief map of parameters for the ECAL (EE, EB, preshower) simulation * */ -class EcalSimParameterMap_Ph2 : public CaloVSimParameterMap -{ +class EcalSimParameterMap_Ph2 : public CaloVSimParameterMap { public: /// ctor EcalSimParameterMap_Ph2(); - EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, - //double simHitToPhotoelectronsEndcap, - double photoelectronsToAnalogBarrel, - //double photoelectronsToAnalogEndcap, - double samplingFactor, double timePhase, - int readoutFrameSize, int binOfMaximum, - bool doPhotostatistics, bool syncPhase); + EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, + //double simHitToPhotoelectronsEndcap, + double photoelectronsToAnalogBarrel, + //double photoelectronsToAnalogEndcap, + double samplingFactor, + double timePhase, + int readoutFrameSize, + int binOfMaximum, + bool doPhotostatistics, + bool syncPhase); /// dtor ~EcalSimParameterMap_Ph2() override {} /// return the sim parameters relative to the right subdet - const CaloSimParameters & simParameters(const DetId & id) const override; + const CaloSimParameters& simParameters(const DetId& id) const override; private: /// EB diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h index 7d06496e0aec2..41f361b92c1fc 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h @@ -12,60 +12,50 @@ #include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h" -class EcalHitResponse_Ph2 ; +class EcalHitResponse_Ph2; class EcalBaseSignalGenerator; namespace CLHEP { class HepRandomEngine; } -template< class Traits > -class EcalTDigitizer_Ph2 -{ - public: - typedef typename Traits::ElectronicsSim_Ph2 ElectronicsSim_Ph2 ; - typedef typename Traits::Digi Digi ; - typedef typename Traits::DigiCollection DigiCollection ; - typedef typename Traits::EcalSamples EcalSamples ; +template +class EcalTDigitizer_Ph2 { +public: + typedef typename Traits::ElectronicsSim_Ph2 ElectronicsSim_Ph2; + typedef typename Traits::Digi Digi; + typedef typename Traits::DigiCollection DigiCollection; + typedef typename Traits::EcalSamples EcalSamples; - EcalTDigitizer_Ph2< Traits >( EcalHitResponse_Ph2* hitResponse , - ElectronicsSim_Ph2* electronicsSim , - bool addNoise ) ; + EcalTDigitizer_Ph2(EcalHitResponse_Ph2* hitResponse, ElectronicsSim_Ph2* electronicsSim, bool addNoise); - virtual ~EcalTDigitizer_Ph2< Traits >() ; + virtual ~EcalTDigitizer_Ph2(); - void add(const std::vector & hits, int bunchCrossing, CLHEP::HepRandomEngine*); + void add(const std::vector& hits, int bunchCrossing, CLHEP::HepRandomEngine*); - virtual void initializeHits(); + virtual void initializeHits(); - virtual void run(DigiCollection& output, CLHEP::HepRandomEngine* ); + virtual void run(DigiCollection& output, CLHEP::HepRandomEngine*); - virtual void run( MixCollection& input , - DigiCollection& output ) { - assert(0); - } + virtual void run(MixCollection& input, DigiCollection& output) { assert(0); } - void setNoiseSignalGenerator(EcalBaseSignalGenerator * noiseSignalGenerator); + void setNoiseSignalGenerator(EcalBaseSignalGenerator* noiseSignalGenerator); - void addNoiseSignals(); + void addNoiseSignals(); - protected: +protected: + bool addNoise() const; - bool addNoise() const ; + const EcalHitResponse_Ph2* hitResponse() const; - const EcalHitResponse_Ph2* hitResponse() const ; + const ElectronicsSim_Ph2* elecSim() const; - const ElectronicsSim_Ph2* elecSim() const ; - - private: - - EcalHitResponse_Ph2* m_hitResponse ; - ElectronicsSim_Ph2* m_electronicsSim ; - bool m_addNoise ; - - EcalBaseSignalGenerator * theNoiseSignalGenerator; +private: + EcalHitResponse_Ph2* m_hitResponse; + ElectronicsSim_Ph2* m_electronicsSim; + bool m_addNoise; + EcalBaseSignalGenerator* theNoiseSignalGenerator; }; #endif - diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc index 7c27ada77afef..60342b5b2cf46 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc @@ -7,7 +7,9 @@ #include "CalibFormats/CaloObjects/interface/CaloSamples.h" template -EcalTDigitizer_Ph2::EcalTDigitizer_Ph2(EcalHitResponse_Ph2* hitResponse, ElectronicsSim_Ph2* electronicsSim, bool addNoise) +EcalTDigitizer_Ph2::EcalTDigitizer_Ph2(EcalHitResponse_Ph2* hitResponse, + ElectronicsSim_Ph2* electronicsSim, + bool addNoise) : m_hitResponse(hitResponse), m_electronicsSim(electronicsSim), m_addNoise(addNoise), @@ -17,7 +19,9 @@ template EcalTDigitizer_Ph2::~EcalTDigitizer_Ph2() {} template -void EcalTDigitizer_Ph2::add(const std::vector& hits, int bunchCrossing, CLHEP::HepRandomEngine* engine) { +void EcalTDigitizer_Ph2::add(const std::vector& hits, + int bunchCrossing, + CLHEP::HepRandomEngine* engine) { if (m_hitResponse->withinBunchRange(bunchCrossing)) { for (std::vector::const_iterator it = hits.begin(), itEnd = hits.end(); it != itEnd; ++it) { m_hitResponse->add(*it, engine); diff --git a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc index f8cc8b2f32005..f6cd078b7f64c 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc @@ -1,5 +1,5 @@ -#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h" -#include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitFilter.h" @@ -14,342 +14,246 @@ #include "CondFormats/EcalObjects/interface/EcalConstants.h" - using namespace ecalPh2; -EBHitResponse_Ph2::EBHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , - const CaloVShape* shape , - bool apdOnly , - const APDSimParameters* apdPars = nullptr , - const CaloVShape* apdShape = nullptr ) : - - EcalHitResponse_Ph2( parameterMap, shape ) , - - m_apdOnly ( apdOnly ) , - m_apdPars ( apdPars ) , - m_apdShape ( apdShape ) , - m_timeOffVec ( kNOffsets, apdParameters()->timeOffset() ) , - pcub ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[0] ) , - pqua ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[1] ) , - plin ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[2] ) , - pcon ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[3] ) , - pelo ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[4] ) , - pehi ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[5] ) , - pasy ( nullptr == apdPars ? 0 : apdParameters()->nonlParms()[6] ) , - pext ( nullptr == apdPars ? 0 : nonlFunc1( pelo ) ) , - poff ( nullptr == apdPars ? 0 : nonlFunc1( pehi ) ) , - pfac ( nullptr == apdPars ? 0 : ( pasy - poff )*2./M_PI ), - m_isInitialized(false) -{ - const EBDetId detId ( EBDetId::detIdFromDenseIndex( 0 ) ) ; - const CaloSimParameters& parameters ( parameterMap->simParameters( detId ) ) ; - - const unsigned int rSize ( parameters.readoutFrameSize() ) ; - const unsigned int nPre ( parameters.binOfMaximum() - 1 ) ; - - const unsigned int size ( EBDetId::kSizeForDenseIndexing ) ; - - m_vSam.reserve( size ) ; - - for( unsigned int i ( 0 ) ; i != size ; ++i ) - { - m_vSam.emplace_back(CaloGenericDetId( detId.det(), detId.subdetId(), i ) , - rSize, nPre ); - } +EBHitResponse_Ph2::EBHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, + const CaloVShape* shape, + bool apdOnly, + const APDSimParameters* apdPars = nullptr, + const CaloVShape* apdShape = nullptr) + : + + EcalHitResponse_Ph2(parameterMap, shape), + + m_apdOnly(apdOnly), + m_apdPars(apdPars), + m_apdShape(apdShape), + m_timeOffVec(kNOffsets, apdParameters()->timeOffset()), + pcub(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[0]), + pqua(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[1]), + plin(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[2]), + pcon(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[3]), + pelo(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[4]), + pehi(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[5]), + pasy(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[6]), + pext(nullptr == apdPars ? 0 : nonlFunc1(pelo)), + poff(nullptr == apdPars ? 0 : nonlFunc1(pehi)), + pfac(nullptr == apdPars ? 0 : (pasy - poff) * 2. / M_PI), + m_isInitialized(false) { + const EBDetId detId(EBDetId::detIdFromDenseIndex(0)); + const CaloSimParameters& parameters(parameterMap->simParameters(detId)); + + const unsigned int rSize(parameters.readoutFrameSize()); + const unsigned int nPre(parameters.binOfMaximum() - 1); + + const unsigned int size(EBDetId::kSizeForDenseIndexing); + + m_vSam.reserve(size); + + for (unsigned int i(0); i != size; ++i) { + m_vSam.emplace_back(CaloGenericDetId(detId.det(), detId.subdetId(), i), rSize, nPre); + } } -EBHitResponse_Ph2::~EBHitResponse_Ph2() -{ -} +EBHitResponse_Ph2::~EBHitResponse_Ph2() {} -void -EBHitResponse_Ph2::initialize(CLHEP::HepRandomEngine* engine) -{ - m_isInitialized = true; - for( unsigned int i ( 0 ) ; i != kNOffsets ; ++i ) - { - m_timeOffVec[ i ] += - CLHEP::RandGaussQ::shoot(engine, 0, apdParameters()->timeOffWidth() ) ; - } +void EBHitResponse_Ph2::initialize(CLHEP::HepRandomEngine* engine) { + m_isInitialized = true; + for (unsigned int i(0); i != kNOffsets; ++i) { + m_timeOffVec[i] += CLHEP::RandGaussQ::shoot(engine, 0, apdParameters()->timeOffWidth()); + } } -const APDSimParameters* -EBHitResponse_Ph2::apdParameters() const -{ - assert ( nullptr != m_apdPars ) ; - return m_apdPars ; +const APDSimParameters* EBHitResponse_Ph2::apdParameters() const { + assert(nullptr != m_apdPars); + return m_apdPars; } -const CaloVShape* -EBHitResponse_Ph2::apdShape() const -{ - assert( nullptr != m_apdShape ) ; - return m_apdShape ; +const CaloVShape* EBHitResponse_Ph2::apdShape() const { + assert(nullptr != m_apdShape); + return m_apdShape; } -void -EBHitResponse_Ph2::putAPDSignal( const DetId& detId , - double npe , - double time ) -{ - const CaloSimParameters& parameters ( *params( detId ) ) ; +void EBHitResponse_Ph2::putAPDSignal(const DetId& detId, double npe, double time) { + const CaloSimParameters& parameters(*params(detId)); - const double energyFac ( 1./parameters.simHitToPhotoelectrons( detId ) ) ; + const double energyFac(1. / parameters.simHitToPhotoelectrons(detId)); -// std::cout<<"******** Input APD Npe="<timeToRise() - - jitter - - offsets()[ EBDetId( detId ).denseIndex()%kNOffsets ] - - BUNCHSPACE*( parameters.binOfMaximum() - - phaseShift() ) ) ; + const double tzero(apdShape()->timeToRise() - jitter - offsets()[EBDetId(detId).denseIndex() % kNOffsets] - + BUNCHSPACE * (parameters.binOfMaximum() - phaseShift())); - double binTime ( tzero ) ; + double binTime(tzero); - EcalSamples& result ( *findSignal( detId ) ); + EcalSamples& result(*findSignal(detId)); - for( unsigned int bin ( 0 ) ; bin != result.size(); ++bin ) - { - result[bin] += (*apdShape())(binTime)*signal ; - binTime += BUNCHSPACE ; - } + for (unsigned int bin(0); bin != result.size(); ++bin) { + result[bin] += (*apdShape())(binTime)*signal; + binTime += BUNCHSPACE; + } } -double -EBHitResponse_Ph2::apdSignalAmplitude( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) const -{ +double EBHitResponse_Ph2::apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) const { int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); - assert( 1 == iddepth || 2 == iddepth ) ; - - double npe ( hit.energy()*( 2 == iddepth ? - apdParameters()->simToPELow() : - apdParameters()->simToPEHigh() ) ) ; + assert(1 == iddepth || 2 == iddepth); - // do we need to do Poisson statistics for the photoelectrons? - if( apdParameters()->doPEStats() && - !m_apdOnly ) { + double npe(hit.energy() * (2 == iddepth ? apdParameters()->simToPELow() : apdParameters()->simToPEHigh())); - CLHEP::RandPoissonQ randPoissonQ(*engine, npe); - npe = randPoissonQ.fire(); - } - assert( nullptr != m_intercal ) ; - double fac ( 1 ) ; - findIntercalibConstant( hit.id(), fac ) ; + // do we need to do Poisson statistics for the photoelectrons? + if (apdParameters()->doPEStats() && !m_apdOnly) { + CLHEP::RandPoissonQ randPoissonQ(*engine, npe); + npe = randPoissonQ.fire(); + } + assert(nullptr != m_intercal); + double fac(1); + findIntercalibConstant(hit.id(), fac); - npe *= fac ; + npe *= fac; -// edm::LogError( "EBHitResponse_Ph2" ) << "--- # photoelectrons for " -/* std::cout << "--- # photoelectrons for " + // edm::LogError( "EBHitResponse_Ph2" ) << "--- # photoelectrons for " + /* std::cout << "--- # photoelectrons for " << EBDetId( hit.id() ) <<" is " << npe //; <getMap() ) ; - EcalIntercalibConstantMCMap::const_iterator icalit ( icalMap.find( detId ) ) ; - if( icalit != icalMap.end() ) - { - thisconst = *icalit ; - if ( thisconst == 0. ) thisconst = 1. ; - } - else - { - edm::LogError("EBHitResponse_Ph2") << "No intercalib const found for xtal " - << detId.rawId() - << "! something wrong with EcalIntercalibConstants in your DB? "; - } - } - icalconst = thisconst ; +void EBHitResponse_Ph2::setIntercal(const EcalIntercalibConstantsMC* ical) { m_intercal = ical; } + +void EBHitResponse_Ph2::findIntercalibConstant(const DetId& detId, double& icalconst) const { + EcalIntercalibConstantMC thisconst(1.); + + if (nullptr == m_intercal) { + edm::LogError("EBHitResponse_Ph2") << "No intercal constant defined for EBHitResponse_Ph2"; + } else { + const EcalIntercalibConstantMCMap& icalMap(m_intercal->getMap()); + EcalIntercalibConstantMCMap::const_iterator icalit(icalMap.find(detId)); + if (icalit != icalMap.end()) { + thisconst = *icalit; + if (thisconst == 0.) + thisconst = 1.; + } else { + edm::LogError("EBHitResponse_Ph2") << "No intercalib const found for xtal " << detId.rawId() + << "! something wrong with EcalIntercalibConstants in your DB? "; + } + } + icalconst = thisconst; } -void -EBHitResponse_Ph2::initializeHits() { - if( !index().empty() ) blankOutUsedSamples() ; +void EBHitResponse_Ph2::initializeHits() { + if (!index().empty()) + blankOutUsedSamples(); - const unsigned int bSize ( EBDetId::kSizeForDenseIndexing ) ; + const unsigned int bSize(EBDetId::kSizeForDenseIndexing); - if( m_apdNpeVec.empty() ) - { - m_apdNpeVec = std::vector( bSize, (double)0.0 ) ; - m_apdTimeVec = std::vector( bSize, (double)0.0 ) ; - } + if (m_apdNpeVec.empty()) { + m_apdNpeVec = std::vector(bSize, (double)0.0); + m_apdTimeVec = std::vector(bSize, (double)0.0); + } } -void -EBHitResponse_Ph2::finalizeHits() { - const unsigned int bSize ( EBDetId::kSizeForDenseIndexing ) ; - if( apdParameters()->addToBarrel() || - m_apdOnly ) - { - for( unsigned int i ( 0 ) ; i != bSize ; ++i ) - { - if( 0 < m_apdNpeVec[i] ) - { - putAPDSignal( EBDetId::detIdFromDenseIndex( i ), - m_apdNpeVec[i] , - m_apdTimeVec[i] ) ; - - // now zero out for next time - m_apdNpeVec[i] = 0. ; - m_apdTimeVec[i] = 0. ; - } +void EBHitResponse_Ph2::finalizeHits() { + const unsigned int bSize(EBDetId::kSizeForDenseIndexing); + if (apdParameters()->addToBarrel() || m_apdOnly) { + for (unsigned int i(0); i != bSize; ++i) { + if (0 < m_apdNpeVec[i]) { + putAPDSignal(EBDetId::detIdFromDenseIndex(i), m_apdNpeVec[i], m_apdTimeVec[i]); + + // now zero out for next time + m_apdNpeVec[i] = 0.; + m_apdTimeVec[i] = 0.; } - } + } + } } -void -EBHitResponse_Ph2::add( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) -{ - if (!edm::isNotFinite( hit.time() ) && ( nullptr == hitFilter() || hitFilter()->accepts( hit ) ) ) { +void EBHitResponse_Ph2::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { + if (!edm::isNotFinite(hit.time()) && (nullptr == hitFilter() || hitFilter()->accepts(hit))) { int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); - if ( 0 == iddepth ) // for now take only nonAPD hits - { - if( !m_apdOnly ) putAnalogSignal( hit, engine ) ; - } - else // APD hits here - { - if( apdParameters()->addToBarrel() || - m_apdOnly ) - { - const unsigned int icell ( EBDetId( hit.id() ).denseIndex() ) ; - m_apdNpeVec[ icell ] += apdSignalAmplitude( hit, engine ) ; - if( 0 == m_apdTimeVec[ icell ] ) m_apdTimeVec[ icell ] = hit.time() ; - } - } + if (0 == iddepth) // for now take only nonAPD hits + { + if (!m_apdOnly) + putAnalogSignal(hit, engine); + } else // APD hits here + { + if (apdParameters()->addToBarrel() || m_apdOnly) { + const unsigned int icell(EBDetId(hit.id()).denseIndex()); + m_apdNpeVec[icell] += apdSignalAmplitude(hit, engine); + if (0 == m_apdTimeVec[icell]) + m_apdTimeVec[icell] = hit.time(); + } + } } } -void -EBHitResponse_Ph2::run( MixCollection& hits, CLHEP::HepRandomEngine* engine ) -{ - if( !index().empty() ) blankOutUsedSamples() ; - - const unsigned int bSize ( EBDetId::kSizeForDenseIndexing ) ; - - if( m_apdNpeVec.empty() ) - { - m_apdNpeVec = std::vector( bSize, (double)0.0 ) ; - m_apdTimeVec = std::vector( bSize, (double)0.0 ) ; - } - - for( MixCollection::MixItr hitItr ( hits.begin() ) ; - hitItr != hits.end() ; ++hitItr ) - { - const PCaloHit& hit ( *hitItr ) ; - const int bunch ( hitItr.bunch() ) ; - if( minBunch() <= bunch && - maxBunch() >= bunch && - !edm::isNotFinite( hit.time() ) && - ( nullptr == hitFilter() || - hitFilter()->accepts( hit ) ) ) - { - int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); - if( 0 == iddepth ) // for now take only nonAPD hits - { - if( !m_apdOnly ) putAnalogSignal( hit, engine ) ; - } - else // APD hits here - { - if( apdParameters()->addToBarrel() || - m_apdOnly ) - { - const unsigned int icell ( EBDetId( hit.id() ).denseIndex() ) ; - m_apdNpeVec[ icell ] += apdSignalAmplitude( hit, engine ) ; - if( 0 == m_apdTimeVec[ icell ] ) m_apdTimeVec[ icell ] = hit.time() ; - } - } +void EBHitResponse_Ph2::run(MixCollection& hits, CLHEP::HepRandomEngine* engine) { + if (!index().empty()) + blankOutUsedSamples(); + + const unsigned int bSize(EBDetId::kSizeForDenseIndexing); + + if (m_apdNpeVec.empty()) { + m_apdNpeVec = std::vector(bSize, (double)0.0); + m_apdTimeVec = std::vector(bSize, (double)0.0); + } + + for (MixCollection::MixItr hitItr(hits.begin()); hitItr != hits.end(); ++hitItr) { + const PCaloHit& hit(*hitItr); + const int bunch(hitItr.bunch()); + if (minBunch() <= bunch && maxBunch() >= bunch && !edm::isNotFinite(hit.time()) && + (nullptr == hitFilter() || hitFilter()->accepts(hit))) { + int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); + if (0 == iddepth) // for now take only nonAPD hits + { + if (!m_apdOnly) + putAnalogSignal(hit, engine); + } else // APD hits here + { + if (apdParameters()->addToBarrel() || m_apdOnly) { + const unsigned int icell(EBDetId(hit.id()).denseIndex()); + m_apdNpeVec[icell] += apdSignalAmplitude(hit, engine); + if (0 == m_apdTimeVec[icell]) + m_apdTimeVec[icell] = hit.time(); + } } - } - - if( apdParameters()->addToBarrel() || - m_apdOnly ) - { - for( unsigned int i ( 0 ) ; i != bSize ; ++i ) - { - if( 0 < m_apdNpeVec[i] ) - { - putAPDSignal( EBDetId::detIdFromDenseIndex( i ), - m_apdNpeVec[i] , - m_apdTimeVec[i] ) ; - - // now zero out for next time - m_apdNpeVec[i] = 0. ; - m_apdTimeVec[i] = 0. ; - } - } - } -} + } + } -unsigned int -EBHitResponse_Ph2::samplesSize() const -{ - return m_vSam.size() ; -} + if (apdParameters()->addToBarrel() || m_apdOnly) { + for (unsigned int i(0); i != bSize; ++i) { + if (0 < m_apdNpeVec[i]) { + putAPDSignal(EBDetId::detIdFromDenseIndex(i), m_apdNpeVec[i], m_apdTimeVec[i]); -unsigned int -EBHitResponse_Ph2::samplesSizeAll() const -{ - return m_vSam.size() ; + // now zero out for next time + m_apdNpeVec[i] = 0.; + m_apdTimeVec[i] = 0.; + } + } + } } -const EcalHitResponse_Ph2::EcalSamples* -EBHitResponse_Ph2::operator[]( unsigned int i ) const -{ - return &m_vSam[ i ] ; -} +unsigned int EBHitResponse_Ph2::samplesSize() const { return m_vSam.size(); } -EcalHitResponse_Ph2::EcalSamples* -EBHitResponse_Ph2::operator[]( unsigned int i ) -{ - return &m_vSam[ i ] ; -} +unsigned int EBHitResponse_Ph2::samplesSizeAll() const { return m_vSam.size(); } -EcalHitResponse_Ph2::EcalSamples* -EBHitResponse_Ph2::vSam( unsigned int i ) -{ - return &m_vSam[ i ] ; -} +const EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::operator[](unsigned int i) const { return &m_vSam[i]; } -EcalHitResponse_Ph2::EcalSamples* -EBHitResponse_Ph2::vSamAll( unsigned int i ) -{ - return &m_vSam[ i ] ; -} +EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::operator[](unsigned int i) { return &m_vSam[i]; } -const EcalHitResponse_Ph2::EcalSamples* -EBHitResponse_Ph2::vSamAll( unsigned int i ) const -{ - return &m_vSam[ i ] ; -} +EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::vSam(unsigned int i) { return &m_vSam[i]; } + +EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::vSamAll(unsigned int i) { return &m_vSam[i]; } + +const EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::vSamAll(unsigned int i) const { return &m_vSam[i]; } diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc index 0f2c67ad800f8..d8e19e92f4fd4 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc @@ -23,261 +23,215 @@ //5 samples prima, il sample saturo e poi 10 samples dopo const float DTUVersion = 1.0; -EcalCoder_Ph2::EcalCoder_Ph2( bool addNoise , - bool PreMix1 , - EcalCoder_Ph2::Noisifier* ebCorrNoise0 , - EcalCoder_Ph2::Noisifier* ebCorrNoise1 ) : - m_peds ( nullptr ) , - m_gainRatios ( nullptr ) , - m_intercals ( nullptr ) , - // m_maxEneEB ( 1668.3 ) , // 4095(MAXADC)*12(gain 2)*0.035(GeVtoADC)*0.97 - m_maxEneEB ( 2000. ) , // Maximum for CATIA: LSB gain 10: 0.048 MeV - m_addNoise ( addNoise ) , - m_PreMix1 ( PreMix1 ) - -{ - m_ebCorrNoise[0] = ebCorrNoise0 ; - assert( nullptr != m_ebCorrNoise[0] ) ; - m_ebCorrNoise[1] = ebCorrNoise1 ; - -} +EcalCoder_Ph2::EcalCoder_Ph2(bool addNoise, + bool PreMix1, + EcalCoder_Ph2::Noisifier* ebCorrNoise0, + EcalCoder_Ph2::Noisifier* ebCorrNoise1) + : m_peds(nullptr), + m_gainRatios(nullptr), + m_intercals(nullptr), + // m_maxEneEB ( 1668.3 ) , // 4095(MAXADC)*12(gain 2)*0.035(GeVtoADC)*0.97 + m_maxEneEB(2000.), // Maximum for CATIA: LSB gain 10: 0.048 MeV + m_addNoise(addNoise), + m_PreMix1(PreMix1) -EcalCoder_Ph2::~EcalCoder_Ph2() { + m_ebCorrNoise[0] = ebCorrNoise0; + assert(nullptr != m_ebCorrNoise[0]); + m_ebCorrNoise[1] = ebCorrNoise1; } -void -EcalCoder_Ph2::setFullScaleEnergy( double EBscale ) -{ +EcalCoder_Ph2::~EcalCoder_Ph2() {} + +void EcalCoder_Ph2::setFullScaleEnergy(double EBscale) { // m_maxEneEB = EBscale ; - m_maxEneEB = 2000. ; //I don 't know where is setFullScaleEnergy first call - + m_maxEneEB = 2000.; //I don 't know where is setFullScaleEnergy first call } +void EcalCoder_Ph2::setPedestals(const EcalLiteDTUPedestals* pedestals) { m_peds = pedestals; } -void -EcalCoder_Ph2::setPedestals( const EcalLiteDTUPedestals* pedestals ) -{ - m_peds = pedestals ; -} +void EcalCoder_Ph2::setGainRatios(const EcalCATIAGainRatios* gainRatios) { m_gainRatios = gainRatios; } -void -EcalCoder_Ph2::setGainRatios( const EcalCATIAGainRatios* gainRatios ) -{ - m_gainRatios = gainRatios ; -} - -void -EcalCoder_Ph2::setIntercalibConstants( const EcalIntercalibConstantsMC* ical ) -{ - m_intercals = ical ; -} +void EcalCoder_Ph2::setIntercalibConstants(const EcalIntercalibConstantsMC* ical) { m_intercals = ical; } -double -EcalCoder_Ph2::fullScaleEnergy( const DetId & detId ) const -{ - //return detId.subdetId() == EcalBarrel ? m_maxEneEB : m_maxEneEE ; - return m_maxEneEB ; +double EcalCoder_Ph2::fullScaleEnergy(const DetId& detId) const { + //return detId.subdetId() == EcalBarrel ? m_maxEneEB : m_maxEneEE ; + return m_maxEneEB; } -void -EcalCoder_Ph2::analogToDigital( CLHEP::HepRandomEngine* engine, - const EcalSamples& clf , - EcalDataFrame& df ) const -{ - df.setSize( clf.size() ) ; - encode( clf, df, engine ); - +void EcalCoder_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, const EcalSamples& clf, EcalDataFrame& df) const { + df.setSize(clf.size()); + encode(clf, df, engine); } -void -EcalCoder_Ph2::encode( const EcalSamples& ecalSamples , - EcalDataFrame& df, - CLHEP::HepRandomEngine* engine ) const -{ - assert( nullptr != m_peds ) ; - - const unsigned int csize ( ecalSamples.size() ) ; - - - DetId detId = ecalSamples.id(); - double Emax = fullScaleEnergy(detId); - - //....initialisation - if ( ecalSamples[5] > 0. ) LogDebug("EcalCoder_Ph2") << "Input caloSample" << "\n" << ecalSamples; - - - //N Gains set to 2 in the .h - double pedestals[ecalPh2::NGAINS]; - double widths[ecalPh2::NGAINS]; - //float gains[ecalPh2::NGAINS]; - double LSB[ecalPh2::NGAINS]; - double trueRMS[ecalPh2::NGAINS]; - - - double icalconst = 1. ; - findIntercalibConstant( detId, icalconst ); - - - for( unsigned int igain ( 0 ); igain < NGAINS ; ++igain ) - { - // fill in the pedestal and width - - findPedestal( detId , - igain , - pedestals[igain] , - widths[igain] ) ; - //I insert an absolute value in the trueRMS - trueRMS[igain] = std::sqrt( std::fabs(widths[igain]*widths[igain] - 1./12.) ) ; - - // set nominal value first - //findGains( detId , gains ); - - LSB[igain]= Emax/(MAXADC*ecalPh2::gains[igain]); - - - } - - CaloSamples noiseframe[] = { CaloSamples( detId , csize ) , - CaloSamples( detId , csize ) , - } ; - - const Noisifier* noisy[NGAINS] = { m_ebCorrNoise[0],m_ebCorrNoise[1]} ; - - if( m_addNoise ){ - - #warning noise generation to be checked - noisy[0]->noisify( noiseframe[0], engine ) ; // high gain - //if( nullptr == noisy[1] ) noisy[0]->noisify( noiseframe[1] , - // engine, - // &noisy[0]->vecgau() ) ; // lwo gain - noisy[1]->noisify( noiseframe[1], engine ) ; // low gain - } - - - bool isSaturated[]={false,false}; - std::vector> adctrace(csize); - unsigned int saturatedSample[]={0,0}; - - for( unsigned int i ( 0 ) ; i != csize ; ++i ) adctrace[i].resize(NGAINS); - - for (unsigned int igain=0; igain MAXADC) { - adc = MAXADC; - isSaturated[igain] = true; - saturatedSample[igain] = i; - } - - if (isSaturated[0] && igain==0) { - break; // gain 0 (x10) channel is saturated, readout will use gain 1 (x10) - } - else adctrace[i][igain]=adc; - - if(ecalSamples[i]>0.) - { - // std::cout<<" igain = "<noisify(noiseframe[0], engine); // high gain + //if( nullptr == noisy[1] ) noisy[0]->noisify( noiseframe[1] , + // engine, + // &noisy[0]->vecgau() ) ; // lwo gain + noisy[1]->noisify(noiseframe[1], engine); // low gain + } + + bool isSaturated[] = {false, false}; + std::vector> adctrace(csize); + unsigned int saturatedSample[] = {0, 0}; + + for (unsigned int i(0); i != csize; ++i) + adctrace[i].resize(NGAINS); + + for (unsigned int igain = 0; igain < NGAINS; ++igain) { + for (unsigned int i(0); i != csize; ++i) { + adctrace[i][igain] = -1; + } + } + + // fill ADC trace in gain 0 (x10) and gain 1 (x1) + //NOTE: Before was pedestals[igain], widths[igain] + + for (unsigned int igain = 0; igain < NGAINS; ++igain) { + for (unsigned int i(0); i != csize; ++i) { + double asignal = 0; + + if (!m_PreMix1) { + asignal = + pedestals[igain] + ecalSamples[i] / (LSB[igain] * icalconst) + + trueRMS[igain] * + noiseframe + [igain] + [i]; //Analog signal value for each sample in ADC. It is corrected by the intercalibration constants + + } else { + // no noise nor pedestal when premixing + asignal = ecalSamples[i] / (LSB[igain] * icalconst); + } + int isignal = asignal; + + int adc = asignal - (double)isignal < 0.5 ? isignal : isignal + 1; + if (adc > MAXADC) { + adc = MAXADC; + isSaturated[igain] = true; + saturatedSample[igain] = i; + } + + if (isSaturated[0] && igain == 0) { + break; // gain 0 (x10) channel is saturated, readout will use gain 1 (x10) + } else + adctrace[i][igain] = adc; + + if (ecalSamples[i] > 0.) { + // std::cout<<" igain = "<getMap().size(); - } + if ((detId.subdetId() != EcalBarrel) && (detId.subdetId() != EcalEndcap)) { + edm::LogError("EcalCoder_Ph2") << "Could not find pedestal for " << detId.rawId() << " among the " + << m_peds->getMap().size(); + } - - LogDebug("EcalCoder_Ph2") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" << "Mean = " << ped << " rms = " << width; + LogDebug("EcalCoder_Ph2") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" + << "Mean = " << ped << " rms = " << width; } - -// void +// void // EcalCoder::findGains( const DetId & detId , float Gains[] ) const // { // EcalCATIAGainRatioMap::const_iterator grit = m_gainRatios->getMap().find( detId ); // Gains[1] = 1.; // Gains[0] = Gains[1]*(*grit); - -// if ( (detId.subdetId() != EcalBarrel) && (detId.subdetId() != EcalEndcap) ) -// { + +// if ( (detId.subdetId() != EcalBarrel) && (detId.subdetId() != EcalEndcap) ) +// { // edm::LogError("EcalCoder") << "Could not find gain ratios for " << detId.rawId() << " among the " << m_gainRatios->getMap().size(); -// } - +// } + // } -void -EcalCoder_Ph2::findIntercalibConstant( const DetId& detId, - double& icalconst ) const -{ - EcalIntercalibConstantMC thisconst = 1.; - // find intercalib constant for this xtal - const EcalIntercalibConstantMCMap &icalMap = m_intercals->getMap(); - EcalIntercalibConstantMCMap::const_iterator icalit = icalMap.find(detId); - if( icalit!=icalMap.end() ) - { - thisconst = (*icalit); - if ( icalconst == 0. ) { thisconst = 1.; } - } - else - { - edm::LogError("EcalCoder_Ph2") << "No intercalib const found for xtal " << detId.rawId() << "! something wrong with EcalIntercalibConstants in your DB? "; - } - icalconst = thisconst; +void EcalCoder_Ph2::findIntercalibConstant(const DetId& detId, double& icalconst) const { + EcalIntercalibConstantMC thisconst = 1.; + // find intercalib constant for this xtal + const EcalIntercalibConstantMCMap& icalMap = m_intercals->getMap(); + EcalIntercalibConstantMCMap::const_iterator icalit = icalMap.find(detId); + if (icalit != icalMap.end()) { + thisconst = (*icalit); + if (icalconst == 0.) { + thisconst = 1.; + } + } else { + edm::LogError("EcalCoder_Ph2") << "No intercalib const found for xtal " << detId.rawId() + << "! something wrong with EcalIntercalibConstants in your DB? "; + } + icalconst = thisconst; } diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc index d120016ba2191..c99fa779c36b8 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix_Ph2.cc @@ -1,12 +1,8 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h" #include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.icc" -template class CorrelatedNoisifier< EcalCorrMatrix_Ph2 > ; - -template -void -CorrelatedNoisifier< EcalCorrMatrix_Ph2 >::noisify(CaloSamples&, - CLHEP::HepRandomEngine*, - const std::vector* rangau ) const ; - +template class CorrelatedNoisifier; +template void CorrelatedNoisifier::noisify(CaloSamples&, + CLHEP::HepRandomEngine*, + const std::vector* rangau) const; diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc index 2b54905be00e3..30e6907ce2dd6 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc @@ -11,16 +11,16 @@ #include EcalElectronicsSim_Ph2::EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, - EcalCoder_Ph2* coder, - bool applyConstantTerm, - double rmsConstantTerm) + EcalCoder_Ph2* coder, + bool applyConstantTerm, + double rmsConstantTerm) : m_simMap(parameterMap), m_theCoder(coder), m_thisCT(rmsConstantTerm), m_applyConstantTerm(applyConstantTerm) {} EcalElectronicsSim_Ph2::~EcalElectronicsSim_Ph2() {} void EcalElectronicsSim_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, - EcalElectronicsSim_Ph2::EcalSamples& clf, - EcalDataFrame& df) const { + EcalElectronicsSim_Ph2::EcalSamples& clf, + EcalDataFrame& df) const { //PG input signal is in pe. Converted in GeV amplify(clf, engine); diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc index 1ea5c78bc0d83..3c3d03086793d 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc @@ -1,4 +1,4 @@ -#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVShape.h" @@ -14,340 +14,233 @@ #include "FWCore/Utilities/interface/isFinite.h" #include "CLHEP/Units/GlobalPhysicalConstants.h" -#include "CLHEP/Units/GlobalSystemOfUnits.h" +#include "CLHEP/Units/GlobalSystemOfUnits.h" #include #include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h" - #include "CondFormats/EcalObjects/interface/EcalConstants.h" +EcalHitResponse_Ph2::EcalHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape) + : m_parameterMap(parameterMap), + m_shape(shape), + m_hitCorrection(nullptr), + m_PECorrection(nullptr), + m_hitFilter(nullptr), + m_geometry(nullptr), + m_lasercals(nullptr), + m_minBunch(-32), + m_maxBunch(10), + m_phaseShift(1), + m_iTime(0), + m_useLCcorrection(false) {} +EcalHitResponse_Ph2::~EcalHitResponse_Ph2() {} -EcalHitResponse_Ph2::EcalHitResponse_Ph2( const CaloVSimParameterMap* parameterMap , - const CaloVShape* shape ) : - m_parameterMap ( parameterMap ) , - m_shape ( shape ) , - m_hitCorrection ( nullptr ) , - m_PECorrection ( nullptr ) , - m_hitFilter ( nullptr ) , - m_geometry ( nullptr ) , - m_lasercals ( nullptr ) , - m_minBunch ( -32 ) , - m_maxBunch ( 10 ) , - m_phaseShift ( 1 ) , - m_iTime ( 0 ) , - m_useLCcorrection ( false ) -{ +const CaloSimParameters* EcalHitResponse_Ph2::params(const DetId& detId) const { + assert(nullptr != m_parameterMap); + return &m_parameterMap->simParameters(detId); } -EcalHitResponse_Ph2::~EcalHitResponse_Ph2() -{ +const CaloVShape* EcalHitResponse_Ph2::shape() const { + assert(nullptr != m_shape); + return m_shape; } -const CaloSimParameters* -EcalHitResponse_Ph2::params( const DetId& detId ) const -{ - assert( nullptr != m_parameterMap ) ; - return &m_parameterMap->simParameters( detId ) ; +const CaloSubdetectorGeometry* EcalHitResponse_Ph2::geometry() const { + assert(nullptr != m_geometry); + return m_geometry; } -const CaloVShape* -EcalHitResponse_Ph2::shape() const -{ - assert( nullptr != m_shape ) ; - return m_shape ; +void EcalHitResponse_Ph2::setBunchRange(int minBunch, int maxBunch) { + m_minBunch = minBunch; + m_maxBunch = maxBunch; } -const CaloSubdetectorGeometry* -EcalHitResponse_Ph2::geometry() const -{ - assert( nullptr != m_geometry ) ; - return m_geometry ; -} +void EcalHitResponse_Ph2::setGeometry(const CaloSubdetectorGeometry* geometry) { m_geometry = geometry; } -void -EcalHitResponse_Ph2::setBunchRange( int minBunch , - int maxBunch ) -{ - m_minBunch = minBunch ; - m_maxBunch = maxBunch ; -} +void EcalHitResponse_Ph2::setPhaseShift(double phaseShift) { m_phaseShift = phaseShift; } -void -EcalHitResponse_Ph2::setGeometry( const CaloSubdetectorGeometry* geometry ) -{ - m_geometry = geometry ; -} +double EcalHitResponse_Ph2::phaseShift() const { return m_phaseShift; } -void -EcalHitResponse_Ph2::setPhaseShift( double phaseShift ) -{ - m_phaseShift = phaseShift ; -} +void EcalHitResponse_Ph2::setHitFilter(const CaloVHitFilter* filter) { m_hitFilter = filter; } -double -EcalHitResponse_Ph2::phaseShift() const -{ - return m_phaseShift ; -} +void EcalHitResponse_Ph2::setHitCorrection(const CaloVHitCorrection* hitCorrection) { m_hitCorrection = hitCorrection; } -void -EcalHitResponse_Ph2::setHitFilter( const CaloVHitFilter* filter) -{ - m_hitFilter = filter ; -} +void EcalHitResponse_Ph2::setPECorrection(const CaloVPECorrection* peCorrection) { m_PECorrection = peCorrection; } -void -EcalHitResponse_Ph2::setHitCorrection( const CaloVHitCorrection* hitCorrection) -{ - m_hitCorrection = hitCorrection ; -} - -void -EcalHitResponse_Ph2::setPECorrection( const CaloVPECorrection* peCorrection ) -{ - m_PECorrection = peCorrection ; -} - -void -EcalHitResponse_Ph2::setEventTime(const edm::TimeValue_t& iTime) -{ +void EcalHitResponse_Ph2::setEventTime(const edm::TimeValue_t& iTime) { m_iTime = iTime; //clear the laser cache for each event time - CalibCache().swap(m_laserCalibCache); + CalibCache().swap(m_laserCalibCache); } -void -EcalHitResponse_Ph2::setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection) -{ +void EcalHitResponse_Ph2::setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection) { m_lasercals = laser; m_useLCcorrection = useLCcorrection; } -void -EcalHitResponse_Ph2::blankOutUsedSamples() // blank out previously used elements +void EcalHitResponse_Ph2::blankOutUsedSamples() // blank out previously used elements { - const unsigned int size ( m_index.size() ) ; - - for( unsigned int i ( 0 ) ; i != size ; ++i ) - { - vSamAll( m_index[i] )->setZero() ; - } - m_index.erase( m_index.begin() , // done and make ready to start over - m_index.end() ) ; + const unsigned int size(m_index.size()); + + for (unsigned int i(0); i != size; ++i) { + vSamAll(m_index[i])->setZero(); + } + m_index.erase(m_index.begin(), // done and make ready to start over + m_index.end()); } -void -EcalHitResponse_Ph2::add( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) -{ - if (!edm::isNotFinite( hit.time() ) && ( nullptr == m_hitFilter || m_hitFilter->accepts( hit ) ) ) { - putAnalogSignal( hit, engine ) ; +void EcalHitResponse_Ph2::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { + if (!edm::isNotFinite(hit.time()) && (nullptr == m_hitFilter || m_hitFilter->accepts(hit))) { + putAnalogSignal(hit, engine); } } -void -EcalHitResponse_Ph2::add( const CaloSamples& hit ) -{ - const DetId detId ( hit.id() ) ; +void EcalHitResponse_Ph2::add(const CaloSamples& hit) { + const DetId detId(hit.id()); - EcalSamples& result ( *findSignal( detId ) ) ; + EcalSamples& result(*findSignal(detId)); - const int rsize ( result.size() ) ; + const int rsize(result.size()); - if(rsize != hit.size()) { - throw cms::Exception("EcalDigitization") - << "CaloSamples and EcalSamples have different sizes. Type Mismatach"; + if (rsize != hit.size()) { + throw cms::Exception("EcalDigitization") << "CaloSamples and EcalSamples have different sizes. Type Mismatach"; } - for( int bin ( 0 ) ; bin != rsize ; ++bin ) - { - result[ bin ] += hit[ bin ] ; - } + for (int bin(0); bin != rsize; ++bin) { + result[bin] += hit[bin]; + } - std::cout << "rsize: " << rsize << " hit.size: " << hit.size() << "\n" << std::endl; //Not printed. Function apparently never used + std::cout << "rsize: " << rsize << " hit.size: " << hit.size() << "\n" + << std::endl; //Not printed. Function apparently never used } - -bool -EcalHitResponse_Ph2::withinBunchRange(int bunchCrossing) const -{ - return(m_minBunch <= bunchCrossing && m_maxBunch >= bunchCrossing); +bool EcalHitResponse_Ph2::withinBunchRange(int bunchCrossing) const { + return (m_minBunch <= bunchCrossing && m_maxBunch >= bunchCrossing); } -void -EcalHitResponse_Ph2::initializeHits() -{ - blankOutUsedSamples() ; -} +void EcalHitResponse_Ph2::initializeHits() { blankOutUsedSamples(); } -void -EcalHitResponse_Ph2::finalizeHits() -{ -} +void EcalHitResponse_Ph2::finalizeHits() {} -void -EcalHitResponse_Ph2::run( MixCollection& hits, CLHEP::HepRandomEngine* engine ) -{ +void EcalHitResponse_Ph2::run(MixCollection& hits, CLHEP::HepRandomEngine* engine) { + blankOutUsedSamples(); - - - blankOutUsedSamples() ; - - for( MixCollection::MixItr hitItr ( hits.begin() ) ; - hitItr != hits.end() ; ++hitItr ) - { - const PCaloHit& hit ( *hitItr ) ; - const int bunch ( hitItr.bunch() ) ; - if( withinBunchRange(bunch) && - !edm::isNotFinite( hit.time() ) && - ( nullptr == m_hitFilter || - m_hitFilter->accepts( hit ) ) ) putAnalogSignal( hit, engine ) ; - } - + for (MixCollection::MixItr hitItr(hits.begin()); hitItr != hits.end(); ++hitItr) { + const PCaloHit& hit(*hitItr); + const int bunch(hitItr.bunch()); + if (withinBunchRange(bunch) && !edm::isNotFinite(hit.time()) && + (nullptr == m_hitFilter || m_hitFilter->accepts(hit))) + putAnalogSignal(hit, engine); + } } -void -EcalHitResponse_Ph2::putAnalogSignal( const PCaloHit& hit, CLHEP::HepRandomEngine* engine ) -{ +void EcalHitResponse_Ph2::putAnalogSignal(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { + //const EBShape* sh=dynamic_cast (shape()); + //EBShape* csh = const_cast(sh); + //std::cout << " Cast result" << csh << std::endl; + //if (csh) csh->m_shape_print("newshape.txt"); - //const EBShape* sh=dynamic_cast (shape()); - //EBShape* csh = const_cast(sh); - //std::cout << " Cast result" << csh << std::endl; - //if (csh) csh->m_shape_print("newshape.txt"); - - const DetId detId ( hit.id() ) ; + const DetId detId(hit.id()); - const CaloSimParameters* parameters ( params( detId ) ) ; - - const double signal ( analogSignalAmplitude( detId, hit.energy(), engine ) ) ; //Signal amplitude in number of photoelectrons (npe) + const CaloSimParameters* parameters(params(detId)); - double time = hit.time(); + const double signal( + analogSignalAmplitude(detId, hit.energy(), engine)); //Signal amplitude in number of photoelectrons (npe) - if(m_hitCorrection) { - time += m_hitCorrection->delay( hit, engine ) ; - } + double time = hit.time(); - const double jitter ( time - timeOfFlight( detId ) ) ; + if (m_hitCorrection) { + time += m_hitCorrection->delay(hit, engine); + } - const double tzero = ( shape()->timeToRise() - + parameters->timePhase() - - jitter - - ecalPh2::BUNCHSPACE*( parameters->binOfMaximum() - m_phaseShift ) ) ; - double binTime ( tzero ) ; + const double jitter(time - timeOfFlight(detId)); - EcalSamples& result ( *findSignal( detId ) ) ; + const double tzero = (shape()->timeToRise() + parameters->timePhase() - jitter - + ecalPh2::BUNCHSPACE * (parameters->binOfMaximum() - m_phaseShift)); + double binTime(tzero); - const unsigned int rsize ( result.size() ) ; + EcalSamples& result(*findSignal(detId)); - EBDetId ebid(detId); + const unsigned int rsize(result.size()); - if (hit.energy() > 1.0){ + EBDetId ebid(detId); - for( unsigned int bin ( 0 ) ; bin != rsize ; ++bin ){ - - result[ bin ] += (*shape())( binTime )*signal ; + if (hit.energy() > 1.0) { + for (unsigned int bin(0); bin != rsize; ++bin) { + result[bin] += (*shape())(binTime)*signal; - binTime += ecalPh2::BUNCHSPACE; - } - } + binTime += ecalPh2::BUNCHSPACE; + } + } } -double -EcalHitResponse_Ph2::findLaserConstant(const DetId& detId) const -{ +double EcalHitResponse_Ph2::findLaserConstant(const DetId& detId) const { const edm::Timestamp& evtTimeStamp = edm::Timestamp(m_iTime); return (m_lasercals->getLaserCorrection(detId, evtTimeStamp)); } -EcalHitResponse_Ph2::EcalSamples* -EcalHitResponse_Ph2::findSignal( const DetId& detId ) -{ - const unsigned int di ( CaloGenericDetId( detId ).denseIndex() ) ; - EcalSamples* result ( vSamAll( di ) ) ; +EcalHitResponse_Ph2::EcalSamples* EcalHitResponse_Ph2::findSignal(const DetId& detId) { + const unsigned int di(CaloGenericDetId(detId).denseIndex()); + EcalSamples* result(vSamAll(di)); - if( result->zero() ) m_index.push_back( di ) ; - return result ; + if (result->zero()) + m_index.push_back(di); + return result; } -double -EcalHitResponse_Ph2::analogSignalAmplitude( const DetId& detId, double energy, CLHEP::HepRandomEngine* engine ) -{ - const CaloSimParameters& parameters ( *params( detId ) ) ; - - // OK, the "energy" in the hit could be a real energy, deposited energy, - // or pe count. This factor converts to photoelectrons - - double lasercalib = 1.; - if(m_useLCcorrection == true && detId.subdetId() != 3) { - auto cache = m_laserCalibCache.find(detId); - if( cache != m_laserCalibCache.end() ) { - lasercalib = cache->second; - } else { - lasercalib = 1.0/findLaserConstant(detId); - m_laserCalibCache.emplace(detId,lasercalib); - } - } - - double npe ( energy*lasercalib*parameters.simHitToPhotoelectrons( detId ) ) ; - - // do we need to doPoisson statistics for the photoelectrons? Yes, otherwise we just get the "mean value" - if( parameters.doPhotostatistics() ) { - npe = CLHEP::RandPoissonQ::shoot(engine, npe); - } - if( nullptr != m_PECorrection ) npe = m_PECorrection->correctPE( detId, npe, engine ) ; - - return npe ; -} +double EcalHitResponse_Ph2::analogSignalAmplitude(const DetId& detId, double energy, CLHEP::HepRandomEngine* engine) { + const CaloSimParameters& parameters(*params(detId)); -double -EcalHitResponse_Ph2::timeOfFlight( const DetId& detId ) const -{ - auto cellGeometry ( geometry()->getGeometry( detId ) ) ; - assert( nullptr != cellGeometry ) ; - return cellGeometry->getPosition().mag()*cm/c_light ; // Units of c_light: mm/ns -} + // OK, the "energy" in the hit could be a real energy, deposited energy, + // or pe count. This factor converts to photoelectrons -void -EcalHitResponse_Ph2::add( const EcalSamples* pSam ) -{ - EcalSamples& sam ( *findSignal( pSam->id() ) ) ; - sam += (*pSam) ; -} + double lasercalib = 1.; + if (m_useLCcorrection == true && detId.subdetId() != 3) { + auto cache = m_laserCalibCache.find(detId); + if (cache != m_laserCalibCache.end()) { + lasercalib = cache->second; + } else { + lasercalib = 1.0 / findLaserConstant(detId); + m_laserCalibCache.emplace(detId, lasercalib); + } + } -int -EcalHitResponse_Ph2::minBunch() const -{ - return m_minBunch ; -} + double npe(energy * lasercalib * parameters.simHitToPhotoelectrons(detId)); -int -EcalHitResponse_Ph2::maxBunch() const -{ - return m_maxBunch ; -} + // do we need to doPoisson statistics for the photoelectrons? Yes, otherwise we just get the "mean value" + if (parameters.doPhotostatistics()) { + npe = CLHEP::RandPoissonQ::shoot(engine, npe); + } + if (nullptr != m_PECorrection) + npe = m_PECorrection->correctPE(detId, npe, engine); -EcalHitResponse_Ph2::VecInd& -EcalHitResponse_Ph2::index() -{ - return m_index ; + return npe; } -const EcalHitResponse_Ph2::VecInd& -EcalHitResponse_Ph2::index() const -{ - return m_index ; +double EcalHitResponse_Ph2::timeOfFlight(const DetId& detId) const { + auto cellGeometry(geometry()->getGeometry(detId)); + assert(nullptr != cellGeometry); + return cellGeometry->getPosition().mag() * cm / c_light; // Units of c_light: mm/ns } -const CaloVHitFilter* -EcalHitResponse_Ph2::hitFilter() const -{ - return m_hitFilter ; +void EcalHitResponse_Ph2::add(const EcalSamples* pSam) { + EcalSamples& sam(*findSignal(pSam->id())); + sam += (*pSam); } -const EcalHitResponse_Ph2::EcalSamples* -EcalHitResponse_Ph2::findDetId( const DetId& detId ) const -{ - const unsigned int di ( CaloGenericDetId( detId ).denseIndex() ) ; - return vSamAll( di ) ; +int EcalHitResponse_Ph2::minBunch() const { return m_minBunch; } + +int EcalHitResponse_Ph2::maxBunch() const { return m_maxBunch; } + +EcalHitResponse_Ph2::VecInd& EcalHitResponse_Ph2::index() { return m_index; } + +const EcalHitResponse_Ph2::VecInd& EcalHitResponse_Ph2::index() const { return m_index; } + +const CaloVHitFilter* EcalHitResponse_Ph2::hitFilter() const { return m_hitFilter; } + +const EcalHitResponse_Ph2::EcalSamples* EcalHitResponse_Ph2::findDetId(const DetId& detId) const { + const unsigned int di(CaloGenericDetId(detId).denseIndex()); + return vSamAll(di); } diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc index 14bea503c0d0e..33e073a23c3c6 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc @@ -2,48 +2,53 @@ #include "DataFormats/DetId/interface/DetId.h" #include "DataFormats/EcalDetId/interface/EcalSubdetector.h" #include - + /** Relevant constants are: 4.5 photoelectrons per MeV (J. Nash's slides) APD gain 50, but analog signal stays in GeV Account for excess noise factor */ - -EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2() : - theBarrelParameters(2250., 1./2250., 1., 0, 16, 6, true, true), - //theEndcapParameters(1800., 1./1800., 1., 0, 16, 6, true, true), - theESParameters(1., 1., 1., 20., 3, 2, false, true) -{} -EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, - //double simHitToPhotoelectronsEndcap, - double photoelectronsToAnalogBarrel, - //double photoelectronsToAnalogEndcap, - double samplingFactor, double timePhase, - int readoutFrameSize, int binOfMaximum, - bool doPhotostatistics, bool syncPhase) : - theBarrelParameters(simHitToPhotoelectronsBarrel, photoelectronsToAnalogBarrel, - samplingFactor, timePhase, - readoutFrameSize, binOfMaximum, doPhotostatistics, syncPhase), - //theEndcapParameters(simHitToPhotoelectronsEndcap, photoelectronsToAnalogEndcap, - //samplingFactor, timePhase, - //readoutFrameSize, binOfMaximum, doPhotostatistics, syncPhase), - theESParameters(1., 1., 1., 20., 3, 2, false, syncPhase) -{} +EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2() + : theBarrelParameters(2250., 1. / 2250., 1., 0, 16, 6, true, true), + //theEndcapParameters(1800., 1./1800., 1., 0, 16, 6, true, true), + theESParameters(1., 1., 1., 20., 3, 2, false, true) {} + +EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, + //double simHitToPhotoelectronsEndcap, + double photoelectronsToAnalogBarrel, + //double photoelectronsToAnalogEndcap, + double samplingFactor, + double timePhase, + int readoutFrameSize, + int binOfMaximum, + bool doPhotostatistics, + bool syncPhase) + : theBarrelParameters(simHitToPhotoelectronsBarrel, + photoelectronsToAnalogBarrel, + samplingFactor, + timePhase, + readoutFrameSize, + binOfMaximum, + doPhotostatistics, + syncPhase), + //theEndcapParameters(simHitToPhotoelectronsEndcap, photoelectronsToAnalogEndcap, + //samplingFactor, timePhase, + //readoutFrameSize, binOfMaximum, doPhotostatistics, syncPhase), + theESParameters(1., 1., 1., 20., 3, 2, false, syncPhase) {} - /* +/* CaloSimParameters(double simHitToPhotoelectrons, double photoelectronsToAnalog, double samplingFactor, double timePhase, int readoutFrameSize, int binOfMaximum, bool doPhotostatistics, bool syncPhase) */ - -const CaloSimParameters & EcalSimParameterMap_Ph2::simParameters(const DetId & detId) const -{ - if (EcalSubdetector(detId.subdetId()) == EcalBarrel) + +const CaloSimParameters& EcalSimParameterMap_Ph2::simParameters(const DetId& detId) const { + if (EcalSubdetector(detId.subdetId()) == EcalBarrel) return theBarrelParameters; //else if (EcalSubdetector(detId.subdetId()) == EcalEndcap) - //return theEndcapParameters; - else + //return theEndcapParameters; + else return theESParameters; } diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h index f3d9a916d4f20..74bbb5f895385 100644 --- a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h +++ b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h @@ -13,111 +13,111 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h" #include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" - #include -typedef EcalTDigitizer_Ph2 EBDigitizer_Ph2 ; - +typedef EcalTDigitizer_Ph2 EBDigitizer_Ph2; -class APDSimParameters ; -class EBHitResponse_Ph2 ; -class CaloHitResponse ; -class EcalSimParameterMap_Ph2 ; -class EcalCoder_Ph2 ; -class EcalElectronicsSim_Ph2 ; +class APDSimParameters; +class EBHitResponse_Ph2; +class CaloHitResponse; +class EcalSimParameterMap_Ph2; +class EcalCoder_Ph2; +class EcalElectronicsSim_Ph2; class EcalBaseSignalGenerator; -class CaloGeometry ; -class EBDigiCollectionPh2 ; -class PileUpEventPrincipal ; +class CaloGeometry; +class EBDigiCollectionPh2; +class PileUpEventPrincipal; namespace edm { class ConsumesCollector; class ProducerBase; class Event; class EventSetup; - template class Handle; + template + class Handle; class ParameterSet; class StreamID; -} +} // namespace edm namespace CLHEP { class HepRandomEngine; } class EcalDigiProducer_Ph2 : public DigiAccumulatorMixMod { - public: - - EcalDigiProducer_Ph2( const edm::ParameterSet& params , edm::ProducesCollector producesCollector, edm::ConsumesCollector& iC); - EcalDigiProducer_Ph2( const edm::ParameterSet& params , edm::ConsumesCollector& iC); - ~EcalDigiProducer_Ph2() override; +public: + EcalDigiProducer_Ph2(const edm::ParameterSet& params, + edm::ProducesCollector producesCollector, + edm::ConsumesCollector& iC); + EcalDigiProducer_Ph2(const edm::ParameterSet& params, edm::ConsumesCollector& iC); + ~EcalDigiProducer_Ph2() override; - void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override; - void accumulate(edm::Event const& e, edm::EventSetup const& c) override; - void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override; - void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override; - void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) override; - void beginRun(edm::Run const& run, edm::EventSetup const& setup) override; + void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override; + void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override; + void beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) override; + void beginRun(edm::Run const& run, edm::EventSetup const& setup) override; - void setEBNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator); + void setEBNoiseSignalGenerator(EcalBaseSignalGenerator* noiseGenerator); - private: +private: + virtual void cacheEBDigis(const EBDigiCollectionPh2* ebDigiPtr) const {} - virtual void cacheEBDigis( const EBDigiCollectionPh2* ebDigiPtr ) const { } + typedef edm::Handle > HitsHandle; + void accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing); - typedef edm::Handle > HitsHandle; - void accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing); + void checkGeometry(const edm::EventSetup& eventSetup); - void checkGeometry(const edm::EventSetup& eventSetup) ; + void updateGeometry(); - void updateGeometry() ; + void checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup); - void checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup) ; + APDShape m_APDShape; + EBShape m_EBShape; - APDShape m_APDShape ; - EBShape m_EBShape ; + const std::string m_EBdigiCollection; + const std::string m_hitsProducerTag; - const std::string m_EBdigiCollection ; - const std::string m_hitsProducerTag ; + bool m_useLCcorrection; - bool m_useLCcorrection; + const bool m_apdSeparateDigi; - const bool m_apdSeparateDigi ; + const double m_EBs25notCont; - const double m_EBs25notCont ; + const unsigned int m_readoutFrameSize; - const unsigned int m_readoutFrameSize ; - protected: - std::unique_ptr m_ParameterMap ; - private: - const std::string m_apdDigiTag ; - std::unique_ptr m_apdParameters ; +protected: + std::unique_ptr m_ParameterMap; - std::unique_ptr m_APDResponse ; - protected: - std::unique_ptr m_EBResponse ; - private: +private: + const std::string m_apdDigiTag; + std::unique_ptr m_apdParameters; + std::unique_ptr m_APDResponse; - const bool m_PreMix1 ; - const bool m_PreMix2 ; +protected: + std::unique_ptr m_EBResponse; - const bool m_doEB; +private: + const bool m_PreMix1; + const bool m_PreMix2; + const bool m_doEB; - std::unique_ptr m_APDDigitizer ; - std::unique_ptr m_BarrelDigitizer ; + std::unique_ptr m_APDDigitizer; + std::unique_ptr m_BarrelDigitizer; - std::unique_ptr m_ElectronicsSim ; - std::unique_ptr m_Coder ; + std::unique_ptr m_ElectronicsSim; + std::unique_ptr m_Coder; - std::unique_ptr m_APDElectronicsSim ; - std::unique_ptr m_APDCoder ; + std::unique_ptr m_APDElectronicsSim; + std::unique_ptr m_APDCoder; - const CaloGeometry* m_Geometry ; + const CaloGeometry* m_Geometry; - std::array< std::unique_ptr >, 2 > m_EBCorrNoise ; + std::array >, 2> m_EBCorrNoise; - CLHEP::HepRandomEngine* randomEngine_ = nullptr; + CLHEP::HepRandomEngine* randomEngine_ = nullptr; }; -#endif +#endif diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h b/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h index c32309b836371..5fadb5f7fca57 100644 --- a/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h +++ b/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer_Ph2.h @@ -1,7 +1,6 @@ #ifndef SimCalorimetry_EcalSimProducers_EcalTimeDigiProducer_Ph2_h #define SimCalorimetry_EcalSimProducers_EcalTimeDigiProducer_Ph2_h - #include "DataFormats/Math/interface/Error.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h" @@ -14,50 +13,48 @@ #include -class ESDigitizer ; +class ESDigitizer; -class CaloGeometry ; -class EcalSimParameterMap_Ph2 ; -class PileUpEventPrincipal ; +class CaloGeometry; +class EcalSimParameterMap_Ph2; +class PileUpEventPrincipal; class EcalTimeMapDigitizer; namespace edm { class Event; class EventSetup; - template class Handle; + template + class Handle; class ParameterSet; -} +} // namespace edm class EcalTimeDigiProducer_Ph2 : public DigiAccumulatorMixMod { - public: - - EcalTimeDigiProducer_Ph2( const edm::ParameterSet& params , edm::ProducesCollector, edm::ConsumesCollector&); - ~EcalTimeDigiProducer_Ph2() override; - - void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override; - void accumulate(edm::Event const& e, edm::EventSetup const& c) override; - void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override; - void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override; - - private: +public: + EcalTimeDigiProducer_Ph2(const edm::ParameterSet& params, edm::ProducesCollector, edm::ConsumesCollector&); + ~EcalTimeDigiProducer_Ph2() override; - typedef edm::Handle > HitsHandle; - void accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing); + void initializeEvent(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(edm::Event const& e, edm::EventSetup const& c) override; + void accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& c, edm::StreamID const&) override; + void finalizeEvent(edm::Event& e, edm::EventSetup const& c) override; - void checkGeometry(const edm::EventSetup& eventSetup) ; +private: + typedef edm::Handle > HitsHandle; + void accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing); - void updateGeometry() ; + void checkGeometry(const edm::EventSetup& eventSetup); - const std::string m_EBdigiCollection ; - const edm::InputTag m_hitsProducerTagEB ; - const edm::EDGetTokenT > m_hitsProducerTokenEB ; + void updateGeometry(); - private: - int m_timeLayerEB; - const CaloGeometry* m_Geometry ; + const std::string m_EBdigiCollection; + const edm::InputTag m_hitsProducerTagEB; + const edm::EDGetTokenT > m_hitsProducerTokenEB; - EcalTimeMapDigitizer* m_BarrelDigitizer; +private: + int m_timeLayerEB; + const CaloGeometry* m_Geometry; + EcalTimeMapDigitizer* m_BarrelDigitizer; }; -#endif +#endif diff --git a/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc b/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc index a0d86602af74a..9c150c534ddad 100644 --- a/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc +++ b/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc @@ -13,30 +13,25 @@ const int kEBChannels = 61200; class EcalCATIAGainRatiosESProducer : public edm::ESProducer { - public: - EcalCATIAGainRatiosESProducer(const edm::ParameterSet& iConfig); typedef std::shared_ptr ReturnType; ReturnType produce(const EcalCATIAGainRatiosRcd& iRecord); - private: edm::ParameterSet pset_; }; -EcalCATIAGainRatiosESProducer::EcalCATIAGainRatiosESProducer(const edm::ParameterSet& iConfig) : - pset_(iConfig) { +EcalCATIAGainRatiosESProducer::EcalCATIAGainRatiosESProducer(const edm::ParameterSet& iConfig) : pset_(iConfig) { //the following line is needed to tell the framework what // data is being produced //std::cout<<"*********Creating EcalCATIAGainRatiosESProducer"<(); @@ -47,14 +42,12 @@ EcalCATIAGainRatiosESProducer::produce(const EcalCATIAGainRatiosRcd& iRecord){ float val = 10.; prod->setValue(myEBDetId.rawId(), val); } - + //std::cout<size()< ReturnType; ReturnType produce(const EcalLiteDTUPedestalsRcd& iRecord); - private: edm::ParameterSet pset_; }; -EcalLiteDTUPedestalsESProducer::EcalLiteDTUPedestalsESProducer(const edm::ParameterSet& iConfig) : - pset_(iConfig) { +EcalLiteDTUPedestalsESProducer::EcalLiteDTUPedestalsESProducer(const edm::ParameterSet& iConfig) : pset_(iConfig) { //the following line is needed to tell the framework what // data is being produced //std::cout<<"*********Creating EcalLiteDTUPedestalsESProducer"<(); @@ -45,22 +41,20 @@ EcalLiteDTUPedestalsESProducer::produce(const EcalLiteDTUPedestalsRcd& iRecord){ for (int iChannel = 0; iChannel < kEBChannels; iChannel++) { EBDetId myEBDetId = EBDetId::unhashIndex(iChannel); EcalLiteDTUPed ped; - ped.setMean(0,15.); - ped.setRMS(0,2.5); - - ped.setMean(1,12.); - ped.setRMS(1,2.); - - prod->insert(std::make_pair(myEBDetId,ped)); + ped.setMean(0, 15.); + ped.setRMS(0, 2.5); + + ped.setMean(1, 12.); + ped.setRMS(1, 2.); + + prod->insert(std::make_pair(myEBDetId, ped)); } - + //std::cout<size()<(m_apdDigiTag); - - producesCollector.produces(m_EBdigiCollection); - +EcalDigiProducer_Ph2::EcalDigiProducer_Ph2(const edm::ParameterSet& params, + edm::ProducesCollector producesCollector, + edm::ConsumesCollector& iC) + : EcalDigiProducer_Ph2(params, iC) { + if (m_apdSeparateDigi) + producesCollector.produces(m_apdDigiTag); + + producesCollector.produces(m_EBdigiCollection); } // version for Pre-Mixing, for use outside of MixingModule -EcalDigiProducer_Ph2::EcalDigiProducer_Ph2( const edm::ParameterSet& params, edm::ConsumesCollector& iC) : - DigiAccumulatorMixMod(), - m_APDShape ( true ) , - m_EBShape ( true ) , - - m_EBdigiCollection ( params.getParameter("EBdigiCollectionPh2") ) , - - m_hitsProducerTag ( params.getParameter("hitsProducer" ) ) , - m_useLCcorrection ( params.getUntrackedParameter("UseLCcorrection") ) , - m_apdSeparateDigi ( params.getParameter ("apdSeparateDigi") ) , - - m_EBs25notCont ( params.getParameter ("EBs25notContainment") ) , - - - m_readoutFrameSize ( params.getParameter ("readoutFrameSize") ) , - m_ParameterMap ( new EcalSimParameterMap_Ph2( - params.getParameter ("simHitToPhotoelectronsBarrel") , - params.getParameter ("photoelectronsToAnalogBarrel") , - params.getParameter ("samplingFactor") , - params.getParameter ("timePhase") , - m_readoutFrameSize , - params.getParameter ("binOfMaximum") , - params.getParameter ("doPhotostatistics") , - params.getParameter ("syncPhase") ) ) , - - m_apdDigiTag ( params.getParameter ("apdDigiTag" ) ) , - m_apdParameters ( new APDSimParameters( - params.getParameter ("apdAddToBarrel" ) , - m_apdSeparateDigi , - params.getParameter ("apdSimToPELow" ) , - params.getParameter ("apdSimToPEHigh" ) , - params.getParameter ("apdTimeOffset" ) , - params.getParameter ("apdTimeOffWidth" ) , - params.getParameter ("apdDoPEStats" ) , - m_apdDigiTag , - params.getParameter > ( "apdNonlParms" ) ) ) , - - m_APDResponse ( !m_apdSeparateDigi ? nullptr : - new EBHitResponse_Ph2( m_ParameterMap.get() , - &m_EBShape , - true , - m_apdParameters.get() , - &m_APDShape ) ) , - - m_EBResponse ( new EBHitResponse_Ph2( m_ParameterMap.get() , - &m_EBShape , - false , // barrel - m_apdParameters.get() , - &m_APDShape ) ) , - - m_PreMix1 ( params.getParameter ("EcalPreMixStage1") ) , - m_PreMix2 ( params.getParameter ("EcalPreMixStage2") ) , - - - - m_doEB ( params.getParameter ("doEB" ) ) , - - - m_APDDigitizer ( nullptr ) , - m_BarrelDigitizer ( nullptr ) , - m_ElectronicsSim ( nullptr ) , - m_Coder ( nullptr ) , - m_APDElectronicsSim ( nullptr ) , - m_APDCoder ( nullptr ) , - m_Geometry ( nullptr ) , - m_EBCorrNoise ( { {nullptr, nullptr} } ) +EcalDigiProducer_Ph2::EcalDigiProducer_Ph2(const edm::ParameterSet& params, edm::ConsumesCollector& iC) + : DigiAccumulatorMixMod(), + m_APDShape(true), + m_EBShape(true), + + m_EBdigiCollection(params.getParameter("EBdigiCollectionPh2")), + + m_hitsProducerTag(params.getParameter("hitsProducer")), + m_useLCcorrection(params.getUntrackedParameter("UseLCcorrection")), + m_apdSeparateDigi(params.getParameter("apdSeparateDigi")), + + m_EBs25notCont(params.getParameter("EBs25notContainment")), + + m_readoutFrameSize(params.getParameter("readoutFrameSize")), + m_ParameterMap(new EcalSimParameterMap_Ph2(params.getParameter("simHitToPhotoelectronsBarrel"), + params.getParameter("photoelectronsToAnalogBarrel"), + params.getParameter("samplingFactor"), + params.getParameter("timePhase"), + m_readoutFrameSize, + params.getParameter("binOfMaximum"), + params.getParameter("doPhotostatistics"), + params.getParameter("syncPhase"))), + + m_apdDigiTag(params.getParameter("apdDigiTag")), + m_apdParameters(new APDSimParameters(params.getParameter("apdAddToBarrel"), + m_apdSeparateDigi, + params.getParameter("apdSimToPELow"), + params.getParameter("apdSimToPEHigh"), + params.getParameter("apdTimeOffset"), + params.getParameter("apdTimeOffWidth"), + params.getParameter("apdDoPEStats"), + m_apdDigiTag, + params.getParameter >("apdNonlParms"))), + + m_APDResponse( + !m_apdSeparateDigi + ? nullptr + : new EBHitResponse_Ph2(m_ParameterMap.get(), &m_EBShape, true, m_apdParameters.get(), &m_APDShape)), + + m_EBResponse(new EBHitResponse_Ph2(m_ParameterMap.get(), + &m_EBShape, + false, // barrel + m_apdParameters.get(), + &m_APDShape)), + + m_PreMix1(params.getParameter("EcalPreMixStage1")), + m_PreMix2(params.getParameter("EcalPreMixStage2")), + + m_doEB(params.getParameter("doEB")), + + m_APDDigitizer(nullptr), + m_BarrelDigitizer(nullptr), + m_ElectronicsSim(nullptr), + m_Coder(nullptr), + m_APDElectronicsSim(nullptr), + m_APDCoder(nullptr), + m_Geometry(nullptr), + m_EBCorrNoise({{nullptr, nullptr}}) { //std::cout<<"[EcalDigiProducer_Ph2] Constructing producer"<< "frameSize: " << m_readoutFrameSize<< std::endl; - if ( m_doEB ) iC.consumes >(edm::InputTag(m_hitsProducerTag, "EcalHitsEB")); - - - const std::vector ebCorMatG10Ph2 = params.getParameter< std::vector >("EBCorrNoiseMatrixG10Ph2"); - const std::vector ebCorMatG01Ph2 = params.getParameter< std::vector >("EBCorrNoiseMatrixG01Ph2"); - - const bool applyConstantTerm = params.getParameter ("applyConstantTerm"); - const double rmsConstantTerm = params.getParameter ("ConstantTerm"); - - const bool addNoise = params.getParameter ("doENoise"); - const bool cosmicsPhase = params.getParameter ("cosmicsPhase"); - const double cosmicsShift = params.getParameter ("cosmicsShift"); - -//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - - // further phase for cosmics studies - if( cosmicsPhase ) - { - if( m_doEB ) m_EBResponse->setPhaseShift( 1. + cosmicsShift ) ; - - } - - EcalCorrMatrix_Ph2 ebMatrix[ 2 ] ; - - - //std::cout<<"[EcalDigiProducer_Ph2] Check size10: "< fabs( ebCorMatG10Ph2[0] - 1.0 ) ) ; - assert( 1.e-7 > fabs( ebCorMatG01Ph2[0] - 1.0 ) ) ; - - //std::cout<<"[EcalDigiProducer_Ph2] Check row of cor and col mat"<= ebCorMatG10Ph2[row] ) ; - assert( 0 == row || 1. >= ebCorMatG01Ph2[row] ) ; - - // std::cout<<"row "<( ebMatrix[0] ) ); - m_EBCorrNoise[1].reset( new CorrelatedNoisifier( ebMatrix[1] ) ); - - - //std::cout<<"[EcalDigiProducer_Ph2] More reset"< >(edm::InputTag(m_hitsProducerTag, "EcalHitsEB")); + + const std::vector ebCorMatG10Ph2 = params.getParameter >("EBCorrNoiseMatrixG10Ph2"); + const std::vector ebCorMatG01Ph2 = params.getParameter >("EBCorrNoiseMatrixG01Ph2"); + + const bool applyConstantTerm = params.getParameter("applyConstantTerm"); + const double rmsConstantTerm = params.getParameter("ConstantTerm"); + + const bool addNoise = params.getParameter("doENoise"); + const bool cosmicsPhase = params.getParameter("cosmicsPhase"); + const double cosmicsShift = params.getParameter("cosmicsShift"); + + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + // further phase for cosmics studies + if (cosmicsPhase) { + if (m_doEB) + m_EBResponse->setPhaseShift(1. + cosmicsShift); + } + + EcalCorrMatrix_Ph2 ebMatrix[2]; + + //std::cout<<"[EcalDigiProducer_Ph2] Check size10: "< fabs(ebCorMatG10Ph2[0] - 1.0)); + assert(1.e-7 > fabs(ebCorMatG01Ph2[0] - 1.0)); + + //std::cout<<"[EcalDigiProducer_Ph2] Check row of cor and col mat"<= ebCorMatG10Ph2[row]); + assert(0 == row || 1. >= ebCorMatG01Ph2[row]); + + // std::cout<<"row "<(ebMatrix[0])); + m_EBCorrNoise[1].reset(new CorrelatedNoisifier(ebMatrix[1])); + + //std::cout<<"[EcalDigiProducer_Ph2] More reset"< rng; randomEngine_ = &rng->getEngine(event.streamID()); - checkGeometry( eventSetup ); - checkCalibrations( event, eventSetup ); - if( m_doEB ) { - m_BarrelDigitizer->initializeHits(); - if(m_apdSeparateDigi) { - m_APDDigitizer->initializeHits(); - } - } - + checkGeometry(eventSetup); + checkCalibrations(event, eventSetup); + if (m_doEB) { + m_BarrelDigitizer->initializeHits(); + if (m_apdSeparateDigi) { + m_APDDigitizer->initializeHits(); + } + } } -void -EcalDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { - if(m_doEB && ebHandle.isValid()) { +void EcalDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { + if (m_doEB && ebHandle.isValid()) { m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_); - if(m_apdSeparateDigi) { + if (m_apdSeparateDigi) { m_APDDigitizer->add(*ebHandle.product(), bunchCrossing, randomEngine_); } } } -void -EcalDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) { +void EcalDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) { // Step A: Get Inputs edm::Handle > ebHandle; - if(m_doEB) { - m_EBShape.setEventSetup(eventSetup); // need to set the eventSetup here, otherwise pre-mixing module will not wrk - m_APDShape.setEventSetup(eventSetup); // + if (m_doEB) { + m_EBShape.setEventSetup(eventSetup); // need to set the eventSetup here, otherwise pre-mixing module will not wrk + m_APDShape.setEventSetup(eventSetup); // edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB"); e.getByLabel(ebTag, ebHandle); } @@ -270,165 +234,150 @@ EcalDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eve accumulateCaloHits(ebHandle, 0); } -void -EcalDigiProducer_Ph2::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& eventSetup, edm::StreamID const& streamID) { +void EcalDigiProducer_Ph2::accumulate(PileUpEventPrincipal const& e, + edm::EventSetup const& eventSetup, + edm::StreamID const& streamID) { // Step A: Get Inputs edm::Handle > ebHandle; - if(m_doEB) { + if (m_doEB) { edm::InputTag ebTag(m_hitsProducerTag, "EcalHitsEB"); e.getByLabel(ebTag, ebHandle); } accumulateCaloHits(ebHandle, e.bunchCrossing()); } -void -EcalDigiProducer_Ph2::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) { - // Step B: Create empty output - std::unique_ptr apdResult ( !m_apdSeparateDigi || !m_doEB ? nullptr : - new EBDigiCollectionPh2() ) ; - std::unique_ptr barrelResult ( new EBDigiCollectionPh2() ) ; - - // run the algorithm - - if( m_doEB ) { - //std::cout << " EcalDigiProducer_Ph2 ::finalize, running digitizer " - //<< event.run() << " " << event.id() << std::endl; - - m_BarrelDigitizer->run( *barrelResult, randomEngine_ ) ; - cacheEBDigis( &*barrelResult ) ; - - - - edm::LogInfo("DigiInfo") << "EB Digis: " << barrelResult->size() ; - - if( m_apdSeparateDigi ) { - m_APDDigitizer->run( *apdResult, randomEngine_ ) ; - edm::LogInfo("DigiInfo") << "APD Digis: " << apdResult->size() ; - } - } - - // Step D: Put outputs into event - if( m_apdSeparateDigi ) { - //event.put(std::move(apdResult), m_apdDigiTag ) ; - } - - event.put(std::move(barrelResult), m_EBdigiCollection ) ; - - randomEngine_ = nullptr; // to prevent access outside event +void EcalDigiProducer_Ph2::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) { + // Step B: Create empty output + std::unique_ptr apdResult(!m_apdSeparateDigi || !m_doEB ? nullptr : new EBDigiCollectionPh2()); + std::unique_ptr barrelResult(new EBDigiCollectionPh2()); + + // run the algorithm + + if (m_doEB) { + //std::cout << " EcalDigiProducer_Ph2 ::finalize, running digitizer " + //<< event.run() << " " << event.id() << std::endl; + + m_BarrelDigitizer->run(*barrelResult, randomEngine_); + cacheEBDigis(&*barrelResult); + + edm::LogInfo("DigiInfo") << "EB Digis: " << barrelResult->size(); + + if (m_apdSeparateDigi) { + m_APDDigitizer->run(*apdResult, randomEngine_); + edm::LogInfo("DigiInfo") << "APD Digis: " << apdResult->size(); + } + } + + // Step D: Put outputs into event + if (m_apdSeparateDigi) { + //event.put(std::move(apdResult), m_apdDigiTag ) ; + } + + event.put(std::move(barrelResult), m_EBdigiCollection); + + randomEngine_ = nullptr; // to prevent access outside event } -void -EcalDigiProducer_Ph2::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) -{ - edm::Service rng; - if ( ! rng.isAvailable() ) { - throw cms::Exception("Configuration") << - "RandomNumberGenerator service is not available.\n" - "You must add the service in the configuration file\n" - "or remove the module that requires it."; - } - CLHEP::HepRandomEngine* engine = &rng->getEngine(lumi.index()); - - if( m_doEB ) { - if( nullptr != m_APDResponse ) m_APDResponse->initialize(engine); - m_EBResponse->initialize(engine); - } +void EcalDigiProducer_Ph2::beginLuminosityBlock(edm::LuminosityBlock const& lumi, edm::EventSetup const& setup) { + edm::Service rng; + if (!rng.isAvailable()) { + throw cms::Exception("Configuration") << "RandomNumberGenerator service is not available.\n" + "You must add the service in the configuration file\n" + "or remove the module that requires it."; + } + CLHEP::HepRandomEngine* engine = &rng->getEngine(lumi.index()); + + if (m_doEB) { + if (nullptr != m_APDResponse) + m_APDResponse->initialize(engine); + m_EBResponse->initialize(engine); + } } -void -EcalDigiProducer_Ph2::checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup ) -{ - // Pedestals from event setup - - edm::ESHandle dbPed ; - eventSetup.get().get( dbPed ) ; - const EcalLiteDTUPedestals* pedestals ( dbPed.product() ) ; - - m_Coder->setPedestals( pedestals ) ; - if( nullptr != m_APDCoder ) m_APDCoder->setPedestals( pedestals ) ; - - // Ecal Intercalibration Constants - edm::ESHandle pIcal ; - eventSetup.get().get( pIcal ) ; - const EcalIntercalibConstantsMC* ical ( pIcal.product() ) ; - - m_Coder->setIntercalibConstants( ical ) ; - if( nullptr != m_APDCoder) m_APDCoder->setIntercalibConstants( ical ) ; - - m_EBResponse->setIntercal( ical ) ; - if( nullptr != m_APDResponse ) m_APDResponse->setIntercal( ical ) ; - - // Ecal LaserCorrection Constants - edm::ESHandle laser; - eventSetup.get().get(laser); - const edm::TimeValue_t eventTimeValue = event.time().value(); - - m_EBResponse->setEventTime(eventTimeValue); - m_EBResponse->setLaserConstants(laser.product(), m_useLCcorrection); - - - // ADC -> GeV Scale - edm::ESHandle pAgc; - eventSetup.get().get(pAgc); - const EcalADCToGeVConstant* agc = pAgc.product(); - - // Gain Ratios - edm::ESHandle pRatio; - eventSetup.get().get(pRatio); - const EcalCATIAGainRatios* gr = pRatio.product(); - m_Coder->setGainRatios( gr ); - if( nullptr != m_APDCoder) m_APDCoder->setGainRatios( gr ); - - - - const double EBscale ( - ( agc->getEBValue())*ecalPh2::gains[1]*(m_Coder->MAXADC)*m_EBs25notCont ) ; - - LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEBValue() - << "\n" << " notCont = " << m_EBs25notCont - << "\n" << " saturation for EB = " << EBscale - << ", " << m_EBs25notCont ; - - - m_Coder->setFullScaleEnergy( EBscale ) ; - if( nullptr != m_APDCoder ) m_APDCoder->setFullScaleEnergy( EBscale ) ; +void EcalDigiProducer_Ph2::checkCalibrations(const edm::Event& event, const edm::EventSetup& eventSetup) { + // Pedestals from event setup + + edm::ESHandle dbPed; + eventSetup.get().get(dbPed); + const EcalLiteDTUPedestals* pedestals(dbPed.product()); + + m_Coder->setPedestals(pedestals); + if (nullptr != m_APDCoder) + m_APDCoder->setPedestals(pedestals); + // Ecal Intercalibration Constants + edm::ESHandle pIcal; + eventSetup.get().get(pIcal); + const EcalIntercalibConstantsMC* ical(pIcal.product()); + + m_Coder->setIntercalibConstants(ical); + if (nullptr != m_APDCoder) + m_APDCoder->setIntercalibConstants(ical); + + m_EBResponse->setIntercal(ical); + if (nullptr != m_APDResponse) + m_APDResponse->setIntercal(ical); + + // Ecal LaserCorrection Constants + edm::ESHandle laser; + eventSetup.get().get(laser); + const edm::TimeValue_t eventTimeValue = event.time().value(); + + m_EBResponse->setEventTime(eventTimeValue); + m_EBResponse->setLaserConstants(laser.product(), m_useLCcorrection); + + // ADC -> GeV Scale + edm::ESHandle pAgc; + eventSetup.get().get(pAgc); + const EcalADCToGeVConstant* agc = pAgc.product(); + + // Gain Ratios + edm::ESHandle pRatio; + eventSetup.get().get(pRatio); + const EcalCATIAGainRatios* gr = pRatio.product(); + m_Coder->setGainRatios(gr); + if (nullptr != m_APDCoder) + m_APDCoder->setGainRatios(gr); + + const double EBscale((agc->getEBValue()) * ecalPh2::gains[1] * (m_Coder->MAXADC) * m_EBs25notCont); + + LogDebug("EcalDigi") << " GeV/ADC = " << agc->getEBValue() << "\n" + << " notCont = " << m_EBs25notCont << "\n" + << " saturation for EB = " << EBscale << ", " << m_EBs25notCont; + + m_Coder->setFullScaleEnergy(EBscale); + if (nullptr != m_APDCoder) + m_APDCoder->setFullScaleEnergy(EBscale); } -void -EcalDigiProducer_Ph2::checkGeometry( const edm::EventSetup & eventSetup ) -{ - // TODO find a way to avoid doing this every event - edm::ESHandle hGeometry ; - eventSetup.get().get( hGeometry ) ; +void EcalDigiProducer_Ph2::checkGeometry(const edm::EventSetup& eventSetup) { + // TODO find a way to avoid doing this every event + edm::ESHandle hGeometry; + eventSetup.get().get(hGeometry); - const CaloGeometry* pGeometry = &*hGeometry; + const CaloGeometry* pGeometry = &*hGeometry; - if( pGeometry != m_Geometry ) - { - m_Geometry = pGeometry; - updateGeometry(); - } + if (pGeometry != m_Geometry) { + m_Geometry = pGeometry; + updateGeometry(); + } } -void -EcalDigiProducer_Ph2::updateGeometry() -{ - if( m_doEB ) { - if( nullptr != m_APDResponse ) m_APDResponse->setGeometry( - m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ; - m_EBResponse->setGeometry( - m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ; +void EcalDigiProducer_Ph2::updateGeometry() { + if (m_doEB) { + if (nullptr != m_APDResponse) + m_APDResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel)); + m_EBResponse->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel)); } - } +} -void EcalDigiProducer_Ph2::setEBNoiseSignalGenerator(EcalBaseSignalGenerator * noiseGenerator) { +void EcalDigiProducer_Ph2::setEBNoiseSignalGenerator(EcalBaseSignalGenerator* noiseGenerator) { //noiseGenerator->setParameterMap(theParameterMap); - if(nullptr != m_BarrelDigitizer) m_BarrelDigitizer->setNoiseSignalGenerator(noiseGenerator); + if (nullptr != m_BarrelDigitizer) + m_BarrelDigitizer->setNoiseSignalGenerator(noiseGenerator); } - void EcalDigiProducer_Ph2::beginRun(edm::Run const& run, edm::EventSetup const& setup) { - m_EBShape.setEventSetup(setup); - m_APDShape.setEventSetup(setup); + m_EBShape.setEventSetup(setup); + m_APDShape.setEventSetup(setup); } diff --git a/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc b/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc index e5cb363e1eae7..bf02ee4813e2d 100644 --- a/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc +++ b/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer_Ph2.cc @@ -18,53 +18,46 @@ #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h" - //#define ecal_time_debug 1 -EcalTimeDigiProducer_Ph2::EcalTimeDigiProducer_Ph2( const edm::ParameterSet& params, edm::ProducesCollector producesCollector, edm::ConsumesCollector& sumes) : - DigiAccumulatorMixMod(), - m_EBdigiCollection ( params.getParameter("EBtimeDigiCollection") ) , - m_hitsProducerTagEB ( params.getParameter("hitsProducerEB" ) ) , - m_hitsProducerTokenEB ( sumes.consumes >( m_hitsProducerTagEB) ) , - m_timeLayerEB ( params.getParameter ("timeLayerBarrel") ), - m_Geometry ( nullptr ) -{ - producesCollector.produces(m_EBdigiCollection); +EcalTimeDigiProducer_Ph2::EcalTimeDigiProducer_Ph2(const edm::ParameterSet& params, + edm::ProducesCollector producesCollector, + edm::ConsumesCollector& sumes) + : DigiAccumulatorMixMod(), + m_EBdigiCollection(params.getParameter("EBtimeDigiCollection")), + m_hitsProducerTagEB(params.getParameter("hitsProducerEB")), + m_hitsProducerTokenEB(sumes.consumes >(m_hitsProducerTagEB)), + m_timeLayerEB(params.getParameter("timeLayerBarrel")), + m_Geometry(nullptr) { + producesCollector.produces(m_EBdigiCollection); - m_BarrelDigitizer = new EcalTimeMapDigitizer(EcalBarrel); + m_BarrelDigitizer = new EcalTimeMapDigitizer(EcalBarrel); #ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer_Ph2]::Create EB " << m_EBdigiCollection << " collection and digitizer" << std::endl; + std::cout << "[EcalTimeDigiProducer_Ph2]::Create EB " << m_EBdigiCollection << " collection and digitizer" + << std::endl; #endif - m_BarrelDigitizer->setTimeLayerId(m_timeLayerEB); - -} - -EcalTimeDigiProducer_Ph2::~EcalTimeDigiProducer_Ph2() -{ + m_BarrelDigitizer->setTimeLayerId(m_timeLayerEB); } -void -EcalTimeDigiProducer_Ph2::initializeEvent(edm::Event const& event, edm::EventSetup const& eventSetup) { - checkGeometry( eventSetup ); - // checkCalibrations( event, eventSetup ); - // here the methods to clean the maps - m_BarrelDigitizer->initializeMap(); +EcalTimeDigiProducer_Ph2::~EcalTimeDigiProducer_Ph2() {} +void EcalTimeDigiProducer_Ph2::initializeEvent(edm::Event const& event, edm::EventSetup const& eventSetup) { + checkGeometry(eventSetup); + // checkCalibrations( event, eventSetup ); + // here the methods to clean the maps + m_BarrelDigitizer->initializeMap(); } -void -EcalTimeDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { +void EcalTimeDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { // accumulate the simHits and do the averages in a given layer per bunch crossing - if(ebHandle.isValid()) { + if (ebHandle.isValid()) { m_BarrelDigitizer->add(*ebHandle.product(), bunchCrossing); } - } -void -EcalTimeDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) { +void EcalTimeDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& eventSetup) { // Step A: Get Inputs edm::Handle > ebHandle; e.getByToken(m_hitsProducerTokenEB, ebHandle); @@ -76,60 +69,54 @@ EcalTimeDigiProducer_Ph2::accumulate(edm::Event const& e, edm::EventSetup const& accumulateCaloHits(ebHandle, 0); } -void -EcalTimeDigiProducer_Ph2::accumulate(PileUpEventPrincipal const& e, edm::EventSetup const& eventSetup, edm::StreamID const&) { +void EcalTimeDigiProducer_Ph2::accumulate(PileUpEventPrincipal const& e, + edm::EventSetup const& eventSetup, + edm::StreamID const&) { edm::Handle > ebHandle; e.getByLabel(m_hitsProducerTagEB, ebHandle); - #ifdef ecal_time_debug std::cout << "[EcalTimeDigiProducer_Ph2]::Accumulate Hits for BC " << e.bunchCrossing() << std::endl; #endif accumulateCaloHits(ebHandle, e.bunchCrossing()); } -void -EcalTimeDigiProducer_Ph2::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) { - std::unique_ptr barrelResult ( new EcalTimeDigiCollection() ) ; +void EcalTimeDigiProducer_Ph2::finalizeEvent(edm::Event& event, edm::EventSetup const& eventSetup) { + std::unique_ptr barrelResult(new EcalTimeDigiCollection()); #ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer_Ph2]::finalizeEvent" << std::endl; + std::cout << "[EcalTimeDigiProducer_Ph2]::finalizeEvent" << std::endl; #endif - // here basically just put everything in the final collections - m_BarrelDigitizer->run( *barrelResult ) ; + // here basically just put everything in the final collections + m_BarrelDigitizer->run(*barrelResult); #ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer_Ph2]::EB Digi size " << barrelResult->size() << std::endl; + std::cout << "[EcalTimeDigiProducer_Ph2]::EB Digi size " << barrelResult->size() << std::endl; #endif - edm::LogInfo("TimeDigiInfo") << "EB time Digis: " << barrelResult->size() ; + edm::LogInfo("TimeDigiInfo") << "EB time Digis: " << barrelResult->size(); #ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer_Ph2]::putting collections into the event " << std::endl; + std::cout << "[EcalTimeDigiProducer_Ph2]::putting collections into the event " << std::endl; #endif - event.put( std::move(barrelResult), m_EBdigiCollection ) ; + event.put(std::move(barrelResult), m_EBdigiCollection); } -void -EcalTimeDigiProducer_Ph2::checkGeometry( const edm::EventSetup & eventSetup ) -{ - // TODO find a way to avoid doing this every event - edm::ESHandle hGeometry ; - eventSetup.get().get( hGeometry ) ; +void EcalTimeDigiProducer_Ph2::checkGeometry(const edm::EventSetup& eventSetup) { + // TODO find a way to avoid doing this every event + edm::ESHandle hGeometry; + eventSetup.get().get(hGeometry); - const CaloGeometry* pGeometry = &*hGeometry; + const CaloGeometry* pGeometry = &*hGeometry; - if( pGeometry != m_Geometry ) - { - m_Geometry = pGeometry; - updateGeometry(); - } + if (pGeometry != m_Geometry) { + m_Geometry = pGeometry; + updateGeometry(); + } } -void -EcalTimeDigiProducer_Ph2::updateGeometry() -{ - m_BarrelDigitizer->setGeometry( - m_Geometry->getSubdetectorGeometry( DetId::Ecal, EcalBarrel ) ) ;} +void EcalTimeDigiProducer_Ph2::updateGeometry() { + m_BarrelDigitizer->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel)); +} diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc index d747f37cd7049..b13d5a3aeb110 100644 --- a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc @@ -2,7 +2,7 @@ // // Package: PhaseI/PhaseIAnalyzer // Class: PhaseIAnalyzer -// +// /**\class PhaseIAnalyzer PhaseIAnalyzer.cc PhaseI/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc Description: [one line class summary] @@ -16,7 +16,6 @@ // // - // system include files #include @@ -63,116 +62,102 @@ using namespace edm; // // constructors and destructor // -PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) -{ -//now do what ever initialization is needed -usesResource("TFileService"); - - digiTagEB_= iConfig.getParameter("BarrelDigis"); - - digiTokenEB_ = consumes(digiTagEB_); - - //Files: - edm::Service fs; - //Histograms - - for(int isample=0;isample<16;isample++) { - EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC",isample), 950 , 100 , 2000 ); - EBGainHisto[isample] = fs->make(Form("GainEB_%d", isample), Form("Gain Barrel sample %d;Gain",isample) , 5 , 0 , 4 ); - } - SingleChannelE = fs->make("SingleChannelE", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); - SingleChannelELow = fs->make("SingleChannelELow", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); +PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) { + //now do what ever initialization is needed + usesResource("TFileService"); + + digiTagEB_ = iConfig.getParameter("BarrelDigis"); + + digiTokenEB_ = consumes(digiTagEB_); + + //Files: + edm::Service fs; + //Histograms + + for (int isample = 0; isample < 16; isample++) { + EBEnergyHisto[isample] = + fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC", isample), 950, 100, 2000); + EBGainHisto[isample] = + fs->make(Form("GainEB_%d", isample), Form("Gain Barrel sample %d;Gain", isample), 5, 0, 4); + } + SingleChannelE = fs->make("SingleChannelE", "Energy single channel Barrel;ADC", 17, -0.5, 16.5); + SingleChannelELow = fs->make("SingleChannelELow", "Energy single channel Barrel;ADC", 17, -0.5, 16.5); Char_t histo[200]; - - sprintf (histo, "EcalDigiTaskBarrelOccupancy" ) ; + + sprintf(histo, "EcalDigiTaskBarrelOccupancy"); meEBDigiOccupancy_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - sprintf (histo, "EcalDigiTaskBarrelOccupancyHigh" ) ; + sprintf(histo, "EcalDigiTaskBarrelOccupancyHigh"); meEBDigiOccupancyHigh_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - sprintf (histo, "EcalDigiTaskBarrelOccupancyLow" ) ; + sprintf(histo, "EcalDigiTaskBarrelOccupancyLow"); meEBDigiOccupancyLow_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - - sprintf (histo, "EcalDigiTaskBarrelOccupancyMid" ) ; + + sprintf(histo, "EcalDigiTaskBarrelOccupancyMid"); meEBDigiOccupancyMid_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - sprintf (histo, "EcalDigiTaskBarrelDigisMultiplicity" ) ; + sprintf(histo, "EcalDigiTaskBarrelDigisMultiplicity"); meEBDigiMultiplicity_ = fs->make(histo, histo, 612, 0., 61200); - - - for (int i = 0; i < ecalPh2::sampleSize ; i++ ) { - sprintf (histo, "EcalDigiTaskBarrelAnalogPulse%02d", i+1) ; + for (int i = 0; i < ecalPh2::sampleSize; i++) { + sprintf(histo, "EcalDigiTaskBarrelAnalogPulse%02d", i + 1); meEBDigiADCAnalog_[i] = fs->make(histo, histo, 4000, 0., 400.); - sprintf (histo, "EcalDigiTaskBarrelADCPulse%02dGain0_Saturated", i+1) ; + sprintf(histo, "EcalDigiTaskBarrelADCPulse%02dGain0_Saturated", i + 1); meEBDigiADCgS_[i] = fs->make(histo, histo, 4096, -0.5, 4095.5); - sprintf (histo, "EcalDigiTaskBarrelGainPulse%02d", i+1) ; + sprintf(histo, "EcalDigiTaskBarrelGainPulse%02d", i + 1); meEBDigiGain_[i] = fs->make(histo, histo, 4, 0, 4); - } - - sprintf (histo, "EcalDigiTaskBarrelPedestalForPreSample" ) ; - meEBPedestal_ = fs->make(histo, histo, 4096, -0.5, 4095.5) ; - sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt100ADC" ) ; - meEBMaximumgt100ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + sprintf(histo, "EcalDigiTaskBarrelPedestalForPreSample"); + meEBPedestal_ = fs->make(histo, histo, 4096, -0.5, 4095.5); + + sprintf(histo, "EcalDigiTaskBarrelMaximumPositionGt100ADC"); + meEBMaximumgt100ADC_ = fs->make(histo, histo, 10, 0., 10.); - sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt10ADC" ) ; - meEBMaximumgt10ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + sprintf(histo, "EcalDigiTaskBarrelMaximumPositionGt10ADC"); + meEBMaximumgt10ADC_ = fs->make(histo, histo, 10, 0., 10.); // sprintf (histo, "EcalDigiTask Barrel ADC counts after gain switch" ) ; //meEBnADCafterSwitch_ = fs->makehisto, histo, 10, 0., 10.) ; - - - } - - -PhaseIAnalyzer::~PhaseIAnalyzer() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) +PhaseIAnalyzer::~PhaseIAnalyzer() { + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) } - // // member functions // // ------------ method called for each event ------------ -void -PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - +void PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { //LogInfo("PhaseI") << "new event "; - Handle pDigiEB; - iEvent.getByToken(digiTokenEB_,pDigiEB); - - // edm::ESHandle ical; - // iSetup.get().get(ical); - // const EcalIntercalibConstantsMC* ical_map = ical.product(); - // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); - // cout << "intercalib: " << (*itical) << endl; + Handle pDigiEB; + iEvent.getByToken(digiTokenEB_, pDigiEB); - const int MAXSAMPLES=ecalPh1::sampleSize; + // edm::ESHandle ical; + // iSetup.get().get(ical); + // const EcalIntercalibConstantsMC* ical_map = ical.product(); + // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); + // cout << "intercalib: " << (*itical) << endl; - std::vector ebAnalogSignal ; - std::vector ebADCCounts ; - std::vector ebADCGains_temp ; - std::vector ebADCGains ; + const int MAXSAMPLES = ecalPh1::sampleSize; + std::vector ebAnalogSignal; + std::vector ebADCCounts; + std::vector ebADCGains_temp; + std::vector ebADCGains; - ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES); - ebADCCounts.reserve(EBDataFrame::MAXSAMPLES); - ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); - ebADCGains.reserve(EBDataFrame::MAXSAMPLES); + ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES); + ebADCCounts.reserve(EBDataFrame::MAXSAMPLES); + ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); + ebADCGains.reserve(EBDataFrame::MAXSAMPLES); - //Take Pedestals: + //Take Pedestals: // edm::ESHandle peds; // iSetup.get().get(peds); // const EcalLiteDTUPedestals* myped = peds.product(); @@ -180,128 +165,115 @@ PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) // for( EcalLiteDTUPedestals::const_iterator it = myped->barrelItems().begin(); it != myped->barrelItems().end(); ++it) // { // std::cout << "EcalPedestal: " << " BARREL " << cnt << " " - // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); + // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); // std::cout << std::endl; // ++cnt; // } - - int nDigis=0; - int LowGain(0),MidGain(0),HighGain(0); - int maxADCValue=0; - - for (EBDigiCollection::const_iterator pDigi=pDigiEB->begin(); pDigi!=pDigiEB->end(); ++pDigi) - { - LowGain=0; - MidGain=0; - HighGain=0; - maxADCValue=0; - - EBDataFrame digi( *pDigi ); - int nrSamples = digi.size(); - cout<<"NSamples found: "<>12; - ebAnalogSignal[sample] = (ebADCCounts[sample]*gainConv_[(int)ebADCGains[sample]]*barrelADCtoGeV_); - - if(ebADCCounts[sample] > maxADCValue) maxADCValue = ebADCCounts[sample]; - - if( ebid.iphi()==333 and ebid.ieta()==83) SingleChannelE -> SetBinContent(sample,ebADCCounts[sample]); - - if( ebid.iphi()==334 and ebid.ieta()==83) { - SingleChannelELow -> SetBinContent(sample,ebADCCounts[sample]); - } - - if( ebADCGains[sample]==3) LowGain=1; - if( ebADCGains[sample]==2) MidGain=1; - if( ebADCGains[sample]==1) HighGain=1; - - - if(ebADCCounts[sample]>250) { - cout<<"Channel: "<begin(); pDigi != pDigiEB->end(); ++pDigi) { + LowGain = 0; + MidGain = 0; + HighGain = 0; + maxADCValue = 0; + + EBDataFrame digi(*pDigi); + int nrSamples = digi.size(); + cout << "NSamples found: " << nrSamples << endl; + EBDetId ebid = digi.id(); + cout << " Crystall ID " << ebid << endl; + nDigis++; + cout << " nDigis aaaaaaa " << nDigis << endl; + double Emax = 0.; + int Pmax = 0; + double pedestalPreSample = 0.; + double pedestalPreSampleAnalog = 0.; + int countsAfterGainSwitch = -1; + + for (int sample = 0; sample < nrSamples; ++sample) { + ebAnalogSignal[sample] = 0.; + ebADCCounts[sample] = 0.; + ebADCGains_temp[sample] = 0.; + ebADCGains[sample] = 0.; + } + + double gainConv_[4] = {0, 12, 6, 1}; + // saturated channels + double barrelADCtoGeV_ = 0.048; //GeV + + // EcalIntercalibConstantsMC* ical = + + // EcalIntercalibConstantMCMap &icalMap = + + for (int sample = 0; sample < nrSamples; ++sample) { + int thisSample = digi[sample]; + + ebADCCounts[sample] = (thisSample & 0xFFF); + ebADCGains[sample] = (thisSample & (0x3 << 12)) >> 12; + ebAnalogSignal[sample] = (ebADCCounts[sample] * gainConv_[(int)ebADCGains[sample]] * barrelADCtoGeV_); + + if (ebADCCounts[sample] > maxADCValue) + maxADCValue = ebADCCounts[sample]; + + if (ebid.iphi() == 333 and ebid.ieta() == 83) + SingleChannelE->SetBinContent(sample, ebADCCounts[sample]); + + if (ebid.iphi() == 334 and ebid.ieta() == 83) { + SingleChannelELow->SetBinContent(sample, ebADCCounts[sample]); } - - if(1==1)cout<<"P max "< 250) { - meEBDigiOccupancy_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); - if(HighGain==1) meEBDigiOccupancyHigh_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); - if(MidGain==1) meEBDigiOccupancyMid_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); - if(LowGain==1) meEBDigiOccupancyLow_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + if (ebADCGains[sample] == 3) + LowGain = 1; + if (ebADCGains[sample] == 2) + MidGain = 1; + if (ebADCGains[sample] == 1) + HighGain = 1; + + if (ebADCCounts[sample] > 250) { + cout << "Channel: " << ebid << endl; + cout << "Sample " << sample << endl; + cout << " Full data " << thisSample << endl; + cout << " ebADCCounts " << ebADCCounts[sample] << endl; + cout << " ebADCGains " << ebADCGains[sample] << endl; + cout << " gainConv_ " << gainConv_[(int)ebADCGains[sample]] << endl; + cout << " barrelADCtoGeV_ " << barrelADCtoGeV_ << endl; + cout << " ebAnalogSignal " << ebAnalogSignal[sample] << endl; } - - }//end digi - - -} + if (Emax < ebAnalogSignal[sample]) { + Emax = ebAnalogSignal[sample]; + Pmax = sample; + } + } + + if (1 == 1) + cout << "P max " << Pmax << endl; + cout << "High Gain: " << HighGain << " MidGain " << MidGain << " LowGain " << LowGain << endl; + cout << "maxADCValue " << maxADCValue << endl; + if (maxADCValue > 250) { + meEBDigiOccupancy_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + if (HighGain == 1) + meEBDigiOccupancyHigh_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + if (MidGain == 1) + meEBDigiOccupancyMid_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + if (LowGain == 1) + meEBDigiOccupancyLow_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + } + + } //end digi +} // ------------ method called once each job just before starting event loop ------------ -void -PhaseIAnalyzer::beginJob() -{ -} +void PhaseIAnalyzer::beginJob() {} // ------------ method called once each job just after ending the event loop ------------ -void -PhaseIAnalyzer::endJob() -{ -} - +void PhaseIAnalyzer::endJob() {} // ------------ method fills 'descriptions' with the allowed parameters for the module ------------ -void -PhaseIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { +void PhaseIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { //The following says we do not know what parameters are allowed so do no validation // Please change this to state exactly what you do use, even if it is no parameters edm::ParameterSetDescription desc; diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h index f8f332cc4e9a4..9ee3fb51939f1 100644 --- a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h @@ -16,70 +16,54 @@ using namespace std; // class declaration // -class PhaseIAnalyzer : public edm::one::EDAnalyzer { - public: +class PhaseIAnalyzer : public edm::one::EDAnalyzer { +public: explicit PhaseIAnalyzer(const edm::ParameterSet&); - ~PhaseIAnalyzer(); + ~PhaseIAnalyzer(); static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - - private: - virtual void beginJob() ; - void analyze(const edm::Event&, const edm::EventSetup&) override ; - virtual void endJob() ; +private: + virtual void beginJob(); + void analyze(const edm::Event&, const edm::EventSetup&) override; + virtual void endJob(); edm::InputTag digiTagEB_; - - edm::EDGetTokenT digiTokenEB_; - - edm::InputTag hitTagEB_; + edm::EDGetTokenT digiTokenEB_; - - edm::EDGetTokenT> hitTokenEB_; + edm::InputTag hitTagEB_; + edm::EDGetTokenT> hitTokenEB_; edm::InputTag trackTag_; - edm::EDGetTokenT> trackToken_; - - //Histograms - TH1I *EBEnergyHisto[ecalPh2::sampleSize]; -TH1I *EBGainHisto[ecalPh2::sampleSize]; - - - TH2D* meEBDigiOccupancy_; - TH2D* meEBDigiOccupancyHigh_; - TH2D* meEBDigiOccupancyMid_; - TH2D* meEBDigiOccupancyLow_; - - TH1D* meEBDigiMultiplicity_; - - TH1D* meEBDigiADCGlobal_; - - TH1I* SingleChannelE; - TH1I* SingleChannelELow; - - TH1D* meEBDigiADCAnalog_[ecalPh2::sampleSize]; - TH1D* meEBDigiADCgS_[ecalPh2::sampleSize]; - TH1D* meEBDigiGain_[ecalPh2::sampleSize]; + edm::EDGetTokenT> trackToken_; + //Histograms + TH1I* EBEnergyHisto[ecalPh2::sampleSize]; + TH1I* EBGainHisto[ecalPh2::sampleSize]; - TH1D* meEBPedestal_; - -TH1D* meEBMaximumgt100ADC_; - - TH1D* meEBMaximumgt10ADC_; - - TH1D* meEBnADCafterSwitch_; - + TH2D* meEBDigiOccupancy_; + TH2D* meEBDigiOccupancyHigh_; + TH2D* meEBDigiOccupancyMid_; + TH2D* meEBDigiOccupancyLow_; + TH1D* meEBDigiMultiplicity_; + TH1D* meEBDigiADCGlobal_; + TH1I* SingleChannelE; + TH1I* SingleChannelELow; + TH1D* meEBDigiADCAnalog_[ecalPh2::sampleSize]; + TH1D* meEBDigiADCgS_[ecalPh2::sampleSize]; + TH1D* meEBDigiGain_[ecalPh2::sampleSize]; + TH1D* meEBPedestal_; + TH1D* meEBMaximumgt100ADC_; + TH1D* meEBMaximumgt10ADC_; - + TH1D* meEBnADCafterSwitch_; }; diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc index 58c0c76caa44c..7fae5cf1dcff5 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -2,7 +2,7 @@ // // Package: PhaseII/PhaseIIAnalyzer // Class: PhaseIIAnalyzer -// +// /**\class PhaseIIAnalyzer PhaseIIAnalyzer.cc PhaseII/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc Description: [one line class summary] Implementation: @@ -14,7 +14,6 @@ // // - // system include files #include @@ -63,92 +62,80 @@ using namespace edm; // // constructors and destructor // -PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) -{ +PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) { //now do what ever initialization is needed usesResource("TFileService"); - digiTagEB_= iConfig.getParameter("BarrelDigis"); + digiTagEB_ = iConfig.getParameter("BarrelDigis"); digiTokenEB_ = consumes(digiTagEB_); - + //Files: edm::Service fs; //Histograms - for(int isample=0;isample<16;isample++) { - EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC",isample), 950 , 100 , 2000 ); - EBGainHisto[isample] = fs->make(Form("GainEB_%d", isample), Form("Gain Barrel sample %d;Gain",isample) , 5 , 0 , 4 ); + for (int isample = 0; isample < 16; isample++) { + EBEnergyHisto[isample] = + fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC", isample), 950, 100, 2000); + EBGainHisto[isample] = + fs->make(Form("GainEB_%d", isample), Form("Gain Barrel sample %d;Gain", isample), 5, 0, 4); } - SingleChannelE = fs->make("SingleChannelE", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); - SingleChannelELow = fs->make("SingleChannelELow", "Energy single channel Barrel;ADC", 17 , -0.5 , 16.5 ); + SingleChannelE = fs->make("SingleChannelE", "Energy single channel Barrel;ADC", 17, -0.5, 16.5); + SingleChannelELow = fs->make("SingleChannelELow", "Energy single channel Barrel;ADC", 17, -0.5, 16.5); Char_t histo[200]; - - sprintf (histo, "EcalDigiTaskBarrelOccupancy" ) ; + + sprintf(histo, "EcalDigiTaskBarrelOccupancy"); meEBDigiOccupancy_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - sprintf (histo, "EcalDigiTaskBarrelOccupancyHigh" ) ; + sprintf(histo, "EcalDigiTaskBarrelOccupancyHigh"); meEBDigiOccupancyHigh_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - sprintf (histo, "EcalDigiTaskBarrelOccupancyLow" ) ; + sprintf(histo, "EcalDigiTaskBarrelOccupancyLow"); meEBDigiOccupancyLow_ = fs->make(histo, histo, 360, 0., 360., 170, -85., 85.); - - sprintf (histo, "EcalDigiTaskBarrelDigisMultiplicity" ) ; + + sprintf(histo, "EcalDigiTaskBarrelDigisMultiplicity"); meEBDigiMultiplicity_ = fs->make(histo, histo, 612, 0., 61200); - - - for (int i = 0; i < ecalPh2::sampleSize ; i++ ) { - sprintf (histo, "EcalDigiTaskBarrelAnalogPulse%02d", i+1) ; + for (int i = 0; i < ecalPh2::sampleSize; i++) { + sprintf(histo, "EcalDigiTaskBarrelAnalogPulse%02d", i + 1); meEBDigiADCAnalog_[i] = fs->make(histo, histo, 4000, 0., 400.); - sprintf (histo, "EcalDigiTaskBarrelADCPulse%02dGain0_Saturated", i+1) ; + sprintf(histo, "EcalDigiTaskBarrelADCPulse%02dGain0_Saturated", i + 1); meEBDigiADCgS_[i] = fs->make(histo, histo, 4096, -0.5, 4095.5); - sprintf (histo, "EcalDigiTaskBarrelGainPulse%02d", i+1) ; + sprintf(histo, "EcalDigiTaskBarrelGainPulse%02d", i + 1); meEBDigiGain_[i] = fs->make(histo, histo, 4, 0, 4); - } - - sprintf (histo, "EcalDigiTaskBarrelPedestalForPreSample" ) ; - meEBPedestal_ = fs->make(histo, histo, 4096, -0.5, 4095.5) ; - sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt100ADC" ) ; - meEBMaximumgt100ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + sprintf(histo, "EcalDigiTaskBarrelPedestalForPreSample"); + meEBPedestal_ = fs->make(histo, histo, 4096, -0.5, 4095.5); - sprintf (histo, "EcalDigiTaskBarrelMaximumPositionGt10ADC" ) ; - meEBMaximumgt10ADC_ = fs->make(histo, histo, 10, 0., 10.) ; + sprintf(histo, "EcalDigiTaskBarrelMaximumPositionGt100ADC"); + meEBMaximumgt100ADC_ = fs->make(histo, histo, 10, 0., 10.); + + sprintf(histo, "EcalDigiTaskBarrelMaximumPositionGt10ADC"); + meEBMaximumgt10ADC_ = fs->make(histo, histo, 10, 0., 10.); // sprintf (histo, "EcalDigiTask Barrel ADC counts after gain switch" ) ; //meEBnADCafterSwitch_ = fs->makehisto, histo, 10, 0., 10.) ; - - } - -PhaseIIAnalyzer::~PhaseIIAnalyzer() -{ - +PhaseIIAnalyzer::~PhaseIIAnalyzer() { // do anything here that needs to be done at desctruction time // (e.g. close files, deallocate resources etc.) - } - // // member functions // // ------------ method called for each event ------------ -void -PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - +void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { //LogInfo("PhaseII") << "new event "; Handle pDigiEB; - iEvent.getByToken(digiTokenEB_,pDigiEB); + iEvent.getByToken(digiTokenEB_, pDigiEB); // edm::ESHandle ical; // iSetup.get().get(ical); @@ -156,14 +143,13 @@ PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); // cout << "intercalib: " << (*itical) << endl; - const int MAXSAMPLES=ecalPh2::sampleSize; + const int MAXSAMPLES = ecalPh2::sampleSize; - std::vector ebAnalogSignal ; - std::vector ebADCCounts ; - std::vector ebADCGains_temp ; - std::vector ebADCGains ; + std::vector ebAnalogSignal; + std::vector ebADCCounts; + std::vector ebADCGains_temp; + std::vector ebADCGains; - ebAnalogSignal.reserve(EBDataFrame::MAXSAMPLES); ebADCCounts.reserve(EBDataFrame::MAXSAMPLES); ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); @@ -177,125 +163,109 @@ PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup // for( EcalLiteDTUPedestals::const_iterator it = myped->barrelItems().begin(); it != myped->barrelItems().end(); ++it) // { // std::cout << "EcalPedestal: " << " BARREL " << cnt << " " - // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); + // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); // std::cout << std::endl; // ++cnt; // } - - int nDigis=0; - int maxADCValue=0; - int LowGain=0; - double gainConv_[2]={10,1}; - double barrelADCtoGeV_ = 0.048; //GeV - - - for (EBDigiCollectionPh2::const_iterator pDigi=pDigiEB->begin(); pDigi!=pDigiEB->end(); ++pDigi) - { - maxADCValue=0; - LowGain=0; - - EBDataFrame digi( *pDigi ); - int nrSamples = digi.size(); - EBDetId ebid = digi.id () ; - nDigis++; - - edm::ESHandle peds; - iSetup.get().get(peds); - const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); - // EcalLiteDTUPedestalsMap::const_iterator itped = DTUpeds_map->getMap().find(ebid); - // cout << "mean dei piedistalli: " << (*itped).mean(0) << " rms: " << (*itped).rms(0) << endl; - - double Emax = 0. ; - int Pmax = 0 ; - double pedestalPreSample = 0.; - double pedestalPreSampleAnalog = 0.; - int countsAfterGainSwitch = -1; - double higherGain = 1.; - - - for (int sample = 0 ; sample < nrSamples; ++sample) - { - ebAnalogSignal[sample] = 0.; - ebADCCounts[sample] = 0.; - ebADCGains_temp[sample] = 0.; - ebADCGains[sample] = 0.; - } - - // EcalIntercalibConstantsMC* ical = - - // EcalIntercalibConstantMCMap &icalMap = - - for (int sample = 0 ; sample < nrSamples; ++sample) - { - - int thisSample = digi[sample]; - - ebADCCounts[sample] = (thisSample&0xFFF); - ebADCGains[sample] = (thisSample&(0x3<<12))>>12; - ebAnalogSignal[sample] = (ebADCCounts[sample]*gainConv_[(int)ebADCGains[sample]]*barrelADCtoGeV_); - - if(ebADCCounts[sample] > maxADCValue) maxADCValue = ebADCCounts[sample]; - - if( ebADCGains[sample]==1) LowGain=1; - - - if( ebid.iphi()==333 and ebid.ieta()==83) { - SingleChannelE -> SetBinContent(sample,ebADCCounts[sample]); - } - if( ebid.iphi()==333 and ebid.ieta()==83) { - SingleChannelELow -> SetBinContent(sample,ebADCCounts[sample]); - } - if(ebADCCounts[sample] > 27) { - cout<<"Channel: "< 27.5) { - cout<<"Filling Histo: "<SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); - if(LowGain==0) meEBDigiOccupancyHigh_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); - else meEBDigiOccupancyLow_->SetBinContent( ebid.iphi(), ebid.ieta(),maxADCValue ); + int nDigis = 0; + int maxADCValue = 0; + int LowGain = 0; + double gainConv_[2] = {10, 1}; + double barrelADCtoGeV_ = 0.048; //GeV + + for (EBDigiCollectionPh2::const_iterator pDigi = pDigiEB->begin(); pDigi != pDigiEB->end(); ++pDigi) { + maxADCValue = 0; + LowGain = 0; + + EBDataFrame digi(*pDigi); + int nrSamples = digi.size(); + EBDetId ebid = digi.id(); + nDigis++; + + edm::ESHandle peds; + iSetup.get().get(peds); + const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); + // EcalLiteDTUPedestalsMap::const_iterator itped = DTUpeds_map->getMap().find(ebid); + // cout << "mean dei piedistalli: " << (*itped).mean(0) << " rms: " << (*itped).rms(0) << endl; + + double Emax = 0.; + int Pmax = 0; + double pedestalPreSample = 0.; + double pedestalPreSampleAnalog = 0.; + int countsAfterGainSwitch = -1; + double higherGain = 1.; + + for (int sample = 0; sample < nrSamples; ++sample) { + ebAnalogSignal[sample] = 0.; + ebADCCounts[sample] = 0.; + ebADCGains_temp[sample] = 0.; + ebADCGains[sample] = 0.; + } + + // EcalIntercalibConstantsMC* ical = + + // EcalIntercalibConstantMCMap &icalMap = + + for (int sample = 0; sample < nrSamples; ++sample) { + int thisSample = digi[sample]; + + ebADCCounts[sample] = (thisSample & 0xFFF); + ebADCGains[sample] = (thisSample & (0x3 << 12)) >> 12; + ebAnalogSignal[sample] = (ebADCCounts[sample] * gainConv_[(int)ebADCGains[sample]] * barrelADCtoGeV_); + + if (ebADCCounts[sample] > maxADCValue) + maxADCValue = ebADCCounts[sample]; + + if (ebADCGains[sample] == 1) + LowGain = 1; + + if (ebid.iphi() == 333 and ebid.ieta() == 83) { + SingleChannelE->SetBinContent(sample, ebADCCounts[sample]); + } + if (ebid.iphi() == 333 and ebid.ieta() == 83) { + SingleChannelELow->SetBinContent(sample, ebADCCounts[sample]); + } + if (ebADCCounts[sample] > 27) { + cout << "Channel: " << ebid << endl; + cout << "Sample " << sample << endl; + cout << "Full data " << thisSample << endl; + cout << "ebADCCounts " << ebADCCounts[sample] << endl; + cout << "ebADCGains " << ebADCGains[sample] << endl; + cout << "gainConv_ " << gainConv_[(int)ebADCGains[sample]] << endl; + cout << "barrelADCtoGeV_ " << barrelADCtoGeV_ << endl; + cout << "ebAnalogSignal " << ebAnalogSignal[sample] << endl; + cout << "LowGain " << LowGain << endl; } - - if(0==1)cout<<"P max "< 27.5) { + cout << "Filling Histo: " << LowGain << endl; + meEBDigiOccupancy_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + if (LowGain == 0) + meEBDigiOccupancyHigh_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + else + meEBDigiOccupancyLow_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); + } + + if (0 == 1) + cout << "P max " << Pmax << endl; + } //end digi } -// ------------ method called once each job just after ending the event loop ------------ -void -PhaseIIAnalyzer::endJob() -{ -} +// ------------ method called once each job just before starting event loop ------------ +void PhaseIIAnalyzer::beginJob() {} +// ------------ method called once each job just after ending the event loop ------------ +void PhaseIIAnalyzer::endJob() {} // ------------ method fills 'descriptions' with the allowed parameters for the module ------------ -void -PhaseIIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { +void PhaseIIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { //The following says we do not know what parameters are allowed so do no validation // Please change this to state exactly what you do use, even if it is no parameters edm::ParameterSetDescription desc; diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h index c3d3f975d8064..73cc0c42896a8 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h @@ -16,69 +16,55 @@ using namespace std; // class declaration // -class PhaseIIAnalyzer : public edm::one::EDAnalyzer { - public: +class PhaseIIAnalyzer : public edm::one::EDAnalyzer { +public: explicit PhaseIIAnalyzer(const edm::ParameterSet&); - ~PhaseIIAnalyzer(); + ~PhaseIIAnalyzer(); static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - - private: - virtual void beginJob() ; - void analyze(const edm::Event&, const edm::EventSetup&) override ; - virtual void endJob() ; +private: + virtual void beginJob(); + void analyze(const edm::Event&, const edm::EventSetup&) override; + virtual void endJob(); edm::InputTag digiTagEB_; - - edm::EDGetTokenT digiTokenEB_; - - edm::InputTag hitTagEB_; + edm::EDGetTokenT digiTokenEB_; - - edm::EDGetTokenT> hitTokenEB_; + edm::InputTag hitTagEB_; + edm::EDGetTokenT> hitTokenEB_; edm::InputTag trackTag_; - edm::EDGetTokenT> trackToken_; - - //Histograms - TH1I *EBEnergyHisto[ecalPh2::sampleSize]; -TH1I *EBGainHisto[ecalPh2::sampleSize]; - + edm::EDGetTokenT> trackToken_; - TH2D* meEBDigiOccupancy_; - TH2D* meEBDigiOccupancyHigh_; - TH2D* meEBDigiOccupancyLow_; - - TH1D* meEBDigiMultiplicity_; - - TH1D* meEBDigiADCGlobal_; - - TH1I* SingleChannelE; - TH1I* SingleChannelELow; + //Histograms + TH1I* EBEnergyHisto[ecalPh2::sampleSize]; + TH1I* EBGainHisto[ecalPh2::sampleSize]; - TH1D* meEBDigiADCAnalog_[ecalPh2::sampleSize]; - TH1D* meEBDigiADCgS_[ecalPh2::sampleSize]; - TH1D* meEBDigiGain_[ecalPh2::sampleSize]; + TH2D* meEBDigiOccupancy_; + TH2D* meEBDigiOccupancyHigh_; + TH2D* meEBDigiOccupancyLow_; + TH1D* meEBDigiMultiplicity_; - TH1D* meEBPedestal_; - -TH1D* meEBMaximumgt100ADC_; - - TH1D* meEBMaximumgt10ADC_; - - TH1D* meEBnADCafterSwitch_; - - TF1 *f; + TH1D* meEBDigiADCGlobal_; + TH1I* SingleChannelE; + TH1I* SingleChannelELow; + TH1D* meEBDigiADCAnalog_[ecalPh2::sampleSize]; + TH1D* meEBDigiADCgS_[ecalPh2::sampleSize]; + TH1D* meEBDigiGain_[ecalPh2::sampleSize]; + TH1D* meEBPedestal_; + TH1D* meEBMaximumgt100ADC_; + TH1D* meEBMaximumgt10ADC_; + TH1D* meEBnADCafterSwitch_; - + TF1* f; }; From 9677137438ce0845dabdd59f5fa39c584f230b05 Mon Sep 17 00:00:00 2001 From: jobereng Date: Wed, 8 Apr 2020 03:02:33 +0200 Subject: [PATCH 05/10] Add Phase 2 comments after PR 11_1_X --- .../interface/EcalDigiCollections_Ph2.h | 6 ++-- DataFormats/EcalDigi/src/EBDataFrame.cc | 2 +- .../interface/EcalSimParameterMap_Ph2.h | 2 +- .../src/EcalSimParameterMap_Ph2.cc | 14 ++++---- .../python/ecalDigiParameters_Ph2_cff.py | 36 +++++++++---------- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc | 12 ++++--- .../plugins/PhaseIIAnalyzer.cc | 16 +++++---- 7 files changed, 46 insertions(+), 42 deletions(-) diff --git a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h index b5c604e2d0a25..c47a588413f2a 100644 --- a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h +++ b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h @@ -2,15 +2,15 @@ #define DIGIECAL_ECALDIGICOLLECTION_PH2_H #include "DataFormats/EcalDigi/interface/EBDataFrame.h" -#include "DataFormats/EcalDigi/interface/EEDataFrame.h" -#include "DataFormats/EcalDigi/interface/ESDataFrame.h" +//#include "DataFormats/EcalDigi/interface/EEDataFrame.h" +//#include "DataFormats/EcalDigi/interface/ESDataFrame.h" #include "DataFormats/EcalDigi/interface/EcalTimeDigi.h" #include "DataFormats/EcalDigi/interface/EcalTriggerPrimitiveDigi.h" #include "DataFormats/EcalDigi/interface/EcalEBTriggerPrimitiveDigi.h" #include "DataFormats/EcalDigi/interface/EcalTrigPrimCompactColl.h" #include "DataFormats/EcalDigi/interface/EcalPseudoStripInputDigi.h" #include "DataFormats/EcalDigi/interface/EBSrFlag.h" -#include "DataFormats/EcalDigi/interface/EESrFlag.h" +//#include "DataFormats/EcalDigi/interface/EESrFlag.h" #include "DataFormats/EcalDigi/interface/EcalPnDiodeDigi.h" #include "DataFormats/EcalDigi/interface/EcalMatacqDigi.h" #include "DataFormats/Common/interface/SortedCollection.h" diff --git a/DataFormats/EcalDigi/src/EBDataFrame.cc b/DataFormats/EcalDigi/src/EBDataFrame.cc index acd83dc03ce91..bee47b39472f2 100644 --- a/DataFormats/EcalDigi/src/EBDataFrame.cc +++ b/DataFormats/EcalDigi/src/EBDataFrame.cc @@ -1,7 +1,7 @@ #include "DataFormats/EcalDigi/interface/EBDataFrame.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include -#warning[DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 +//#warning[DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 float EBDataFrame::spikeEstimator() const { if (size() != 10) { edm::LogError("InvalidNumberOfSamples") diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h index 8562d2960422c..a17bb04fc5b2c 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h @@ -34,7 +34,7 @@ class EcalSimParameterMap_Ph2 : public CaloVSimParameterMap { /// EE //CaloSimParameters theEndcapParameters; /// ES - CaloSimParameters theESParameters; + //CaloSimParameters theESParameters; }; #endif diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc index 33e073a23c3c6..9f830c7d3d60e 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalSimParameterMap_Ph2.cc @@ -10,9 +10,9 @@ */ EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2() - : theBarrelParameters(2250., 1. / 2250., 1., 0, 16, 6, true, true), + : theBarrelParameters(2250., 1. / 2250., 1., 0, 16, 6, true, true){}//, //theEndcapParameters(1800., 1./1800., 1., 0, 16, 6, true, true), - theESParameters(1., 1., 1., 20., 3, 2, false, true) {} + //theESParameters(1., 1., 1., 20., 3, 2, false, true) {} EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBarrel, //double simHitToPhotoelectronsEndcap, @@ -31,11 +31,11 @@ EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBa readoutFrameSize, binOfMaximum, doPhotostatistics, - syncPhase), + syncPhase){}//, //theEndcapParameters(simHitToPhotoelectronsEndcap, photoelectronsToAnalogEndcap, //samplingFactor, timePhase, //readoutFrameSize, binOfMaximum, doPhotostatistics, syncPhase), - theESParameters(1., 1., 1., 20., 3, 2, false, syncPhase) {} + //theESParameters(1., 1., 1., 20., 3, 2, false, syncPhase) {} /* CaloSimParameters(double simHitToPhotoelectrons, double photoelectronsToAnalog, @@ -45,10 +45,10 @@ EcalSimParameterMap_Ph2::EcalSimParameterMap_Ph2(double simHitToPhotoelectronsBa */ const CaloSimParameters& EcalSimParameterMap_Ph2::simParameters(const DetId& detId) const { - if (EcalSubdetector(detId.subdetId()) == EcalBarrel) + //if (EcalSubdetector(detId.subdetId()) == EcalBarrel) return theBarrelParameters; //else if (EcalSubdetector(detId.subdetId()) == EcalEndcap) //return theEndcapParameters; - else - return theESParameters; + //else + //return theESParameters; } diff --git a/SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py b/SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py index cc0eb8ad1ceb4..3f327e2700a1a 100644 --- a/SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py +++ b/SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py @@ -6,29 +6,29 @@ # ESdigiCollection = cms.string(''), UseLCcorrection = cms.untracked.bool(True), - EBCorrNoiseMatrixG12 = cms.vdouble ( - 1.00000, 0.71073, 0.55721, 0.46089, 0.40449, - 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ) , + # EBCorrNoiseMatrixG12 = cms.vdouble ( + # 1.00000, 0.71073, 0.55721, 0.46089, 0.40449, + # 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ) , - EECorrNoiseMatrixG12 = cms.vdouble ( - 1.00000, 0.71373, 0.44825, 0.30152, 0.21609, - 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ) , + # EECorrNoiseMatrixG12 = cms.vdouble ( + # 1.00000, 0.71373, 0.44825, 0.30152, 0.21609, + # 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ) , - EBCorrNoiseMatrixG06 = cms.vdouble ( - 1.00000, 0.70946, 0.58021, 0.49846, 0.45006, - 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ) , + # EBCorrNoiseMatrixG06 = cms.vdouble ( + # 1.00000, 0.70946, 0.58021, 0.49846, 0.45006, + # 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ) , - EECorrNoiseMatrixG06 = cms.vdouble ( - 1.00000, 0.71217, 0.47464, 0.34056, 0.26282, - 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + # EECorrNoiseMatrixG06 = cms.vdouble ( + # 1.00000, 0.71217, 0.47464, 0.34056, 0.26282, + # 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble ( - 1.00000, 0.73354, 0.64442, 0.58851, 0.55425, - 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ) , + # EBCorrNoiseMatrixG01 = cms.vdouble ( + # 1.00000, 0.73354, 0.64442, 0.58851, 0.55425, + # 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ) , - EECorrNoiseMatrixG01 = cms.vdouble ( - 1.00000, 0.72698, 0.62048, 0.55691, 0.51848, - 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ) , + # EECorrNoiseMatrixG01 = cms.vdouble ( + # 1.00000, 0.72698, 0.62048, 0.55691, 0.51848, + # 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ) , #Adding Phase2 noise correlation matrices (dimension 16): FIXME diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc index b13d5a3aeb110..827fa0f96a893 100644 --- a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc @@ -62,7 +62,9 @@ using namespace edm; // // constructors and destructor // + PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) { + //now do what ever initialization is needed usesResource("TFileService"); @@ -74,7 +76,7 @@ PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) { edm::Service fs; //Histograms - for (int isample = 0; isample < 16; isample++) { + for (int isample = 0; isample < ecalPh1::sampleSize; isample++) { EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC", isample), 950, 100, 2000); EBGainHisto[isample] = @@ -145,7 +147,7 @@ void PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iS // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); // cout << "intercalib: " << (*itical) << endl; - const int MAXSAMPLES = ecalPh1::sampleSize; + //const int MAXSAMPLES = ecalPh1::sampleSize; std::vector ebAnalogSignal; std::vector ebADCCounts; @@ -189,9 +191,9 @@ void PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iS cout << " nDigis aaaaaaa " << nDigis << endl; double Emax = 0.; int Pmax = 0; - double pedestalPreSample = 0.; - double pedestalPreSampleAnalog = 0.; - int countsAfterGainSwitch = -1; + //double pedestalPreSample = 0.; + //double pedestalPreSampleAnalog = 0.; + //int countsAfterGainSwitch = -1; for (int sample = 0; sample < nrSamples; ++sample) { ebAnalogSignal[sample] = 0.; diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc index 7fae5cf1dcff5..0af72bf9a3e04 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -62,6 +62,8 @@ using namespace edm; // // constructors and destructor // + + PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) { //now do what ever initialization is needed usesResource("TFileService"); @@ -74,7 +76,7 @@ PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) { edm::Service fs; //Histograms - for (int isample = 0; isample < 16; isample++) { + for (int isample = 0; isample < ecalPh2::sampleSize; isample++) { EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC", isample), 950, 100, 2000); EBGainHisto[isample] = @@ -143,7 +145,7 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); // cout << "intercalib: " << (*itical) << endl; - const int MAXSAMPLES = ecalPh2::sampleSize; + //const int MAXSAMPLES = ecalPh2::sampleSize; std::vector ebAnalogSignal; std::vector ebADCCounts; @@ -185,16 +187,16 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i edm::ESHandle peds; iSetup.get().get(peds); - const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); + //const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); // EcalLiteDTUPedestalsMap::const_iterator itped = DTUpeds_map->getMap().find(ebid); // cout << "mean dei piedistalli: " << (*itped).mean(0) << " rms: " << (*itped).rms(0) << endl; double Emax = 0.; int Pmax = 0; - double pedestalPreSample = 0.; - double pedestalPreSampleAnalog = 0.; - int countsAfterGainSwitch = -1; - double higherGain = 1.; + //double pedestalPreSample = 0.; + //double pedestalPreSampleAnalog = 0.; + //int countsAfterGainSwitch = -1; + //double higherGain = 1.; for (int sample = 0; sample < nrSamples; ++sample) { ebAnalogSignal[sample] = 0.; From b9531cff6cfcd6b8a7610b455d40f6185b549726 Mon Sep 17 00:00:00 2001 From: jobereng Date: Thu, 16 Apr 2020 16:26:00 +0200 Subject: [PATCH 06/10] Add Phase 2 Add Phase 2 comments after PR 11_1_X --- CondFormats/EcalObjects/interface/EcalConstants.h | 7 +++++-- CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h | 7 ++++--- SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h | 6 +++--- SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc | 6 +++--- SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc | 4 ++-- .../plugins/EcalLiteDTUPedestalsESProducer.cc | 9 +++++++-- 6 files changed, 24 insertions(+), 15 deletions(-) diff --git a/CondFormats/EcalObjects/interface/EcalConstants.h b/CondFormats/EcalObjects/interface/EcalConstants.h index cb504df53d94f..5728e15fa169b 100644 --- a/CondFormats/EcalObjects/interface/EcalConstants.h +++ b/CondFormats/EcalObjects/interface/EcalConstants.h @@ -3,14 +3,17 @@ #define EcalObject_EcalConstants_h namespace ecalPh2 { - constexpr double BUNCHSPACE = 6.25; + constexpr double Samp_Period = 6.25; constexpr int NGAINS = 2; constexpr float gains[2] = {10., 1.}; constexpr int sampleSize = 16; + constexpr int NBITS =12;// number of available bits + constexpr int MAXADC =4095;// 2^12 -1, adc max range + constexpr int kEBChannels = 61200; } // namespace ecalPh2 namespace ecalPh1 { - constexpr double BUNCHSPACE = 25.; + constexpr double Samp_Period = 25.; constexpr int NGAINS = 4; constexpr float gains[4] = {0., 12., 6., 1.}; constexpr int sampleSize = 10; diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h index 0eea76667f47f..f28bd6069258a 100644 --- a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -3,8 +3,9 @@ #include "CondFormats/Serialization/interface/Serializable.h" #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" -const int NGAINS = 2; +//const int NGAINS = 2; const int gainId1 = 1; const int gainId10 = 0; @@ -15,7 +16,7 @@ class EcalLiteDTUPed { double rmsarray[2] = {2.8, 1.2}; int setMean(int i, float value) { - if (i >= NGAINS || i < 0) + if (i >= ecalPh2::NGAINS || i < 0) return -1; else meanarray[i] = value; @@ -23,7 +24,7 @@ class EcalLiteDTUPed { } int setRMS(int i, float value) { - if (i >= NGAINS || i < 0) + if (i >= ecalPh2::NGAINS || i < 0) return -1; else rmsarray[i] = value; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h index d66654f3c4708..aadd6703806e1 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h @@ -31,9 +31,9 @@ class EcalCoder_Ph2 { typedef CorrelatedNoisifier Noisifier; enum { - NBITS = 12, // number of available bits - MAXADC = 4095, // 2^12 -1, adc max range - NGAINS = 2 // number of electronic gains + NBITS = ecalPh2::NBITS, // number of available bits + MAXADC = ecalPh2::MAXADC, // 2^12 -1, adc max range + NGAINS = ecalPh2::NGAINS // number of electronic gains }; /// ctor diff --git a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc index f6cd078b7f64c..16134a77cb191 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc @@ -14,7 +14,7 @@ #include "CondFormats/EcalObjects/interface/EcalConstants.h" -using namespace ecalPh2; +//using namespace ecalPh2; EBHitResponse_Ph2::EBHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape, @@ -92,7 +92,7 @@ void EBHitResponse_Ph2::putAPDSignal(const DetId& detId, double npe, double time } const double tzero(apdShape()->timeToRise() - jitter - offsets()[EBDetId(detId).denseIndex() % kNOffsets] - - BUNCHSPACE * (parameters.binOfMaximum() - phaseShift())); + ecalPh2::Samp_Period * (parameters.binOfMaximum() - phaseShift())); double binTime(tzero); @@ -100,7 +100,7 @@ void EBHitResponse_Ph2::putAPDSignal(const DetId& detId, double npe, double time for (unsigned int bin(0); bin != result.size(); ++bin) { result[bin] += (*apdShape())(binTime)*signal; - binTime += BUNCHSPACE; + binTime += ecalPh2::Samp_Period; } } diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc index 3c3d03086793d..b6a7767a8775b 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc @@ -158,7 +158,7 @@ void EcalHitResponse_Ph2::putAnalogSignal(const PCaloHit& hit, CLHEP::HepRandomE const double jitter(time - timeOfFlight(detId)); const double tzero = (shape()->timeToRise() + parameters->timePhase() - jitter - - ecalPh2::BUNCHSPACE * (parameters->binOfMaximum() - m_phaseShift)); + ecalPh2::Samp_Period * (parameters->binOfMaximum() - m_phaseShift)); double binTime(tzero); EcalSamples& result(*findSignal(detId)); @@ -171,7 +171,7 @@ void EcalHitResponse_Ph2::putAnalogSignal(const PCaloHit& hit, CLHEP::HepRandomE for (unsigned int bin(0); bin != rsize; ++bin) { result[bin] += (*shape())(binTime)*signal; - binTime += ecalPh2::BUNCHSPACE; + binTime += ecalPh2::Samp_Period; } } } diff --git a/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc b/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc index 86c51167a2521..1475f4a74d231 100644 --- a/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc +++ b/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc @@ -7,10 +7,15 @@ #include "CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h" #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" #include "CondFormats/EcalObjects/src/classes.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + // // class declaration // -const int kEBChannels = 61200; +//const int kEBChannels = 61200; + + + class EcalLiteDTUPedestalsESProducer : public edm::ESProducer { public: @@ -38,7 +43,7 @@ EcalLiteDTUPedestalsESProducer::ReturnType EcalLiteDTUPedestalsESProducer::produ //std::cout<<"**********Set EB Values "< Date: Fri, 24 Apr 2020 15:38:49 +0200 Subject: [PATCH 07/10] Add Ecal Phase 2 PR comments --- .../CaloObjects/interface/CaloTSamples_Ph2.h | 4 +- .../EcalObjects/interface/EcalConstants.h | 9 ++- .../interface/EcalLiteDTUPedestals.h | 14 +++-- .../EcalDigi/interface/EBDataFrame_Ph2.h | 33 ++++++++++ .../EcalDigi/interface/EcalDataFrame_Ph2.h | 60 +++++++++++++++++++ .../EcalDigi/interface/EcalLiteDTUSample.h | 44 ++++++++++++++ DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc | 34 +++++++++++ DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc | 36 +++++++++++ DataFormats/EcalDigi/src/EcalLiteDTUSample.cc | 9 +++ DataFormats/EcalDigi/src/classes_def.xml | 8 +-- .../interface/EBHitResponse_Ph2.h | 2 +- .../EcalSimAlgos/interface/EcalCoder.h | 2 +- .../EcalSimAlgos/interface/EcalCoder_Ph2.h | 12 ++-- .../interface/EcalDigitizerTraits_Ph2.h | 6 +- .../interface/EcalElectronicsSim_Ph2.h | 9 +-- .../EcalSimAlgos/src/EcalCoder_Ph2.cc | 20 +++---- .../src/EcalElectronicsSim_Ph2.cc | 3 +- .../EcalSimAlgos/src/EcalHitResponse_Ph2.cc | 4 +- .../plugins/EcalCATIAGainRatiosESProducer.cc | 7 ++- .../plugins/EcalLiteDTUPedestalsESProducer.cc | 7 ++- .../python/ecalDigiParameters_Ph2_cff.py | 26 -------- .../src/EcalTimeDigiProducer_Ph2.cc | 2 +- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc | 34 +++++------ .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.h | 7 ++- .../plugins/PhaseIIAnalyzer.cc | 28 ++++----- .../PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h | 6 +- 26 files changed, 315 insertions(+), 111 deletions(-) create mode 100644 DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h create mode 100644 DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h create mode 100644 DataFormats/EcalDigi/interface/EcalLiteDTUSample.h create mode 100644 DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc create mode 100644 DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc create mode 100644 DataFormats/EcalDigi/src/EcalLiteDTUSample.cc diff --git a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h index f6d058368d8cf..20ef97545ac9a 100644 --- a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h +++ b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h @@ -1,5 +1,5 @@ -#ifndef CALOTSAMPLES_Pha2_H -#define CALOTSAMPLES_Pha2_H 1 +#ifndef CALOTSAMPLES_Ph2_H +#define CALOTSAMPLES_Ph2_H 1 #include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" diff --git a/CondFormats/EcalObjects/interface/EcalConstants.h b/CondFormats/EcalObjects/interface/EcalConstants.h index 5728e15fa169b..710ee24bf1362 100644 --- a/CondFormats/EcalObjects/interface/EcalConstants.h +++ b/CondFormats/EcalObjects/interface/EcalConstants.h @@ -8,8 +8,15 @@ namespace ecalPh2 { constexpr float gains[2] = {10., 1.}; constexpr int sampleSize = 16; constexpr int NBITS =12;// number of available bits - constexpr int MAXADC =4095;// 2^12 -1, adc max range + constexpr int MAXADC =(1-NBITS)-1;// 2^12 -1, adc max range constexpr int kEBChannels = 61200; + constexpr double maxEneEB=2000.; + constexpr int gainId1 = 1; + constexpr int gainId10 = 0; + constexpr double meanarray[2] = {13., 8.}; + constexpr double rmsarray[2] = {2.8, 1.2}; + constexpr int kNOffsets = 2000; + } // namespace ecalPh2 namespace ecalPh1 { diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h index f28bd6069258a..9fc152b5d4abf 100644 --- a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -7,13 +7,15 @@ //const int NGAINS = 2; -const int gainId1 = 1; -const int gainId10 = 0; +//const int gainId1 = 1; +//const int gainId10 = 0; class EcalLiteDTUPed { public: - double meanarray[2] = {13., 8.}; - double rmsarray[2] = {2.8, 1.2}; + double meanarray[2] = {ecalPh2::meanarray[0],ecalPh2::meanarray[1]}; + double rmsarray[2] = {ecalPh2::rmsarray[0],ecalPh2::rmsarray[1]}; + + int setMean(int i, float value) { if (i >= ecalPh2::NGAINS || i < 0) @@ -31,9 +33,9 @@ class EcalLiteDTUPed { return 1; } - float mean(int i) const { return meanarray[i]; } + float mean(int i) const { return ecalPh2::meanarray[i]; } - float rms(int i) const { return rmsarray[i]; } + float rms(int i) const { return ecalPh2::rmsarray[i]; } COND_SERIALIZABLE; }; diff --git a/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h new file mode 100644 index 0000000000000..3645bd5e07af7 --- /dev/null +++ b/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h @@ -0,0 +1,33 @@ +#ifndef DIGIECAL_EBDATAFRAME_PH2_H +#define DIGIECAL_EBDATAFRAME_PH2_H + +#include "DataFormats/EcalDetId/interface/EBDetId.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" +#include + +/** \class EBDataFrame_Ph2 + +*/ +class EBDataFrame_Ph2 : public EcalDataFrame_Ph2{ +public: + typedef EBDetId key_type; ///< For the sorted collection + typedef EcalDataFrame_Ph2 Base; + + EBDataFrame_Ph2() {} + // EBDataFrame(DetId i) : Base(i) {} + EBDataFrame_Ph2(edm::DataFrame const& base) : Base(base) {} + EBDataFrame_Ph2(EcalDataFrame_Ph2 const& base) : Base(base) {} + + /** estimator for a signal being a spike + * based on ratios between 4th, 5th and 6th sample + */ + float spikeEstimator() const; + + ~EBDataFrame_Ph2() override {} + + key_type id() const { return Base::id(); } +}; + +std::ostream& operator<<(std::ostream&, const EBDataFrame_Ph2&); + +#endif diff --git a/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h new file mode 100644 index 0000000000000..ce18f48bc8a63 --- /dev/null +++ b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h @@ -0,0 +1,60 @@ +#ifndef DIGIECAL_ECALDATAFRAME_PH2_H +#define DIGIECAL_ECALDATAFRAME_PH2_H +#include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" +#include "DataFormats/DetId/interface/DetId.h" +#include "DataFormats/Common/interface/DataFrame.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + + +//#define EcalMgpaBitwiseGain12 1 +//#define EcalMgpaBitwiseGain6 2 +//#define EcalMgpaBitwiseGain1 3 +//#define EcalMgpaBitwiseGain0 0 + +//#define EcalLiteBitwiseGain1 1 + +/** \class EcalDataFrame_Ph2 + +*/ +class EcalDataFrame_Ph2 { +public: + EcalDataFrame_Ph2() {} + // EcalDataFrame_Ph2(DetId i) : m_data(i) {} + EcalDataFrame_Ph2(edm::DataFrame const& iframe) : m_data(iframe) {} + + virtual ~EcalDataFrame_Ph2() {} + + DetId id() const { return m_data.id(); } + + int size() const { return m_data.size(); } + + EcalLiteDTUSample operator[](int i) const { return m_data[i]; } + EcalLiteDTUSample sample(int i) const { return m_data[i]; } + + // get the leading sample (the first non saturated sample) + // starting from the fourth sample + // (it relies on the fact that the unpaker will discard fixed gain0 DataFrame) + // .. sample numbering: [0, 9] + // .. return -1 in case of no saturation + int lastUnsaturatedSample() const; + // just the boolean method + bool isSaturated() const { return (lastUnsaturatedSample() != -1); } + + // FIXME (shall we throw??) + void setSize(int) {} + // void setPresamples(int ps); + void setSample(int i, EcalLiteDTUSample sam) { m_data[i] = sam; } + + //bool hasSwitchToGain6() const; + //bool hasSwitchToGain1() const; + + int MAXSAMPLES = ecalPh2::sampleSize; + + edm::DataFrame const& frame() const { return m_data; } + edm::DataFrame& frame() { return m_data; } + +private: + edm::DataFrame m_data; +}; + +#endif diff --git a/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h b/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h new file mode 100644 index 0000000000000..9c2c538dcada2 --- /dev/null +++ b/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h @@ -0,0 +1,44 @@ +#ifndef DIGIECAL_ECALLITEDTUSAMPLE_H +#define DIGIECAL_ECALLITEDTUSAMPLE_H + +#include +#include + +namespace ecalLiteDTU { + typedef uint16_t sample_type; + + /// get the ADC sample (12 bits) + constexpr int adc(sample_type sample) { return sample & 0xFFF; } + /// get the gainId (2 bits) + constexpr int gainId(sample_type sample) { return (sample >> 12) & 0x3; } + constexpr sample_type pack(int adc, int gainId) { return (adc & 0xFFF) | ((gainId & 0x3) << 12); } +} // namespace ealLiteDTU + +/** \class EcalLiteDTUSample + * Simple container packer/unpacker for a single sample from the Lite_CATIA electronics + * + * + */ +class EcalLiteDTUSample { +public: + EcalLiteDTUSample() { theSample = 0; } + EcalLiteDTUSample(uint16_t data) { theSample = data; } + EcalLiteDTUSample(int adc, int gainId); + + /// get the raw word + uint16_t raw() const { return theSample; } + /// get the ADC sample (12 bits) + int adc() const { return theSample & 0xFFF; } + /// get the gainId (2 bits) + int gainId() const { return (theSample >> 12) & 0x3; } + /// for streaming + uint16_t operator()() const { return theSample; } + operator uint16_t() const { return theSample; } + +private: + uint16_t theSample; +}; + +std::ostream& operator<<(std::ostream&, const EcalLiteDTUSample&); + +#endif diff --git a/DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc b/DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc new file mode 100644 index 0000000000000..03b8304e90ca1 --- /dev/null +++ b/DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc @@ -0,0 +1,34 @@ +#include "DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include +//#warning[DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 +float EBDataFrame_Ph2::spikeEstimator() const { + if (size() != 10) { + edm::LogError("InvalidNumberOfSamples") + << "This method only applies to signals sampled 10 times (" << size() << " samples found)"; + return 10.; + } + // skip faulty channels + if (sample(5).adc() == 0) + return 10.; + size_t imax = 0; + int maxAdc = 0; + for (int i = 0; i < size(); ++i) { + if (sample(i).adc() > maxAdc) { + imax = i; + maxAdc = sample(i).adc(); + } + } + // skip early signals + if (imax < 4) + return 10.; + float ped = 1. / 3. * (sample(0).adc() + sample(1).adc() + sample(2).adc()); + return 0.18 * (sample(4).adc() - ped) / (sample(5).adc() - ped) + (sample(6).adc() - ped) / (sample(5).adc() - ped); +} + +std::ostream& operator<<(std::ostream& s, const EBDataFrame_Ph2& digi) { + s << digi.id() << " " << digi.size() << " samples " << std::endl; + for (int i = 0; i < digi.size(); i++) + s << " " << digi[i] << std::endl; + return s; +} diff --git a/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc b/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc new file mode 100644 index 0000000000000..13622e50bf07d --- /dev/null +++ b/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc @@ -0,0 +1,36 @@ +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" +#include + +int EcalDataFrame_Ph2::lastUnsaturatedSample() const { + int cnt = 0; + for (size_t i = 3; i < m_data.size(); ++i) { + cnt = 0; + for (size_t j = i; j < (i + 5) && j < m_data.size(); ++j) { + //if (((EcalLiteDTUSample)m_data[j]).gainId() == EcalMgpaBitwiseGain0) + if (((EcalLiteDTUSample)m_data[j]).gainId() == ecalPh2::gainId1){ + ++cnt; + std::cout<<" cuentas "<(m_data[u])).gainId() == EcalMgpaBitwiseGain6) + return true; + } + return false; +}*/ +/* +bool EcalDataFrame_Ph2::hasSwitchToGain1() const { + for (unsigned int u = 0; u < m_data.size(); u++) { + if ((static_cast(m_data[u])).gainId() == EcalMgpaBitwiseGain1) + return true; + } + return false; +}*/ diff --git a/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc b/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc new file mode 100644 index 0000000000000..69f3c1df76f3f --- /dev/null +++ b/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc @@ -0,0 +1,9 @@ +#include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" +#include + +EcalLiteDTUSample::EcalLiteDTUSample(int adc, int gainId) { theSample = (adc & 0xFFF) | ((gainId & 0x3) << 12); } + +std::ostream& operator<<(std::ostream& s, const EcalLiteDTUSample& samp) { + s << "ADC=" << samp.adc() << ", gainId=" << samp.gainId(); + return s; +} diff --git a/DataFormats/EcalDigi/src/classes_def.xml b/DataFormats/EcalDigi/src/classes_def.xml index 29f081252acee..9c40edacab4db 100644 --- a/DataFormats/EcalDigi/src/classes_def.xml +++ b/DataFormats/EcalDigi/src/classes_def.xml @@ -72,11 +72,11 @@ - - + + - - + + diff --git a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h index e7bf7a0c64f17..3184ad953f32d 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h @@ -19,7 +19,7 @@ class EBHitResponse_Ph2 : public EcalHitResponse_Ph2 { typedef std::vector VecD; - enum { kNOffsets = 2000 }; + enum { kNOffsets = ecalPh2::kNOffsets }; EBHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape, diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h index 0fe9792fef649..71a051431f945 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h @@ -1,5 +1,5 @@ #ifndef EcalSimAlgos_EcalCoder_h -#define EcalSimAlgos_EcalCoder_h 1 +#define EcalSimAlgos_EcalCoder_h #include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "CondFormats/EcalObjects/interface/EcalPedestals.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h index aadd6703806e1..03f72418aa104 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h @@ -1,5 +1,5 @@ #ifndef EcalSimAlgos_EcalCoder_Ph2_h -#define EcalSimAlgos_EcalCoder_Ph2_h 1 +#define EcalSimAlgos_EcalCoder_Ph2_h #include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" //#include "CondFormats/EcalObjects/interface/EcalPedestals.h" @@ -11,8 +11,8 @@ template class CorrelatedNoisifier; -class EcalMGPASample; -class EcalDataFrame; +class EcalLiteDTUSample; +class EcalDataFrame_Ph2; class DetId; class EcalLiteDTUPed; @@ -51,15 +51,15 @@ class EcalCoder_Ph2 { void setIntercalibConstants(const EcalIntercalibConstantsMC* ical); - /// from EcalSamples to EcalDataFrame - virtual void analogToDigital(CLHEP::HepRandomEngine*, const EcalSamples& clf, EcalDataFrame& df) const; + /// from EcalSamples to EcalDataFrame_Ph2 + virtual void analogToDigital(CLHEP::HepRandomEngine*, const EcalSamples& clf, EcalDataFrame_Ph2& df) const; private: /// limit on the energy scale due to the electronics range double fullScaleEnergy(const DetId& did) const; /// produce the pulse-shape - void encode(const EcalSamples& ecalSamples, EcalDataFrame& df, CLHEP::HepRandomEngine*) const; + void encode(const EcalSamples& ecalSamples, EcalDataFrame_Ph2& df, CLHEP::HepRandomEngine*) const; void findPedestal(const DetId& detId, int gainId, double& pedestal, double& width) const; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h index 90cc1910d564b..03bfd2245c68d 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h @@ -4,8 +4,8 @@ #include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h" #include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" -#include "DataFormats/EcalDigi/interface/EcalDataFrame.h" -#include "DataFormats/EcalDigi/interface/EBDataFrame.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" +#include "DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" class EcalHitResponse; @@ -14,7 +14,7 @@ class EBDigitizerTraits_Ph2 { /// the digis collection typedef EBDigiCollectionPh2 DigiCollection; /// the dataframes - typedef EBDataFrame Digi; + typedef EBDataFrame_Ph2 Digi; /// the electronics simulation typedef EcalElectronicsSim_Ph2 ElectronicsSim_Ph2; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h index 0c4a1ef38c43a..c3d777a2fa08a 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h @@ -4,9 +4,11 @@ #include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" + class EcalCoder_Ph2; -class EcalDataFrame; +//class EcalDataFrame_Ph2; class EcalSimParameterMap_Ph2; namespace CLHEP { @@ -21,7 +23,6 @@ namespace CLHEP { class EcalElectronicsSim_Ph2 { public: typedef CaloTSamples_Ph2 EcalSamples; - //typedef CaloTSamples_Ph2 EcalSamples; EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, EcalCoder_Ph2* coder, bool applyConstantTerm, @@ -29,8 +30,8 @@ class EcalElectronicsSim_Ph2 { ~EcalElectronicsSim_Ph2(); - /// from EcalSamples to EcalDataFrame - void analogToDigital(CLHEP::HepRandomEngine*, EcalSamples& clf, EcalDataFrame& df) const; + /// from EcalSamples to EcalDataFrame_Ph2 + void analogToDigital(CLHEP::HepRandomEngine*, EcalSamples& clf, EcalDataFrame_Ph2& df) const; void newEvent() {} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc index d8e19e92f4fd4..e1754158c55a4 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc @@ -1,8 +1,8 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.h" -#include "DataFormats/EcalDigi/interface/EcalMGPASample.h" -#include "DataFormats/EcalDigi/interface/EcalDataFrame.h" +#include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" @@ -31,7 +31,7 @@ EcalCoder_Ph2::EcalCoder_Ph2(bool addNoise, m_gainRatios(nullptr), m_intercals(nullptr), // m_maxEneEB ( 1668.3 ) , // 4095(MAXADC)*12(gain 2)*0.035(GeVtoADC)*0.97 - m_maxEneEB(2000.), // Maximum for CATIA: LSB gain 10: 0.048 MeV + m_maxEneEB(ecalPh2::maxEneEB), // Maximum for CATIA: LSB gain 10: 0.048 MeV m_addNoise(addNoise), m_PreMix1(PreMix1) @@ -45,7 +45,7 @@ EcalCoder_Ph2::~EcalCoder_Ph2() {} void EcalCoder_Ph2::setFullScaleEnergy(double EBscale) { // m_maxEneEB = EBscale ; - m_maxEneEB = 2000.; //I don 't know where is setFullScaleEnergy first call + m_maxEneEB = ecalPh2::maxEneEB; //I don 't know where is setFullScaleEnergy first call } void EcalCoder_Ph2::setPedestals(const EcalLiteDTUPedestals* pedestals) { m_peds = pedestals; } @@ -59,12 +59,12 @@ double EcalCoder_Ph2::fullScaleEnergy(const DetId& detId) const { return m_maxEneEB; } -void EcalCoder_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, const EcalSamples& clf, EcalDataFrame& df) const { +void EcalCoder_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, const EcalSamples& clf, EcalDataFrame_Ph2& df) const { df.setSize(clf.size()); encode(clf, df, engine); } -void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame& df, CLHEP::HepRandomEngine* engine) const { +void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame_Ph2& df, CLHEP::HepRandomEngine* engine) const { assert(nullptr != m_peds); const unsigned int csize(ecalSamples.size()); @@ -109,7 +109,7 @@ void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame& df, CL const Noisifier* noisy[NGAINS] = {m_ebCorrNoise[0], m_ebCorrNoise[1]}; if (m_addNoise) { -#warning noise generation to be checked +//#warning noise generation to be checked noisy[0]->noisify(noiseframe[0], engine); // high gain //if( nullptr == noisy[1] ) noisy[0]->noisify( noiseframe[1] , // engine, @@ -163,9 +163,9 @@ void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame& df, CL } else adctrace[i][igain] = adc; - if (ecalSamples[i] > 0.) { + //if (ecalSamples[i] > 0.) { // std::cout<<" igain = "< ReturnType; + //typedef std::shared_ptr ReturnType; + typedef std::unique_ptr ReturnType; ReturnType produce(const EcalCATIAGainRatiosRcd& iRecord); @@ -33,7 +34,7 @@ EcalCATIAGainRatiosESProducer::EcalCATIAGainRatiosESProducer(const edm::Paramete //// EcalCATIAGainRatiosESProducer::ReturnType EcalCATIAGainRatiosESProducer::produce(const EcalCATIAGainRatiosRcd& iRecord) { //std::cout<<"********Starting Production"<(); + auto prod = std::make_unique(); //std::cout<<"**********Set EB Values "< ReturnType; - + //typedef std::shared_ptr ReturnType; + typedef std::unique_ptr ReturnType; + ReturnType produce(const EcalLiteDTUPedestalsRcd& iRecord); private: @@ -39,7 +40,7 @@ EcalLiteDTUPedestalsESProducer::EcalLiteDTUPedestalsESProducer(const edm::Parame EcalLiteDTUPedestalsESProducer::ReturnType EcalLiteDTUPedestalsESProducer::produce( const EcalLiteDTUPedestalsRcd& iRecord) { //std::cout<<"********Starting Production"<(); + auto prod = std::make_unique(); //std::cout<<"**********Set EB Values "< 250) { - cout << "Channel: " << ebid << endl; - cout << "Sample " << sample << endl; - cout << " Full data " << thisSample << endl; - cout << " ebADCCounts " << ebADCCounts[sample] << endl; - cout << " ebADCGains " << ebADCGains[sample] << endl; - cout << " gainConv_ " << gainConv_[(int)ebADCGains[sample]] << endl; - cout << " barrelADCtoGeV_ " << barrelADCtoGeV_ << endl; - cout << " ebAnalogSignal " << ebAnalogSignal[sample] << endl; + std::cout << "Channel: " << ebid << std::endl; + std::cout << "Sample " << sample << std::endl; + std::cout << " Full data " << thisSample << std::endl; + std::cout << " ebADCCounts " << ebADCCounts[sample] << std::endl; + std::cout << " ebADCGains " << ebADCGains[sample] << std::endl; + std::cout << " gainConv_ " << gainConv_[(int)ebADCGains[sample]] << std::endl; + std::cout << " barrelADCtoGeV_ " << barrelADCtoGeV_ << std::endl; + std::cout << " ebAnalogSignal " << ebAnalogSignal[sample] << std::endl; } if (Emax < ebAnalogSignal[sample]) { @@ -252,9 +252,9 @@ void PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iS } if (1 == 1) - cout << "P max " << Pmax << endl; - cout << "High Gain: " << HighGain << " MidGain " << MidGain << " LowGain " << LowGain << endl; - cout << "maxADCValue " << maxADCValue << endl; + std::cout << "P max " << Pmax << std::endl; + std::cout << "High Gain: " << HighGain << " MidGain " << MidGain << " LowGain " << LowGain << std::endl; + std::cout << "maxADCValue " << maxADCValue << std::endl; if (maxADCValue > 250) { meEBDigiOccupancy_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); if (HighGain == 1) @@ -278,9 +278,9 @@ void PhaseIAnalyzer::endJob() {} void PhaseIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { //The following says we do not know what parameters are allowed so do no validation // Please change this to state exactly what you do use, even if it is no parameters - edm::ParameterSetDescription desc; - desc.setUnknown(); - descriptions.addDefault(desc); + //edm::ParameterSetDescription desc; + //desc.setUnknown(); + //descriptions.addDefault(desc); } //define this as a plug-in diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h index 9ee3fb51939f1..69354cbe3d9a5 100644 --- a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h @@ -11,7 +11,8 @@ #include #include "CondFormats/EcalObjects/interface/EcalConstants.h" -using namespace std; +//using namespace std; + // // class declaration // @@ -34,10 +35,10 @@ class PhaseIAnalyzer : public edm::one::EDAnalyzer { edm::InputTag hitTagEB_; - edm::EDGetTokenT> hitTokenEB_; + edm::EDGetTokenT> hitTokenEB_; edm::InputTag trackTag_; - edm::EDGetTokenT> trackToken_; + edm::EDGetTokenT> trackToken_; //Histograms TH1I* EBEnergyHisto[ecalPh2::sampleSize]; diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc index 0af72bf9a3e04..0354678520720 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -229,15 +229,15 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i SingleChannelELow->SetBinContent(sample, ebADCCounts[sample]); } if (ebADCCounts[sample] > 27) { - cout << "Channel: " << ebid << endl; - cout << "Sample " << sample << endl; - cout << "Full data " << thisSample << endl; - cout << "ebADCCounts " << ebADCCounts[sample] << endl; - cout << "ebADCGains " << ebADCGains[sample] << endl; - cout << "gainConv_ " << gainConv_[(int)ebADCGains[sample]] << endl; - cout << "barrelADCtoGeV_ " << barrelADCtoGeV_ << endl; - cout << "ebAnalogSignal " << ebAnalogSignal[sample] << endl; - cout << "LowGain " << LowGain << endl; + std::cout << "Channel: " << ebid << std::endl; + std::cout << "Sample " << sample << std::endl; + std::cout << "Full data " << thisSample << std::endl; + std::cout << "ebADCCounts " << ebADCCounts[sample] << std::endl; + std::cout << "ebADCGains " << ebADCGains[sample] << std::endl; + std::cout << "gainConv_ " << gainConv_[(int)ebADCGains[sample]] << std::endl; + std::cout << "barrelADCtoGeV_ " << barrelADCtoGeV_ << std::endl; + std::cout << "ebAnalogSignal " << ebAnalogSignal[sample] << std::endl; + std::cout << "LowGain " << LowGain << std::endl; } if (Emax < ebAnalogSignal[sample]) { @@ -247,7 +247,7 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i } // end samples if (maxADCValue > 27.5) { - cout << "Filling Histo: " << LowGain << endl; + std::cout << "Filling Histo: " << LowGain << std::endl; meEBDigiOccupancy_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); if (LowGain == 0) meEBDigiOccupancyHigh_->SetBinContent(ebid.iphi(), ebid.ieta(), maxADCValue); @@ -256,7 +256,7 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i } if (0 == 1) - cout << "P max " << Pmax << endl; + std::cout << "P max " << Pmax << std::endl; } //end digi } @@ -270,9 +270,9 @@ void PhaseIIAnalyzer::endJob() {} void PhaseIIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { //The following says we do not know what parameters are allowed so do no validation // Please change this to state exactly what you do use, even if it is no parameters - edm::ParameterSetDescription desc; - desc.setUnknown(); - descriptions.addDefault(desc); + //edm::ParameterSetDescription desc; + //desc.setUnknown(); + //descriptions.addDefault(desc); } //define this as a plug-in diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h index 73cc0c42896a8..51ddd46d0c31e 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h @@ -11,7 +11,7 @@ #include #include "CondFormats/EcalObjects/interface/EcalConstants.h" -using namespace std; +//using namespace std; // // class declaration // @@ -34,10 +34,10 @@ class PhaseIIAnalyzer : public edm::one::EDAnalyzer { edm::InputTag hitTagEB_; - edm::EDGetTokenT> hitTokenEB_; + edm::EDGetTokenT> hitTokenEB_; edm::InputTag trackTag_; - edm::EDGetTokenT> trackToken_; + edm::EDGetTokenT> trackToken_; //Histograms TH1I* EBEnergyHisto[ecalPh2::sampleSize]; From 7568315efd04038853627768ff262d1c0ca581db Mon Sep 17 00:00:00 2001 From: rselvati Date: Wed, 29 Apr 2020 13:46:56 +0200 Subject: [PATCH 08/10] implement comments and corrections --- .../CaloObjects/interface/CaloTSamples_Ph2.h | 4 +- .../interface/EcalLiteDTUPedestalsRcd.h | 4 +- .../interface/EcalCATIAGainRatios.h | 4 +- .../EcalObjects/interface/EcalConstants.h | 20 ++++----- .../interface/EcalLiteDTUPedestals.h | 24 ++++------- .../EcalObjects/src/SerializationManual.h | 2 +- .../src/T_EventSetup_EcalLiteDTUPedestals.cc | 2 +- CondFormats/EcalObjects/src/classes.h | 6 +-- CondFormats/EcalObjects/src/classes_def.xml | 8 ++-- .../EcalDigi/interface/EBDataFrame_Ph2.h | 6 +-- .../EcalDigi/interface/EcalDataFrame_Ph2.h | 12 +----- .../interface/EcalDigiCollections_Ph2.h | 17 ++++---- .../EcalDigi/interface/EcalLiteDTUSample.h | 19 +++++---- DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc | 23 ++--------- DataFormats/EcalDigi/src/EcalLiteDTUSample.cc | 4 +- .../interface/EBHitResponse_Ph2.h | 4 +- .../EcalSimAlgos/interface/EcalCoder.h | 4 +- .../EcalSimAlgos/interface/EcalCoder_Ph2.h | 15 ++++--- .../interface/EcalCorrelatedNoiseMatrix_Ph2.h | 4 +- .../interface/EcalDigitizerTraits_Ph2.h | 4 +- .../interface/EcalElectronicsSim_Ph2.h | 7 ++-- .../interface/EcalHitResponse_Ph2.h | 4 +- .../interface/EcalSimParameterMap_Ph2.h | 4 +- .../interface/EcalTDigitizer_Ph2.h | 4 +- .../EcalSimAlgos/src/EcalCoder_Ph2.cc | 14 ++++--- .../src/EcalElectronicsSim_Ph2.cc | 2 +- .../EcalSimAlgos/src/EcalHitResponse_Ph2.cc | 2 +- .../src/EcalSimParameterMap_Ph2.cc | 20 ++++----- .../plugins/EcalLiteDTUPedestalsESProducer.cc | 12 ++---- .../python/esCATIAGainProducer_cfi.py | 2 - .../esEcalLiteDTUPedestalsProducer_cfi.py | 2 - .../src/EcalDigiProducer_Ph2.cc | 12 +----- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc | 33 --------------- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.h | 9 +++-- .../PhaseIAnalyzer/python/Digitizer1.root | Bin 57745 -> 0 bytes .../run_PhaseIAnalyzer.py} | 0 .../plugins/PhaseIIAnalyzer.cc | 38 +----------------- .../PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h | 8 ++-- .../PhaseIIAnalyzer/python/Digitizer2.root | Bin 54766 -> 0 bytes .../run_PhaseIIAnalyzer.py} | 0 SimGeneral/MixingModule/python/aliases_cfi.py | 15 ------- 41 files changed, 124 insertions(+), 250 deletions(-) delete mode 100644 SimCalorimetry/PhaseIAnalyzer/python/Digitizer1.root rename SimCalorimetry/PhaseIAnalyzer/{python/ConfFile_cfg.py => test/run_PhaseIAnalyzer.py} (100%) delete mode 100644 SimCalorimetry/PhaseIIAnalyzer/python/Digitizer2.root rename SimCalorimetry/PhaseIIAnalyzer/{python/ConfFile_cfg.py => test/run_PhaseIIAnalyzer.py} (100%) diff --git a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h index 20ef97545ac9a..d4ec760074eef 100644 --- a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h +++ b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h @@ -1,5 +1,5 @@ -#ifndef CALOTSAMPLES_Ph2_H -#define CALOTSAMPLES_Ph2_H 1 +#ifndef CalibFormats_CaloObjects_CaloTSamples_Ph2_h +#define CalibFormats_CaloObjects_CaloTSamples_Ph2_h #include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" diff --git a/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h b/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h index 2228c73fb777a..44cd477b836ef 100644 --- a/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h +++ b/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h @@ -1,5 +1,5 @@ -#ifndef ECALLITEDTUPEDESTALSRCD_H -#define ECALLITEDTUPEDESTALSRCD_H +#ifndef CondFormats_DataRecord_EcalLiteDTUPedestalsRcd_h +#define CondFormats_DataRecord_EcalLiteDTUPedestalsRcd_h #include "FWCore/Framework/interface/EventSetupRecordImplementation.h" class EcalLiteDTUPedestalsRcd : public edm::eventsetup::EventSetupRecordImplementation {}; diff --git a/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h b/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h index 7f1d67c7a8da1..56ba116355817 100644 --- a/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h +++ b/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h @@ -1,5 +1,5 @@ -#ifndef _CondFormats_EcalObjects_EcalGainRatios_h_ -#define _CondFormats_EcalObjects_EcalGainRatios_h_ +#ifndef CondFormats_EcalObjects_EcalCATIAGainRatios_h +#define CondFormats_EcalObjects_EcalCATIAGainRatios_h #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" diff --git a/CondFormats/EcalObjects/interface/EcalConstants.h b/CondFormats/EcalObjects/interface/EcalConstants.h index 710ee24bf1362..cc302e4642090 100644 --- a/CondFormats/EcalObjects/interface/EcalConstants.h +++ b/CondFormats/EcalObjects/interface/EcalConstants.h @@ -1,22 +1,22 @@ //Namespaces for Phase1 and Phase2 -#ifndef EcalObject_EcalConstants_h -#define EcalObject_EcalConstants_h +#ifndef CondFormats_EcalObject_EcalConstants_h +#define CondFormats_EcalObject_EcalConstants_h namespace ecalPh2 { constexpr double Samp_Period = 6.25; constexpr int NGAINS = 2; constexpr float gains[2] = {10., 1.}; - constexpr int sampleSize = 16; - constexpr int NBITS =12;// number of available bits - constexpr int MAXADC =(1-NBITS)-1;// 2^12 -1, adc max range - constexpr int kEBChannels = 61200; - constexpr double maxEneEB=2000.; constexpr int gainId1 = 1; constexpr int gainId10 = 0; - constexpr double meanarray[2] = {13., 8.}; - constexpr double rmsarray[2] = {2.8, 1.2}; + constexpr int sampleSize = 16; + constexpr int NBITS = 12; // number of available bits + constexpr int MAXADC = (1 << NBITS) - 1; // 2^12 -1, adc max range + constexpr int kEBChannels = 61200; + constexpr double maxEneEB = 2000.; constexpr int kNOffsets = 2000; - + constexpr unsigned int kAdcMask = 0xFFF; + constexpr unsigned int kGainIdMask = 0x3; + } // namespace ecalPh2 namespace ecalPh1 { diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h index 9fc152b5d4abf..d21b099012460 100644 --- a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -1,21 +1,14 @@ -#ifndef EcalLiteDTUPedestals_h -#define EcalLiteDTUPedestals_h +#ifndef CondFormats_EcalObject_EcalLiteDTUPedestals_h +#define CondFormats_EcalObject_EcalLiteDTUPedestals_h #include "CondFormats/Serialization/interface/Serializable.h" #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" -//const int NGAINS = 2; - -//const int gainId1 = 1; -//const int gainId10 = 0; - -class EcalLiteDTUPed { +class EcalLiteDTUPedestals { public: - double meanarray[2] = {ecalPh2::meanarray[0],ecalPh2::meanarray[1]}; - double rmsarray[2] = {ecalPh2::rmsarray[0],ecalPh2::rmsarray[1]}; - - + float meanarray[2] = {13., 8.}; + float rmsarray[2] = {2.8, 1.2}; int setMean(int i, float value) { if (i >= ecalPh2::NGAINS || i < 0) @@ -33,15 +26,14 @@ class EcalLiteDTUPed { return 1; } - float mean(int i) const { return ecalPh2::meanarray[i]; } + float mean(int i) const { return meanarray[i]; } - float rms(int i) const { return ecalPh2::rmsarray[i]; } + float rms(int i) const { return rmsarray[i]; } COND_SERIALIZABLE; }; -typedef EcalCondObjectContainer EcalLiteDTUPedestalsMap; +typedef EcalCondObjectContainer EcalLiteDTUPedestalsMap; typedef EcalLiteDTUPedestalsMap::const_iterator EcalLiteDTUPedestalsMapIterator; -typedef EcalLiteDTUPedestalsMap EcalLiteDTUPedestals; #endif diff --git a/CondFormats/EcalObjects/src/SerializationManual.h b/CondFormats/EcalObjects/src/SerializationManual.h index 7b00af632211d..2f6158477b05d 100644 --- a/CondFormats/EcalObjects/src/SerializationManual.h +++ b/CondFormats/EcalObjects/src/SerializationManual.h @@ -4,7 +4,7 @@ COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); -COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); +COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); COND_SERIALIZATION_INSTANTIATE(EcalCondObjectContainer); diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc index 768ececabe40d..b240af9ef895b 100644 --- a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc @@ -16,4 +16,4 @@ #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" #include "FWCore/Utilities/interface/typelookup.h" -TYPELOOKUP_DATA_REG(EcalLiteDTUPedestals); +TYPELOOKUP_DATA_REG(EcalLiteDTUPedestalsMap); diff --git a/CondFormats/EcalObjects/src/classes.h b/CondFormats/EcalObjects/src/classes.h index cbf507c143274..38dde54d2e79b 100644 --- a/CondFormats/EcalObjects/src/classes.h +++ b/CondFormats/EcalObjects/src/classes.h @@ -97,9 +97,9 @@ namespace CondFormats_EcalObjects { EcalCondObjectContainer pedmap; //typedef EcalPedestals //ECAL PH2: - std::vector v_ecalDTUPed; - EcalContainer ec_ebDetId_ecalLiteDTUPed; - EcalCondObjectContainer pedmapDTU; //typedef EcalPedestals + std::vector v_ecalDTUPedestals; + EcalContainer ec_ebDetId_ecalLiteDTUPedestals; + EcalCondObjectContainer pedmapDTU; //typedef EcalPedestals std::vector v_ecalTPGCrystalStatusCode; EcalContainer ec_eeDetId_ecalTPGCrystalStatusCode; diff --git a/CondFormats/EcalObjects/src/classes_def.xml b/CondFormats/EcalObjects/src/classes_def.xml index b977b995ae480..c5cc8af4e828b 100644 --- a/CondFormats/EcalObjects/src/classes_def.xml +++ b/CondFormats/EcalObjects/src/classes_def.xml @@ -82,11 +82,11 @@ - + - - - + + + diff --git a/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h index 3645bd5e07af7..0c099771e2ad7 100644 --- a/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h +++ b/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h @@ -1,5 +1,5 @@ -#ifndef DIGIECAL_EBDATAFRAME_PH2_H -#define DIGIECAL_EBDATAFRAME_PH2_H +#ifndef DataFormats_EcalDigi_EBDataFrame_Ph2_h +#define DataFormats_EcalDigi_EBDataFrame_Ph2_h #include "DataFormats/EcalDetId/interface/EBDetId.h" #include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" @@ -8,7 +8,7 @@ /** \class EBDataFrame_Ph2 */ -class EBDataFrame_Ph2 : public EcalDataFrame_Ph2{ +class EBDataFrame_Ph2 : public EcalDataFrame_Ph2 { public: typedef EBDetId key_type; ///< For the sorted collection typedef EcalDataFrame_Ph2 Base; diff --git a/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h index ce18f48bc8a63..05fd1382a6c30 100644 --- a/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h +++ b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h @@ -1,18 +1,10 @@ -#ifndef DIGIECAL_ECALDATAFRAME_PH2_H -#define DIGIECAL_ECALDATAFRAME_PH2_H +#ifndef DataFormats_EcalDigi_EcalDataFrame_Ph2_h +#define DataFormats_EcalDigi_EcalDataFrame_Ph2_h #include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" #include "DataFormats/DetId/interface/DetId.h" #include "DataFormats/Common/interface/DataFrame.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" - -//#define EcalMgpaBitwiseGain12 1 -//#define EcalMgpaBitwiseGain6 2 -//#define EcalMgpaBitwiseGain1 3 -//#define EcalMgpaBitwiseGain0 0 - -//#define EcalLiteBitwiseGain1 1 - /** \class EcalDataFrame_Ph2 */ diff --git a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h index c47a588413f2a..fa7daa5bfe18b 100644 --- a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h +++ b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h @@ -1,16 +1,13 @@ -#ifndef DIGIECAL_ECALDIGICOLLECTION_PH2_H -#define DIGIECAL_ECALDIGICOLLECTION_PH2_H +#ifndef DataFormats_EcalDigi_EcalDigiCollections_Ph2_h +#define DataFormats_EcalDigi_EcalDigiCollections_Ph2_h #include "DataFormats/EcalDigi/interface/EBDataFrame.h" -//#include "DataFormats/EcalDigi/interface/EEDataFrame.h" -//#include "DataFormats/EcalDigi/interface/ESDataFrame.h" #include "DataFormats/EcalDigi/interface/EcalTimeDigi.h" -#include "DataFormats/EcalDigi/interface/EcalTriggerPrimitiveDigi.h" -#include "DataFormats/EcalDigi/interface/EcalEBTriggerPrimitiveDigi.h" -#include "DataFormats/EcalDigi/interface/EcalTrigPrimCompactColl.h" +//#include "DataFormats/EcalDigi/interface/EcalTriggerPrimitiveDigi.h" +//#include "DataFormats/EcalDigi/interface/EcalEBTriggerPrimitiveDigi.h" +//#include "DataFormats/EcalDigi/interface/EcalTrigPrimCompactColl.h" #include "DataFormats/EcalDigi/interface/EcalPseudoStripInputDigi.h" #include "DataFormats/EcalDigi/interface/EBSrFlag.h" -//#include "DataFormats/EcalDigi/interface/EESrFlag.h" #include "DataFormats/EcalDigi/interface/EcalPnDiodeDigi.h" #include "DataFormats/EcalDigi/interface/EcalMatacqDigi.h" #include "DataFormats/Common/interface/SortedCollection.h" @@ -50,8 +47,8 @@ inline void swap(EBDigiCollectionPh2& lhs, EBDigiCollectionPh2& rhs) { lhs.swap( typedef edm::SortedCollection EcalTimeDigiCollection; //DA ELIMINARE??? -typedef edm::SortedCollection EcalTrigPrimDigiCollection; -typedef edm::SortedCollection EcalEBTrigPrimDigiCollection; +//typedef edm::SortedCollection EcalTrigPrimDigiCollection; +//typedef edm::SortedCollection EcalEBTrigPrimDigiCollection; typedef edm::SortedCollection EcalPSInputDigiCollection; typedef edm::SortedCollection EBSrFlagCollection; diff --git a/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h b/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h index 9c2c538dcada2..e359e3438d963 100644 --- a/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h +++ b/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h @@ -1,18 +1,21 @@ -#ifndef DIGIECAL_ECALLITEDTUSAMPLE_H -#define DIGIECAL_ECALLITEDTUSAMPLE_H +#ifndef DataFormats_EcalDigi_EcalLiteDTUSample_h +#define DataFormats_EcalDigi_EcalLiteDTUSample_h #include #include +#include "CondFormats/EcalObjects/interface/EcalConstants.h" namespace ecalLiteDTU { typedef uint16_t sample_type; /// get the ADC sample (12 bits) - constexpr int adc(sample_type sample) { return sample & 0xFFF; } + constexpr int adc(sample_type sample) { return sample & ecalPh2::kAdcMask; } /// get the gainId (2 bits) - constexpr int gainId(sample_type sample) { return (sample >> 12) & 0x3; } - constexpr sample_type pack(int adc, int gainId) { return (adc & 0xFFF) | ((gainId & 0x3) << 12); } -} // namespace ealLiteDTU + constexpr int gainId(sample_type sample) { return (sample >> ecalPh2::NBITS) & ecalPh2::kGainIdMask; } + constexpr sample_type pack(int adc, int gainId) { + return (adc & ecalPh2::kAdcMask) | ((gainId & ecalPh2::kGainIdMask) << ecalPh2::NBITS); + } +} // namespace ecalLiteDTU /** \class EcalLiteDTUSample * Simple container packer/unpacker for a single sample from the Lite_CATIA electronics @@ -28,9 +31,9 @@ class EcalLiteDTUSample { /// get the raw word uint16_t raw() const { return theSample; } /// get the ADC sample (12 bits) - int adc() const { return theSample & 0xFFF; } + int adc() const { return theSample & ecalPh2::kAdcMask; } /// get the gainId (2 bits) - int gainId() const { return (theSample >> 12) & 0x3; } + int gainId() const { return (theSample >> ecalPh2::NBITS) & ecalPh2::kGainIdMask; } /// for streaming uint16_t operator()() const { return theSample; } operator uint16_t() const { return theSample; } diff --git a/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc b/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc index 13622e50bf07d..04a43056e4cb0 100644 --- a/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc +++ b/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc @@ -8,29 +8,12 @@ int EcalDataFrame_Ph2::lastUnsaturatedSample() const { cnt = 0; for (size_t j = i; j < (i + 5) && j < m_data.size(); ++j) { //if (((EcalLiteDTUSample)m_data[j]).gainId() == EcalMgpaBitwiseGain0) - if (((EcalLiteDTUSample)m_data[j]).gainId() == ecalPh2::gainId1){ - ++cnt; - std::cout<<" cuentas "<(m_data[u])).gainId() == EcalMgpaBitwiseGain6) - return true; - } - return false; -}*/ -/* -bool EcalDataFrame_Ph2::hasSwitchToGain1() const { - for (unsigned int u = 0; u < m_data.size(); u++) { - if ((static_cast(m_data[u])).gainId() == EcalMgpaBitwiseGain1) - return true; - } - return false; -}*/ diff --git a/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc b/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc index 69f3c1df76f3f..bb036f3472054 100644 --- a/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc +++ b/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc @@ -1,7 +1,9 @@ #include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" #include -EcalLiteDTUSample::EcalLiteDTUSample(int adc, int gainId) { theSample = (adc & 0xFFF) | ((gainId & 0x3) << 12); } +EcalLiteDTUSample::EcalLiteDTUSample(int adc, int gainId) { + theSample = (adc & ecalPh2::kAdcMask) | ((gainId & ecalPh2::kGainIdMask) << ecalPh2::NBITS); +} std::ostream& operator<<(std::ostream& s, const EcalLiteDTUSample& samp) { s << "ADC=" << samp.adc() << ", gainId=" << samp.gainId(); diff --git a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h index 3184ad953f32d..8a87c5bedc705 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EBHitResponse_Ph2_h -#define EcalSimAlgos_EBHitResponse_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EBHitResponse_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EBHitResponse_Ph2_h #include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h index 71a051431f945..6232f4a3fff43 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EcalCoder_h -#define EcalSimAlgos_EcalCoder_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalCoder_h +#define SimCalorimetry_EcalSimAlgos_EcalCoder_h #include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "CondFormats/EcalObjects/interface/EcalPedestals.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h index 03f72418aa104..bc610380d60fc 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h @@ -1,8 +1,7 @@ -#ifndef EcalSimAlgos_EcalCoder_Ph2_h -#define EcalSimAlgos_EcalCoder_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalCoder_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalCoder_Ph2_h #include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" -//#include "CondFormats/EcalObjects/interface/EcalPedestals.h" #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" #include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" #include "CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h" @@ -31,9 +30,9 @@ class EcalCoder_Ph2 { typedef CorrelatedNoisifier Noisifier; enum { - NBITS = ecalPh2::NBITS, // number of available bits - MAXADC = ecalPh2::MAXADC, // 2^12 -1, adc max range - NGAINS = ecalPh2::NGAINS // number of electronic gains + NBITS = ecalPh2::NBITS, // number of available bits + MAXADC = ecalPh2::MAXADC, // 2^12 -1, adc max range + NGAINS = ecalPh2::NGAINS // number of electronic gains }; /// ctor @@ -43,7 +42,7 @@ class EcalCoder_Ph2 { virtual ~EcalCoder_Ph2(); /// can be fetched every event from the EventSetup - void setPedestals(const EcalLiteDTUPedestals* pedestals); + void setPedestals(const EcalLiteDTUPedestalsMap* pedestals); void setGainRatios(const EcalCATIAGainRatios* gainRatios); @@ -67,7 +66,7 @@ class EcalCoder_Ph2 { void findIntercalibConstant(const DetId& detId, double& icalconst) const; - const EcalLiteDTUPedestals* m_peds; + const EcalLiteDTUPedestalsMap* m_peds; const EcalCATIAGainRatios* m_gainRatios; // the electronics gains diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h index 10bceecb659b3..40ec734fb6c3f 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix_Ph2.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EcalCorrelatedNoiseMatrix_Ph2_h -#define EcalSimAlgos_EcalCorrelatedNoiseMatrix_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalCorrelatedNoiseMatrix_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalCorrelatedNoiseMatrix_Ph2_h #include "DataFormats/Math/interface/Error.h" #include "CalibFormats/CaloObjects/interface/CaloSamples.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h index 03bfd2245c68d..4e1b82adbd8e6 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EcalDigitizerTraits_Ph2_h -#define EcalSimAlgos_EcalDigitizerTraits_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalDigitizerTraits_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalDigitizerTraits_Ph2_h #include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h index c3d777a2fa08a..1ab66a63853b4 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h @@ -1,11 +1,10 @@ -#ifndef EcalSimAlgos_EcalElectronicsSim_Ph2_h -#define EcalSimAlgos_EcalElectronicsSim_Ph2_h 1 +#ifndef SimCalorimetry_EcalSimAlgos_EcalElectronicsSim_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalElectronicsSim_Ph2_h #include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" -#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" - +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" class EcalCoder_Ph2; //class EcalDataFrame_Ph2; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h index f871997f01eb9..d1f7fb7d32d4f 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EcalHitResponse_Ph2_h -#define EcalSimAlgos_EcalHitResponse_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalHitResponse_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalHitResponse_Ph2_h #include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" #include "CalibFormats/CaloObjects/interface/CaloSamples.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h index a17bb04fc5b2c..47a4facf36d4c 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EcalSimParameterMap_Ph2_h -#define EcalSimAlgos_EcalSimParameterMap_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalSimParameterMap_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalSimParameterMap_Ph2_h #include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h index 41f361b92c1fc..773f1e686ff99 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h @@ -1,5 +1,5 @@ -#ifndef EcalSimAlgos_EcalTDigitizer_Ph2_h -#define EcalSimAlgos_EcalTDigitizer_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalTDigitizer_Ph2_h +#define SimCalorimetry_EcalSimAlgos_EcalTDigitizer_Ph2_h /** Turns hits into digis. Assumes that there's an ElectroncsSim class with the diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc index e1754158c55a4..07cdbd0655fff 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc @@ -48,7 +48,7 @@ void EcalCoder_Ph2::setFullScaleEnergy(double EBscale) { m_maxEneEB = ecalPh2::maxEneEB; //I don 't know where is setFullScaleEnergy first call } -void EcalCoder_Ph2::setPedestals(const EcalLiteDTUPedestals* pedestals) { m_peds = pedestals; } +void EcalCoder_Ph2::setPedestals(const EcalLiteDTUPedestalsMap* pedestals) { m_peds = pedestals; } void EcalCoder_Ph2::setGainRatios(const EcalCATIAGainRatios* gainRatios) { m_gainRatios = gainRatios; } @@ -59,12 +59,16 @@ double EcalCoder_Ph2::fullScaleEnergy(const DetId& detId) const { return m_maxEneEB; } -void EcalCoder_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, const EcalSamples& clf, EcalDataFrame_Ph2& df) const { +void EcalCoder_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, + const EcalSamples& clf, + EcalDataFrame_Ph2& df) const { df.setSize(clf.size()); encode(clf, df, engine); } -void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame_Ph2& df, CLHEP::HepRandomEngine* engine) const { +void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, + EcalDataFrame_Ph2& df, + CLHEP::HepRandomEngine* engine) const { assert(nullptr != m_peds); const unsigned int csize(ecalSamples.size()); @@ -109,7 +113,7 @@ void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame_Ph2& df const Noisifier* noisy[NGAINS] = {m_ebCorrNoise[0], m_ebCorrNoise[1]}; if (m_addNoise) { -//#warning noise generation to be checked + //#warning noise generation to be checked noisy[0]->noisify(noiseframe[0], engine); // high gain //if( nullptr == noisy[1] ) noisy[0]->noisify( noiseframe[1] , // engine, @@ -164,7 +168,7 @@ void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, EcalDataFrame_Ph2& df adctrace[i][igain] = adc; //if (ecalSamples[i] > 0.) { - // std::cout<<" igain = "< ReturnType; - typedef std::unique_ptr ReturnType; - + typedef std::unique_ptr ReturnType; + ReturnType produce(const EcalLiteDTUPedestalsRcd& iRecord); private: @@ -40,13 +36,13 @@ EcalLiteDTUPedestalsESProducer::EcalLiteDTUPedestalsESProducer(const edm::Parame EcalLiteDTUPedestalsESProducer::ReturnType EcalLiteDTUPedestalsESProducer::produce( const EcalLiteDTUPedestalsRcd& iRecord) { //std::cout<<"********Starting Production"<(); + auto prod = std::make_unique(); //std::cout<<"**********Set EB Values "< dbPed; + edm::ESHandle dbPed; eventSetup.get().get(dbPed); - const EcalLiteDTUPedestals* pedestals(dbPed.product()); + const EcalLiteDTUPedestalsMap* pedestals(dbPed.product()); m_Coder->setPedestals(pedestals); if (nullptr != m_APDCoder) diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc index f29a015de4991..63a7fc9666309 100644 --- a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc @@ -64,7 +64,6 @@ using namespace edm; // PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) { - //now do what ever initialization is needed usesResource("TFileService"); @@ -136,19 +135,9 @@ PhaseIAnalyzer::~PhaseIAnalyzer() { // ------------ method called for each event ------------ void PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { - //LogInfo("PhaseI") << "new event "; - Handle pDigiEB; iEvent.getByToken(digiTokenEB_, pDigiEB); - // edm::ESHandle ical; - // iSetup.get().get(ical); - // const EcalIntercalibConstantsMC* ical_map = ical.product(); - // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); - // cout << "intercalib: " << (*itical) << endl; - - //const int MAXSAMPLES = ecalPh1::sampleSize; - std::vector ebAnalogSignal; std::vector ebADCCounts; std::vector ebADCGains_temp; @@ -159,19 +148,6 @@ void PhaseIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iS ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); ebADCGains.reserve(EBDataFrame::MAXSAMPLES); - //Take Pedestals: - // edm::ESHandle peds; - // iSetup.get().get(peds); - // const EcalLiteDTUPedestals* myped = peds.product(); - // int cnt=0; - // for( EcalLiteDTUPedestals::const_iterator it = myped->barrelItems().begin(); it != myped->barrelItems().end(); ++it) - // { - // std::cout << "EcalPedestal: " << " BARREL " << cnt << " " - // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); - // std::cout << std::endl; - // ++cnt; - // } - int nDigis = 0; int LowGain(0), MidGain(0), HighGain(0); int maxADCValue = 0; @@ -274,14 +250,5 @@ void PhaseIAnalyzer::beginJob() {} // ------------ method called once each job just after ending the event loop ------------ void PhaseIAnalyzer::endJob() {} -// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ -void PhaseIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - //The following says we do not know what parameters are allowed so do no validation - // Please change this to state exactly what you do use, even if it is no parameters - //edm::ParameterSetDescription desc; - //desc.setUnknown(); - //descriptions.addDefault(desc); -} - //define this as a plug-in DEFINE_FWK_MODULE(PhaseIAnalyzer); diff --git a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h index 69354cbe3d9a5..d4800aed12fac 100644 --- a/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h +++ b/SimCalorimetry/PhaseIAnalyzer/plugins/PhaseIAnalyzer.h @@ -1,3 +1,6 @@ +#ifndef SimCalorimetry_PhaseIAnalyzer_PhaseIAnalyzer_h +#define SimCalorimetry_PhaseIAnalyzer_PhaseIAnalyzer_h + #include "FWCore/Framework/interface/Frameworkfwd.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" @@ -11,8 +14,6 @@ #include #include "CondFormats/EcalObjects/interface/EcalConstants.h" -//using namespace std; - // // class declaration // @@ -22,8 +23,6 @@ class PhaseIAnalyzer : public edm::one::EDAnalyzer { explicit PhaseIAnalyzer(const edm::ParameterSet&); ~PhaseIAnalyzer(); - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - private: virtual void beginJob(); void analyze(const edm::Event&, const edm::EventSetup&) override; @@ -68,3 +67,5 @@ class PhaseIAnalyzer : public edm::one::EDAnalyzer { TH1D* meEBnADCafterSwitch_; }; + +#endif diff --git a/SimCalorimetry/PhaseIAnalyzer/python/Digitizer1.root b/SimCalorimetry/PhaseIAnalyzer/python/Digitizer1.root deleted file mode 100644 index 8b7745bde7fa1015778089c7fc8680ca1fb9428d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 57745 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 HbP59iSXgH> diff --git a/SimCalorimetry/PhaseIAnalyzer/python/ConfFile_cfg.py b/SimCalorimetry/PhaseIAnalyzer/test/run_PhaseIAnalyzer.py similarity index 100% rename from SimCalorimetry/PhaseIAnalyzer/python/ConfFile_cfg.py rename to SimCalorimetry/PhaseIAnalyzer/test/run_PhaseIAnalyzer.py diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc index 0354678520720..1d90aafd49ecd 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -63,7 +63,6 @@ using namespace edm; // constructors and destructor // - PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) { //now do what ever initialization is needed usesResource("TFileService"); @@ -134,19 +133,9 @@ PhaseIIAnalyzer::~PhaseIIAnalyzer() { // ------------ method called for each event ------------ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { - //LogInfo("PhaseII") << "new event "; - Handle pDigiEB; iEvent.getByToken(digiTokenEB_, pDigiEB); - // edm::ESHandle ical; - // iSetup.get().get(ical); - // const EcalIntercalibConstantsMC* ical_map = ical.product(); - // EcalIntercalibConstantsMC::const_iterator itical = ical_map->getMap().find(2); - // cout << "intercalib: " << (*itical) << endl; - - //const int MAXSAMPLES = ecalPh2::sampleSize; - std::vector ebAnalogSignal; std::vector ebADCCounts; std::vector ebADCGains_temp; @@ -157,19 +146,6 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i ebADCGains_temp.reserve(EBDataFrame::MAXSAMPLES); ebADCGains.reserve(EBDataFrame::MAXSAMPLES); - //Take Pedestals: - // edm::ESHandle peds; - // iSetup.get().get(peds); - // const EcalLiteDTUPedestals* myped = peds.product(); - // int cnt=0; - // for( EcalLiteDTUPedestals::const_iterator it = myped->barrelItems().begin(); it != myped->barrelItems().end(); ++it) - // { - // std::cout << "EcalPedestal: " << " BARREL " << cnt << " " - // << " mean: " <<(*it).mean(0) << " rms: " << (*it).rms(0); - // std::cout << std::endl; - // ++cnt; - // } - int nDigis = 0; int maxADCValue = 0; int LowGain = 0; @@ -185,11 +161,8 @@ void PhaseIIAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& i EBDetId ebid = digi.id(); nDigis++; - edm::ESHandle peds; + edm::ESHandle peds; iSetup.get().get(peds); - //const EcalLiteDTUPedestalsMap* DTUpeds_map = peds.product(); - // EcalLiteDTUPedestalsMap::const_iterator itped = DTUpeds_map->getMap().find(ebid); - // cout << "mean dei piedistalli: " << (*itped).mean(0) << " rms: " << (*itped).rms(0) << endl; double Emax = 0.; int Pmax = 0; @@ -266,14 +239,5 @@ void PhaseIIAnalyzer::beginJob() {} // ------------ method called once each job just after ending the event loop ------------ void PhaseIIAnalyzer::endJob() {} -// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ -void PhaseIIAnalyzer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - //The following says we do not know what parameters are allowed so do no validation - // Please change this to state exactly what you do use, even if it is no parameters - //edm::ParameterSetDescription desc; - //desc.setUnknown(); - //descriptions.addDefault(desc); -} - //define this as a plug-in DEFINE_FWK_MODULE(PhaseIIAnalyzer); diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h index 51ddd46d0c31e..7513b462c5c19 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.h @@ -1,3 +1,6 @@ +#ifndef SimCalorimetry_PhaseIIAnalyzer_PhaseIIAnalyzer_h +#define SimCalorimetry_PhaseIIAnalyzer_PhaseIIAnalyzer_h + #include "FWCore/Framework/interface/Frameworkfwd.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" @@ -11,7 +14,6 @@ #include #include "CondFormats/EcalObjects/interface/EcalConstants.h" -//using namespace std; // // class declaration // @@ -21,8 +23,6 @@ class PhaseIIAnalyzer : public edm::one::EDAnalyzer { explicit PhaseIIAnalyzer(const edm::ParameterSet&); ~PhaseIIAnalyzer(); - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - private: virtual void beginJob(); void analyze(const edm::Event&, const edm::EventSetup&) override; @@ -68,3 +68,5 @@ class PhaseIIAnalyzer : public edm::one::EDAnalyzer { TF1* f; }; + +#endif diff --git a/SimCalorimetry/PhaseIIAnalyzer/python/Digitizer2.root b/SimCalorimetry/PhaseIIAnalyzer/python/Digitizer2.root deleted file mode 100644 index 76328445a4d5070da92dcaac21deb5785c64b3f8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 54766 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 dhOahozb{xi(qRjSpIfj1>x_ Date: Fri, 8 May 2020 16:14:13 +0200 Subject: [PATCH 09/10] Reduce duplication of EBHitResponse and others --- .../CaloObjects/interface/CaloTSamples_Ph2.h | 34 --- .../EcalObjects/interface/EcalConstants.h | 45 +-- .../interface/EcalLiteDTUPedestals.h | 12 +- .../src/T_EventSetup_EcalLiteDTUPedestals.cc | 15 - CondFormats/EcalObjects/src/classes.h | 3 +- DataFormats/EcalDigi/interface/EBDataFrame.h | 1 + .../EcalDigi/interface/EBDataFrame_Ph2.h | 33 --- .../EcalDigi/interface/EcalDataFrame_Ph2.h | 14 - .../EcalDigi/interface/EcalDigiCollections.h | 27 ++ .../interface/EcalDigiCollections_Ph2.h | 58 ---- DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc | 34 --- DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc | 19 -- DataFormats/EcalDigi/src/classes.h | 1 - .../EcalSimAlgos/interface/EBHitResponse.h | 26 +- .../EBHitResponse.icc} | 65 +++-- .../interface/EBHitResponse_Ph2.h | 100 ------- .../interface/EcalDigitizerTraits_Ph2.h | 9 +- .../interface/EcalElectronicsSim_Ph2.h | 10 +- .../interface/EcalHitResponse_Ph2.h | 137 --------- .../{EcalCoder_Ph2.h => EcalLiteDTUCoder.h} | 15 +- .../interface/EcalTDigitizer_Ph2.h | 8 +- .../interface/EcalTDigitizer_Ph2.icc | 6 +- .../EcalSimAlgos/src/EBHitResponse_Ph2.cc | 259 ------------------ .../src/EcalElectronicsSim_Ph2.cc | 4 +- .../EcalSimAlgos/src/EcalHitResponse_Ph2.cc | 246 ----------------- .../{EcalCoder_Ph2.cc => EcalLiteDTUCoder.cc} | 36 +-- .../interface/EcalDigiProducer.h | 3 +- .../interface/EcalDigiProducer_Ph2.h | 9 +- .../plugins/EcalLiteDTUPedestalsESProducer.cc | 2 +- .../src/EcalDigiProducer_Ph2.cc | 10 +- ..._cfi_py_GEN_IDEAL_withECALDigi_newshape.py | 2 +- .../PhaseIAnalyzer/plugins/PhaseIAnalyzer.cc | 4 +- .../plugins/PhaseIIAnalyzer.cc | 6 +- 33 files changed, 177 insertions(+), 1076 deletions(-) delete mode 100644 CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h delete mode 100644 DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h delete mode 100644 DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h delete mode 100644 DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc delete mode 100644 DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc rename SimCalorimetry/EcalSimAlgos/{src/EBHitResponse.cc => interface/EBHitResponse.icc} (74%) delete mode 100644 SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h delete mode 100644 SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h rename SimCalorimetry/EcalSimAlgos/interface/{EcalCoder_Ph2.h => EcalLiteDTUCoder.h} (83%) delete mode 100644 SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc delete mode 100644 SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc rename SimCalorimetry/EcalSimAlgos/src/{EcalCoder_Ph2.cc => EcalLiteDTUCoder.cc} (83%) diff --git a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h b/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h deleted file mode 100644 index d4ec760074eef..0000000000000 --- a/CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h +++ /dev/null @@ -1,34 +0,0 @@ -#ifndef CalibFormats_CaloObjects_CaloTSamples_Ph2_h -#define CalibFormats_CaloObjects_CaloTSamples_Ph2_h - -#include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" - -/** \class CaloTSamples_Ph2 - -Class which represents the charge/voltage measurements of an event/channel -with the ADC decoding performed. - -*/ - -template -class CaloTSamples_Ph2 : public CaloTSamplesBase { -public: - enum { kCapacity = Tsize }; - - CaloTSamples_Ph2(); - CaloTSamples_Ph2(const CaloTSamples_Ph2 &cs); - CaloTSamples_Ph2(const DetId &id, uint32_t size = 0, uint32_t pre = 0); - ~CaloTSamples_Ph2() override; - - CaloTSamples_Ph2 &operator=(const CaloTSamples_Ph2 &cs); - - uint32_t capacity() const override; - -private: - Ttype *data(uint32_t i) override; - const Ttype *cdata(uint32_t i) const override; - - Ttype m_data[Tsize]; -}; - -#endif diff --git a/CondFormats/EcalObjects/interface/EcalConstants.h b/CondFormats/EcalObjects/interface/EcalConstants.h index cc302e4642090..b5bc70d985e25 100644 --- a/CondFormats/EcalObjects/interface/EcalConstants.h +++ b/CondFormats/EcalObjects/interface/EcalConstants.h @@ -2,27 +2,30 @@ #ifndef CondFormats_EcalObject_EcalConstants_h #define CondFormats_EcalObject_EcalConstants_h -namespace ecalPh2 { - constexpr double Samp_Period = 6.25; - constexpr int NGAINS = 2; - constexpr float gains[2] = {10., 1.}; - constexpr int gainId1 = 1; - constexpr int gainId10 = 0; - constexpr int sampleSize = 16; - constexpr int NBITS = 12; // number of available bits - constexpr int MAXADC = (1 << NBITS) - 1; // 2^12 -1, adc max range - constexpr int kEBChannels = 61200; - constexpr double maxEneEB = 2000.; - constexpr int kNOffsets = 2000; - constexpr unsigned int kAdcMask = 0xFFF; - constexpr unsigned int kGainIdMask = 0x3; +class ecalPh2 { +public: + static constexpr double Samp_Period = 6.25; + static constexpr unsigned int NGAINS = 2; + static constexpr float gains[2] = {10., 1.}; + static constexpr unsigned int gainId1 = 1; + static constexpr unsigned int gainId10 = 0; + static constexpr unsigned int sampleSize = 16; + static constexpr unsigned int NBITS = 12; // number of available bits + static constexpr unsigned int MAXADC = (1 << NBITS) - 1; // 2^12 -1, adc max range + static constexpr unsigned int kEBChannels = 61200; + static constexpr double maxEneEB = 2000.; + static constexpr unsigned int kNOffsets = 2000; + static constexpr unsigned int kAdcMask = 0xFFF; + static constexpr unsigned int kGainIdMask = 0x3; -} // namespace ecalPh2 +}; // namespace ecalPh2 -namespace ecalPh1 { - constexpr double Samp_Period = 25.; - constexpr int NGAINS = 4; - constexpr float gains[4] = {0., 12., 6., 1.}; - constexpr int sampleSize = 10; -} // namespace ecalPh1 +class ecalPh1 { +public: + static constexpr double Samp_Period = 25.; + static constexpr unsigned int NGAINS = 4; + static constexpr float gains[4] = {0., 12., 6., 1.}; + static constexpr unsigned int sampleSize = 10; + static constexpr unsigned int kNOffsets = 2000; +}; // namespace ecalPh1 #endif diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h index d21b099012460..599ce3eaa29c8 100644 --- a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -10,25 +10,25 @@ class EcalLiteDTUPedestals { float meanarray[2] = {13., 8.}; float rmsarray[2] = {2.8, 1.2}; - int setMean(int i, float value) { - if (i >= ecalPh2::NGAINS || i < 0) + int setMean(unsigned int i, float value) { + if (i >= ecalPh2::NGAINS) return -1; else meanarray[i] = value; return 1; } - int setRMS(int i, float value) { - if (i >= ecalPh2::NGAINS || i < 0) + int setRMS(unsigned int i, float value) { + if (i >= ecalPh2::NGAINS) return -1; else rmsarray[i] = value; return 1; } - float mean(int i) const { return meanarray[i]; } + float mean(unsigned int i) const { return meanarray[i]; } - float rms(int i) const { return rmsarray[i]; } + float rms(unsigned int i) const { return rmsarray[i]; } COND_SERIALIZABLE; }; diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc index b240af9ef895b..75bcfb76d8b96 100644 --- a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc @@ -1,18 +1,3 @@ -// -*- C++ -*- -// -// Package: EDMProto -// Class : T_Context_Pedestals -// -// Implementation: -// create all the 'infrastructure' needed to get into the Context -// -// Author: Dario Soldi -// Created: Mon March 14 16:42:52 EDT 2019 -// - -// system include files - -// user include files #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" #include "FWCore/Utilities/interface/typelookup.h" diff --git a/CondFormats/EcalObjects/src/classes.h b/CondFormats/EcalObjects/src/classes.h index 38dde54d2e79b..2c40d0319ff6b 100644 --- a/CondFormats/EcalObjects/src/classes.h +++ b/CondFormats/EcalObjects/src/classes.h @@ -1,5 +1,4 @@ -#include - +#include #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" #include "CondFormats/EcalObjects/interface/EcalCondTowerObjectContainer.h" #include "CondFormats/EcalObjects/interface/EcalPedestals.h" diff --git a/DataFormats/EcalDigi/interface/EBDataFrame.h b/DataFormats/EcalDigi/interface/EBDataFrame.h index cb6ded7d25a82..89c6e97da5419 100644 --- a/DataFormats/EcalDigi/interface/EBDataFrame.h +++ b/DataFormats/EcalDigi/interface/EBDataFrame.h @@ -3,6 +3,7 @@ #include "DataFormats/EcalDetId/interface/EBDetId.h" #include "DataFormats/EcalDigi/interface/EcalDataFrame.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" #include /** \class EBDataFrame diff --git a/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h deleted file mode 100644 index 0c099771e2ad7..0000000000000 --- a/DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h +++ /dev/null @@ -1,33 +0,0 @@ -#ifndef DataFormats_EcalDigi_EBDataFrame_Ph2_h -#define DataFormats_EcalDigi_EBDataFrame_Ph2_h - -#include "DataFormats/EcalDetId/interface/EBDetId.h" -#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" -#include - -/** \class EBDataFrame_Ph2 - -*/ -class EBDataFrame_Ph2 : public EcalDataFrame_Ph2 { -public: - typedef EBDetId key_type; ///< For the sorted collection - typedef EcalDataFrame_Ph2 Base; - - EBDataFrame_Ph2() {} - // EBDataFrame(DetId i) : Base(i) {} - EBDataFrame_Ph2(edm::DataFrame const& base) : Base(base) {} - EBDataFrame_Ph2(EcalDataFrame_Ph2 const& base) : Base(base) {} - - /** estimator for a signal being a spike - * based on ratios between 4th, 5th and 6th sample - */ - float spikeEstimator() const; - - ~EBDataFrame_Ph2() override {} - - key_type id() const { return Base::id(); } -}; - -std::ostream& operator<<(std::ostream&, const EBDataFrame_Ph2&); - -#endif diff --git a/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h index 05fd1382a6c30..0420f97c28a1e 100644 --- a/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h +++ b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h @@ -11,7 +11,6 @@ class EcalDataFrame_Ph2 { public: EcalDataFrame_Ph2() {} - // EcalDataFrame_Ph2(DetId i) : m_data(i) {} EcalDataFrame_Ph2(edm::DataFrame const& iframe) : m_data(iframe) {} virtual ~EcalDataFrame_Ph2() {} @@ -23,23 +22,10 @@ class EcalDataFrame_Ph2 { EcalLiteDTUSample operator[](int i) const { return m_data[i]; } EcalLiteDTUSample sample(int i) const { return m_data[i]; } - // get the leading sample (the first non saturated sample) - // starting from the fourth sample - // (it relies on the fact that the unpaker will discard fixed gain0 DataFrame) - // .. sample numbering: [0, 9] - // .. return -1 in case of no saturation - int lastUnsaturatedSample() const; - // just the boolean method - bool isSaturated() const { return (lastUnsaturatedSample() != -1); } - // FIXME (shall we throw??) void setSize(int) {} - // void setPresamples(int ps); void setSample(int i, EcalLiteDTUSample sam) { m_data[i] = sam; } - //bool hasSwitchToGain6() const; - //bool hasSwitchToGain1() const; - int MAXSAMPLES = ecalPh2::sampleSize; edm::DataFrame const& frame() const { return m_data; } diff --git a/DataFormats/EcalDigi/interface/EcalDigiCollections.h b/DataFormats/EcalDigi/interface/EcalDigiCollections.h index 3a117d2cc908a..49b7042bde065 100644 --- a/DataFormats/EcalDigi/interface/EcalDigiCollections.h +++ b/DataFormats/EcalDigi/interface/EcalDigiCollections.h @@ -18,6 +18,29 @@ #include "DataFormats/DetId/interface/DetId.h" #include "DataFormats/EcalDetId/interface/EcalSubdetector.h" #include "DataFormats/Common/interface/DataFrameContainer.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" + +class EcalDigiCollectionPh2 : public edm::DataFrameContainer { +public: + typedef edm::DataFrameContainer::size_type size_type; + static const size_type MAXSAMPLES = ecalPh2::sampleSize; + explicit EcalDigiCollectionPh2(size_type istride = MAXSAMPLES, int isubdet = 0) + : edm::DataFrameContainer(istride, isubdet) {} + void swap(DataFrameContainer& other) { this->DataFrameContainer::swap(other); } +}; + +class EBDigiCollectionPh2 : public EcalDigiCollectionPh2 { +public: + typedef edm::DataFrameContainer::size_type size_type; + typedef EBDataFrame Digi; + typedef Digi::key_type DetId; + + EBDigiCollectionPh2(size_type istride = MAXSAMPLES) : EcalDigiCollectionPh2(istride, EcalBarrel) {} + void swap(EBDigiCollectionPh2& other) { this->EcalDigiCollectionPh2::swap(other); } + void push_back(const Digi& digi) { DataFrameContainer::push_back(digi.id(), digi.frame().begin()); } + void push_back(id_type iid) { DataFrameContainer::push_back(iid); } + void push_back(id_type iid, data_type const* idata) { DataFrameContainer::push_back(iid, idata); } +}; class EcalDigiCollection : public edm::DataFrameContainer { public: @@ -89,6 +112,10 @@ inline void swap(EEDigiCollection& lhs, EEDigiCollection& rhs) { lhs.swap(rhs); inline void swap(ESDigiCollection& lhs, ESDigiCollection& rhs) { lhs.swap(rhs); } +inline void swap(EcalDigiCollectionPh2& lhs, EcalDigiCollectionPh2& rhs) { lhs.swap(rhs); } + +inline void swap(EBDigiCollectionPh2& lhs, EBDigiCollectionPh2& rhs) { lhs.swap(rhs); } + typedef edm::SortedCollection EcalTimeDigiCollection; typedef edm::SortedCollection EcalTrigPrimDigiCollection; typedef edm::SortedCollection EcalEBTrigPrimDigiCollection; diff --git a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h b/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h deleted file mode 100644 index fa7daa5bfe18b..0000000000000 --- a/DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef DataFormats_EcalDigi_EcalDigiCollections_Ph2_h -#define DataFormats_EcalDigi_EcalDigiCollections_Ph2_h - -#include "DataFormats/EcalDigi/interface/EBDataFrame.h" -#include "DataFormats/EcalDigi/interface/EcalTimeDigi.h" -//#include "DataFormats/EcalDigi/interface/EcalTriggerPrimitiveDigi.h" -//#include "DataFormats/EcalDigi/interface/EcalEBTriggerPrimitiveDigi.h" -//#include "DataFormats/EcalDigi/interface/EcalTrigPrimCompactColl.h" -#include "DataFormats/EcalDigi/interface/EcalPseudoStripInputDigi.h" -#include "DataFormats/EcalDigi/interface/EBSrFlag.h" -#include "DataFormats/EcalDigi/interface/EcalPnDiodeDigi.h" -#include "DataFormats/EcalDigi/interface/EcalMatacqDigi.h" -#include "DataFormats/Common/interface/SortedCollection.h" - -#include "DataFormats/DetId/interface/DetId.h" -#include "DataFormats/EcalDetId/interface/EcalSubdetector.h" -#include "DataFormats/Common/interface/DataFrameContainer.h" -#include "CondFormats/EcalObjects/interface/EcalConstants.h" - -class EcalDigiCollectionPh2 : public edm::DataFrameContainer { -public: - typedef edm::DataFrameContainer::size_type size_type; - static const size_type MAXSAMPLES = ecalPh2::sampleSize; - explicit EcalDigiCollectionPh2(size_type istride = MAXSAMPLES, int isubdet = 0) - : edm::DataFrameContainer(istride, isubdet) {} - void swap(DataFrameContainer& other) { this->DataFrameContainer::swap(other); } -}; - -// make edm (and ecal client) happy -class EBDigiCollectionPh2 : public EcalDigiCollectionPh2 { -public: - typedef edm::DataFrameContainer::size_type size_type; - typedef EBDataFrame Digi; - typedef Digi::key_type DetId; - - EBDigiCollectionPh2(size_type istride = MAXSAMPLES) : EcalDigiCollectionPh2(istride, EcalBarrel) {} - void swap(EBDigiCollectionPh2& other) { this->EcalDigiCollectionPh2::swap(other); } - void push_back(const Digi& digi) { DataFrameContainer::push_back(digi.id(), digi.frame().begin()); } - void push_back(id_type iid) { DataFrameContainer::push_back(iid); } - void push_back(id_type iid, data_type const* idata) { DataFrameContainer::push_back(iid, idata); } -}; - -// Free swap functions -inline void swap(EcalDigiCollectionPh2& lhs, EcalDigiCollectionPh2& rhs) { lhs.swap(rhs); } - -inline void swap(EBDigiCollectionPh2& lhs, EBDigiCollectionPh2& rhs) { lhs.swap(rhs); } - -typedef edm::SortedCollection EcalTimeDigiCollection; -//DA ELIMINARE??? -//typedef edm::SortedCollection EcalTrigPrimDigiCollection; -//typedef edm::SortedCollection EcalEBTrigPrimDigiCollection; - -typedef edm::SortedCollection EcalPSInputDigiCollection; -typedef edm::SortedCollection EBSrFlagCollection; -typedef edm::SortedCollection EcalPnDiodeDigiCollection; -typedef edm::SortedCollection EcalMatacqDigiCollection; - -#endif diff --git a/DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc b/DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc deleted file mode 100644 index 03b8304e90ca1..0000000000000 --- a/DataFormats/EcalDigi/src/EBDataFrame_Ph2.cc +++ /dev/null @@ -1,34 +0,0 @@ -#include "DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include -//#warning[DataFormats/EcalDigi/src/EBDataFrame.cc] spike estimator contains a suspicious 10 -float EBDataFrame_Ph2::spikeEstimator() const { - if (size() != 10) { - edm::LogError("InvalidNumberOfSamples") - << "This method only applies to signals sampled 10 times (" << size() << " samples found)"; - return 10.; - } - // skip faulty channels - if (sample(5).adc() == 0) - return 10.; - size_t imax = 0; - int maxAdc = 0; - for (int i = 0; i < size(); ++i) { - if (sample(i).adc() > maxAdc) { - imax = i; - maxAdc = sample(i).adc(); - } - } - // skip early signals - if (imax < 4) - return 10.; - float ped = 1. / 3. * (sample(0).adc() + sample(1).adc() + sample(2).adc()); - return 0.18 * (sample(4).adc() - ped) / (sample(5).adc() - ped) + (sample(6).adc() - ped) / (sample(5).adc() - ped); -} - -std::ostream& operator<<(std::ostream& s, const EBDataFrame_Ph2& digi) { - s << digi.id() << " " << digi.size() << " samples " << std::endl; - for (int i = 0; i < digi.size(); i++) - s << " " << digi[i] << std::endl; - return s; -} diff --git a/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc b/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc deleted file mode 100644 index 04a43056e4cb0..0000000000000 --- a/DataFormats/EcalDigi/src/EcalDataFrame_Ph2.cc +++ /dev/null @@ -1,19 +0,0 @@ -#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" -#include "CondFormats/EcalObjects/interface/EcalConstants.h" -#include - -int EcalDataFrame_Ph2::lastUnsaturatedSample() const { - int cnt = 0; - for (size_t i = 3; i < m_data.size(); ++i) { - cnt = 0; - for (size_t j = i; j < (i + 5) && j < m_data.size(); ++j) { - //if (((EcalLiteDTUSample)m_data[j]).gainId() == EcalMgpaBitwiseGain0) - if (((EcalLiteDTUSample)m_data[j]).gainId() == ecalPh2::gainId1) { - ++cnt; - } - } - if (cnt == 5) - return i - 1; // the last unsaturated sample - } - return -1; // no saturation found -} diff --git a/DataFormats/EcalDigi/src/classes.h b/DataFormats/EcalDigi/src/classes.h index c3a2052e5da4f..631c4d7be1395 100644 --- a/DataFormats/EcalDigi/src/classes.h +++ b/DataFormats/EcalDigi/src/classes.h @@ -1,3 +1,2 @@ #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" -#include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" #include "DataFormats/Common/interface/Wrapper.h" diff --git a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h index 80699d98f24a7..b5e74ded8b14e 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h @@ -4,6 +4,7 @@ #include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse.h" #include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" +#include "CondFormats/EcalObjects/interface/EcalConstants.h" class APDSimParameters; @@ -11,21 +12,24 @@ namespace CLHEP { class HepRandomEngine; } -class EBHitResponse : public EcalHitResponse { +template +class EBHitResponseImpl : public EcalHitResponse { public: - typedef CaloTSamples EBSamples; + typedef CaloTSamples EBSamples; typedef std::vector VecD; - enum { kNOffsets = 2000 }; + static constexpr size_t kNOffsets = constset::kNOffsets; - EBHitResponse(const CaloVSimParameterMap* parameterMap, - const CaloVShape* shape, - bool apdOnly, - const APDSimParameters* apdPars, - const CaloVShape* apdShape); + static constexpr double kSamplePeriod = constset::Samp_Period; - ~EBHitResponse() override; + EBHitResponseImpl(const CaloVSimParameterMap* parameterMap, + const CaloVShape* shape, + bool apdOnly, + const APDSimParameters* apdPars = nullptr, + const CaloVShape* apdShape = nullptr); + + ~EBHitResponseImpl() override; void initialize(CLHEP::HepRandomEngine*); @@ -95,4 +99,8 @@ class EBHitResponse : public EcalHitResponse { bool m_isInitialized; }; + +typedef EBHitResponseImpl EBHitResponse; +typedef EBHitResponseImpl EBHitResponse_Ph2; +#include "EBHitResponse.icc" #endif diff --git a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse.cc b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.icc similarity index 74% rename from SimCalorimetry/EcalSimAlgos/src/EBHitResponse.cc rename to SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.icc index c500007a729eb..25e7286f81e81 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse.cc +++ b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.icc @@ -12,11 +12,11 @@ #include "FWCore/Utilities/interface/isFinite.h" #include "FWCore/Utilities/interface/Exception.h" -EBHitResponse::EBHitResponse(const CaloVSimParameterMap* parameterMap, +template EBHitResponseImpl::EBHitResponseImpl(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape, bool apdOnly, - const APDSimParameters* apdPars = nullptr, - const CaloVShape* apdShape = nullptr) + const APDSimParameters* apdPars, + const CaloVShape* apdShape) : EcalHitResponse(parameterMap, shape), @@ -51,26 +51,29 @@ EBHitResponse::EBHitResponse(const CaloVSimParameterMap* parameterMap, } } -EBHitResponse::~EBHitResponse() {} +template EBHitResponseImpl::~EBHitResponseImpl() {} -void EBHitResponse::initialize(CLHEP::HepRandomEngine* engine) { +template void EBHitResponseImpl::initialize(CLHEP::HepRandomEngine* engine) { m_isInitialized = true; for (unsigned int i(0); i != kNOffsets; ++i) { m_timeOffVec[i] += CLHEP::RandGaussQ::shoot(engine, 0, apdParameters()->timeOffWidth()); } } -const APDSimParameters* EBHitResponse::apdParameters() const { +template +const APDSimParameters* EBHitResponseImpl::apdParameters() const { assert(nullptr != m_apdPars); return m_apdPars; } -const CaloVShape* EBHitResponse::apdShape() const { +template +const CaloVShape* EBHitResponseImpl::apdShape() const { assert(nullptr != m_apdShape); return m_apdShape; } -void EBHitResponse::putAPDSignal(const DetId& detId, double npe, double time) { +template +void EBHitResponseImpl::putAPDSignal(const DetId& detId, double npe, double time) { const CaloSimParameters& parameters(*params(detId)); const double energyFac(1. / parameters.simHitToPhotoelectrons(detId)); @@ -88,7 +91,7 @@ void EBHitResponse::putAPDSignal(const DetId& detId, double npe, double time) { } const double tzero(apdShape()->timeToRise() - jitter - offsets()[EBDetId(detId).denseIndex() % kNOffsets] - - BUNCHSPACE * (parameters.binOfMaximum() - phaseShift())); + kSamplePeriod * (parameters.binOfMaximum() - phaseShift())); double binTime(tzero); @@ -96,11 +99,12 @@ void EBHitResponse::putAPDSignal(const DetId& detId, double npe, double time) { for (unsigned int bin(0); bin != result.size(); ++bin) { result[bin] += (*apdShape())(binTime)*signal; - binTime += BUNCHSPACE; + binTime += kSamplePeriod; } } -double EBHitResponse::apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) const { +template +double EBHitResponseImpl::apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) const { int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); assert(1 == iddepth || 2 == iddepth); @@ -126,9 +130,11 @@ double EBHitResponse::apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEn return npe; } -void EBHitResponse::setIntercal(const EcalIntercalibConstantsMC* ical) { m_intercal = ical; } +template +void EBHitResponseImpl::setIntercal(const EcalIntercalibConstantsMC* ical) { m_intercal = ical; } -void EBHitResponse::findIntercalibConstant(const DetId& detId, double& icalconst) const { +template +void EBHitResponseImpl::findIntercalibConstant(const DetId& detId, double& icalconst) const { EcalIntercalibConstantMC thisconst(1.); if (nullptr == m_intercal) { @@ -148,7 +154,8 @@ void EBHitResponse::findIntercalibConstant(const DetId& detId, double& icalconst icalconst = thisconst; } -void EBHitResponse::initializeHits() { +template +void EBHitResponseImpl::initializeHits() { if (!index().empty()) blankOutUsedSamples(); @@ -160,7 +167,8 @@ void EBHitResponse::initializeHits() { } } -void EBHitResponse::finalizeHits() { +template +void EBHitResponseImpl::finalizeHits() { const unsigned int bSize(EBDetId::kSizeForDenseIndexing); if (apdParameters()->addToBarrel() || m_apdOnly) { for (unsigned int i(0); i != bSize; ++i) { @@ -175,7 +183,8 @@ void EBHitResponse::finalizeHits() { } } -void EBHitResponse::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { +template +void EBHitResponseImpl::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { if (!edm::isNotFinite(hit.time()) && (nullptr == hitFilter() || hitFilter()->accepts(hit))) { int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); if (0 == iddepth) // for now take only nonAPD hits @@ -194,7 +203,8 @@ void EBHitResponse::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { } } -void EBHitResponse::run(MixCollection& hits, CLHEP::HepRandomEngine* engine) { +template +void EBHitResponseImpl::run(MixCollection& hits, CLHEP::HepRandomEngine* engine) { if (!index().empty()) blankOutUsedSamples(); @@ -240,16 +250,23 @@ void EBHitResponse::run(MixCollection& hits, CLHEP::HepRandomEngine* e } } -unsigned int EBHitResponse::samplesSize() const { return m_vSam.size(); } +template +unsigned int EBHitResponseImpl::samplesSize() const { return m_vSam.size(); } -unsigned int EBHitResponse::samplesSizeAll() const { return m_vSam.size(); } +template +unsigned int EBHitResponseImpl::samplesSizeAll() const { return m_vSam.size(); } -const EcalHitResponse::EcalSamples* EBHitResponse::operator[](unsigned int i) const { return &m_vSam[i]; } +template +const EcalHitResponse::EcalSamples* EBHitResponseImpl::operator[](unsigned int i) const { return &m_vSam[i]; } -EcalHitResponse::EcalSamples* EBHitResponse::operator[](unsigned int i) { return &m_vSam[i]; } +template +EcalHitResponse::EcalSamples* EBHitResponseImpl::operator[](unsigned int i) { return &m_vSam[i]; } -EcalHitResponse::EcalSamples* EBHitResponse::vSam(unsigned int i) { return &m_vSam[i]; } +template +EcalHitResponse::EcalSamples* EBHitResponseImpl::vSam(unsigned int i) { return &m_vSam[i]; } -EcalHitResponse::EcalSamples* EBHitResponse::vSamAll(unsigned int i) { return &m_vSam[i]; } +template +EcalHitResponse::EcalSamples* EBHitResponseImpl::vSamAll(unsigned int i) { return &m_vSam[i]; } -const EcalHitResponse::EcalSamples* EBHitResponse::vSamAll(unsigned int i) const { return &m_vSam[i]; } +template +const EcalHitResponse::EcalSamples* EBHitResponseImpl::vSamAll(unsigned int i) const { return &m_vSam[i]; } diff --git a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h deleted file mode 100644 index 8a87c5bedc705..0000000000000 --- a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h +++ /dev/null @@ -1,100 +0,0 @@ -#ifndef SimCalorimetry_EcalSimAlgos_EBHitResponse_Ph2_h -#define SimCalorimetry_EcalSimAlgos_EBHitResponse_Ph2_h - -#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" -#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" -#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" - -#include "CondFormats/EcalObjects/interface/EcalConstants.h" - -class APDSimParameters; - -namespace CLHEP { - class HepRandomEngine; -} - -class EBHitResponse_Ph2 : public EcalHitResponse_Ph2 { -public: - typedef CaloTSamples EBSamples; - - typedef std::vector VecD; - - enum { kNOffsets = ecalPh2::kNOffsets }; - - EBHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, - const CaloVShape* shape, - bool apdOnly, - const APDSimParameters* apdPars, - const CaloVShape* apdShape); - - ~EBHitResponse_Ph2() override; - - void initialize(CLHEP::HepRandomEngine*); - - virtual bool keepBlank() const { return false; } - - void setIntercal(const EcalIntercalibConstantsMC* ical); - - void add(const PCaloHit& hit, CLHEP::HepRandomEngine*) override; - - void initializeHits() override; - - void finalizeHits() override; - - void run(MixCollection& hits, CLHEP::HepRandomEngine*) override; - - unsigned int samplesSize() const override; - - EcalSamples* operator[](unsigned int i) override; - - const EcalSamples* operator[](unsigned int i) const override; - -protected: - unsigned int samplesSizeAll() const override; - - EcalSamples* vSamAll(unsigned int i) override; - - const EcalSamples* vSamAll(unsigned int i) const override; - - EcalSamples* vSam(unsigned int i) override; - - void putAPDSignal(const DetId& detId, double npe, double time); - -private: - const VecD& offsets() const { return m_timeOffVec; } - - const double nonlFunc(double enr) const { - return (pelo > enr ? pext : (pehi > enr ? nonlFunc1(enr) : pfac * atan(log10(enr - pehi + 0.00001)) + poff)); - } - - const double nonlFunc1(double energy) const { - const double enr(log10(energy)); - const double enr2(enr * enr); - const double enr3(enr2 * enr); - return (pcub * enr3 + pqua * enr2 + plin * enr + pcon); - } - - const APDSimParameters* apdParameters() const; - const CaloVShape* apdShape() const; - - double apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEngine*) const; - - void findIntercalibConstant(const DetId& detId, double& icalconst) const; - - const bool m_apdOnly; - const APDSimParameters* m_apdPars; - const CaloVShape* m_apdShape; - const EcalIntercalibConstantsMC* m_intercal; - - std::vector m_timeOffVec; - - std::vector m_apdNpeVec; - std::vector m_apdTimeVec; - - const double pcub, pqua, plin, pcon, pelo, pehi, pasy, pext, poff, pfac; - - std::vector m_vSam; - - bool m_isInitialized; -}; -#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h index 4e1b82adbd8e6..c143672cfc2d7 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h @@ -1,11 +1,10 @@ #ifndef SimCalorimetry_EcalSimAlgos_EcalDigitizerTraits_Ph2_h #define SimCalorimetry_EcalSimAlgos_EcalDigitizerTraits_Ph2_h -#include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h" -#include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" +#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" -#include "DataFormats/EcalDigi/interface/EBDataFrame_Ph2.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" class EcalHitResponse; @@ -14,11 +13,11 @@ class EBDigitizerTraits_Ph2 { /// the digis collection typedef EBDigiCollectionPh2 DigiCollection; /// the dataframes - typedef EBDataFrame_Ph2 Digi; + typedef EcalDataFrame_Ph2 Digi; /// the electronics simulation typedef EcalElectronicsSim_Ph2 ElectronicsSim_Ph2; - typedef CaloTSamples_Ph2 EcalSamples; + typedef CaloTSamples EcalSamples; static void fix(Digi& digi, edm::DataFrame df){}; }; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h index 1ab66a63853b4..1f81c0908b17e 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h @@ -1,12 +1,12 @@ #ifndef SimCalorimetry_EcalSimAlgos_EcalElectronicsSim_Ph2_h #define SimCalorimetry_EcalSimAlgos_EcalElectronicsSim_Ph2_h -#include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" +#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" #include "CondFormats/EcalObjects/interface/EcalConstants.h" #include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" -class EcalCoder_Ph2; +class EcalLiteDTUCoder; //class EcalDataFrame_Ph2; class EcalSimParameterMap_Ph2; @@ -21,9 +21,9 @@ namespace CLHEP { class EcalElectronicsSim_Ph2 { public: - typedef CaloTSamples_Ph2 EcalSamples; + typedef CaloTSamples EcalSamples; EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, - EcalCoder_Ph2* coder, + EcalLiteDTUCoder* coder, bool applyConstantTerm, double rmsConstantTerm); @@ -48,7 +48,7 @@ class EcalElectronicsSim_Ph2 { const CaloVNoiseSignalGenerator* theNoiseSignalGenerator; - EcalCoder_Ph2* m_theCoder; + EcalLiteDTUCoder* m_theCoder; const double m_thisCT; const bool m_applyConstantTerm; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h deleted file mode 100644 index d1f7fb7d32d4f..0000000000000 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h +++ /dev/null @@ -1,137 +0,0 @@ -#ifndef SimCalorimetry_EcalSimAlgos_EcalHitResponse_Ph2_h -#define SimCalorimetry_EcalSimAlgos_EcalHitResponse_Ph2_h - -#include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" -#include "CalibFormats/CaloObjects/interface/CaloSamples.h" -#include "DataFormats/DetId/interface/DetId.h" -#include "SimDataFormats/CrossingFrame/interface/MixCollection.h" -#include "SimDataFormats/CaloHit/interface/PCaloHit.h" -#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" -#include "DataFormats/Provenance/interface/Timestamp.h" - -#include -#include - -typedef unsigned long long TimeValue_t; - -class CaloVShape; -class CaloVSimParameterMap; -class CaloVHitCorrection; -class CaloVHitFilter; -class CaloSimParameters; -class CaloSubdetectorGeometry; -class CaloVPECorrection; -namespace CLHEP { - class HepRandomEngine; -} - -class EcalHitResponse_Ph2 { -public: - typedef CaloTSamplesBase EcalSamples; - - typedef std::vector VecInd; - - typedef std::unordered_map CalibCache; - - EcalHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape); - - virtual ~EcalHitResponse_Ph2(); - - void setBunchRange(int minBunch, int maxBunch); - - void setGeometry(const CaloSubdetectorGeometry* geometry); - - void setPhaseShift(double phaseShift); - - void setHitFilter(const CaloVHitFilter* filter); - - void setHitCorrection(const CaloVHitCorrection* hitCorrection); - - void setPECorrection(const CaloVPECorrection* peCorrection); - - void setEventTime(const edm::TimeValue_t& iTime); - - void setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection); - - void add(const EcalSamples* pSam); - - virtual void add(const PCaloHit& hit, CLHEP::HepRandomEngine*); - - virtual void add(const CaloSamples& hit); - - virtual void initializeHits(); - - virtual void finalizeHits(); - - virtual void run(MixCollection& hits, CLHEP::HepRandomEngine*); - - virtual unsigned int samplesSize() const = 0; - - virtual EcalSamples* operator[](unsigned int i) = 0; - - virtual const EcalSamples* operator[](unsigned int i) const = 0; - - const EcalSamples* findDetId(const DetId& detId) const; - - bool withinBunchRange(int bunchCrossing) const; - -protected: - virtual unsigned int samplesSizeAll() const = 0; - - virtual EcalSamples* vSam(unsigned int i) = 0; - - virtual EcalSamples* vSamAll(unsigned int i) = 0; - - virtual const EcalSamples* vSamAll(unsigned int i) const = 0; - - virtual void putAnalogSignal(const PCaloHit& inputHit, CLHEP::HepRandomEngine*); - - double findLaserConstant(const DetId& detId) const; - - EcalSamples* findSignal(const DetId& detId); - - double analogSignalAmplitude(const DetId& id, double energy, CLHEP::HepRandomEngine*); - - double timeOfFlight(const DetId& detId) const; - - double phaseShift() const; - - void blankOutUsedSamples(); - - const CaloSimParameters* params(const DetId& detId) const; - - const CaloVShape* shape() const; - - const CaloSubdetectorGeometry* geometry() const; - - int minBunch() const; - - int maxBunch() const; - - VecInd& index(); - - const VecInd& index() const; - - const CaloVHitFilter* hitFilter() const; - -private: - const CaloVSimParameterMap* m_parameterMap; - const CaloVShape* m_shape; - const CaloVHitCorrection* m_hitCorrection; - const CaloVPECorrection* m_PECorrection; - const CaloVHitFilter* m_hitFilter; - const CaloSubdetectorGeometry* m_geometry; - const EcalLaserDbService* m_lasercals; - - int m_minBunch; - int m_maxBunch; - double m_phaseShift; - - edm::TimeValue_t m_iTime; - bool m_useLCcorrection; - CalibCache m_laserCalibCache; - - VecInd m_index; -}; - -#endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h similarity index 83% rename from SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h rename to SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h index bc610380d60fc..b520d4ecd2d97 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h @@ -1,7 +1,7 @@ -#ifndef SimCalorimetry_EcalSimAlgos_EcalCoder_Ph2_h -#define SimCalorimetry_EcalSimAlgos_EcalCoder_Ph2_h +#ifndef SimCalorimetry_EcalSimAlgos_EcalLiteDTUCoder_h +#define SimCalorimetry_EcalSimAlgos_EcalLiteDTUCoder_h -#include "CalibFormats/CaloObjects/interface/CaloTSamples_Ph2.h" +#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" #include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" #include "CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h" @@ -21,11 +21,10 @@ namespace CLHEP { class HepRandomEngine; } -class EcalCoder_Ph2 { +class EcalLiteDTUCoder { public: - typedef CaloTSamples_Ph2 EcalSamples; + typedef CaloTSamples EcalSamples; - //typedef CaloTSamples_Ph2 EcalSamples ; typedef CorrelatedNoisifier Noisifier; @@ -36,10 +35,10 @@ class EcalCoder_Ph2 { }; /// ctor - EcalCoder_Ph2(bool addNoise, bool PreMix1, Noisifier* ebCorrNoise0, Noisifier* ebCorrNoise1 = nullptr); + EcalLiteDTUCoder(bool addNoise, bool PreMix1, Noisifier* ebCorrNoise0, Noisifier* ebCorrNoise1 = nullptr); /// dtor - virtual ~EcalCoder_Ph2(); + virtual ~EcalLiteDTUCoder(); /// can be fetched every event from the EventSetup void setPedestals(const EcalLiteDTUPedestalsMap* pedestals); diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h index 773f1e686ff99..7ea5197293179 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h @@ -12,7 +12,7 @@ #include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h" -class EcalHitResponse_Ph2; +class EcalHitResponse; class EcalBaseSignalGenerator; namespace CLHEP { @@ -27,7 +27,7 @@ class EcalTDigitizer_Ph2 { typedef typename Traits::DigiCollection DigiCollection; typedef typename Traits::EcalSamples EcalSamples; - EcalTDigitizer_Ph2(EcalHitResponse_Ph2* hitResponse, ElectronicsSim_Ph2* electronicsSim, bool addNoise); + EcalTDigitizer_Ph2(EcalHitResponse* hitResponse, ElectronicsSim_Ph2* electronicsSim, bool addNoise); virtual ~EcalTDigitizer_Ph2(); @@ -46,12 +46,12 @@ class EcalTDigitizer_Ph2 { protected: bool addNoise() const; - const EcalHitResponse_Ph2* hitResponse() const; + const EcalHitResponse* hitResponse() const; const ElectronicsSim_Ph2* elecSim() const; private: - EcalHitResponse_Ph2* m_hitResponse; + EcalHitResponse* m_hitResponse; ElectronicsSim_Ph2* m_electronicsSim; bool m_addNoise; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc index 60342b5b2cf46..ba871b0d59393 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.icc @@ -2,12 +2,12 @@ #define EcalSimAlgos_EcalTDigitizer_Ph2_icc #include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h" -#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h" #include "CalibFormats/CaloObjects/interface/CaloSamples.h" template -EcalTDigitizer_Ph2::EcalTDigitizer_Ph2(EcalHitResponse_Ph2* hitResponse, +EcalTDigitizer_Ph2::EcalTDigitizer_Ph2(EcalHitResponse* hitResponse, ElectronicsSim_Ph2* electronicsSim, bool addNoise) : m_hitResponse(hitResponse), @@ -84,7 +84,7 @@ bool EcalTDigitizer_Ph2::addNoise() const { } template -const EcalHitResponse_Ph2* EcalTDigitizer_Ph2::hitResponse() const { +const EcalHitResponse* EcalTDigitizer_Ph2::hitResponse() const { return m_hitResponse; } diff --git a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc deleted file mode 100644 index 16134a77cb191..0000000000000 --- a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse_Ph2.cc +++ /dev/null @@ -1,259 +0,0 @@ -#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse_Ph2.h" -#include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitFilter.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVShape.h" -#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" -#include "CLHEP/Random/RandPoissonQ.h" -#include "CLHEP/Random/RandGaussQ.h" -#include "DataFormats/EcalDetId/interface/EBDetId.h" -#include "SimDataFormats/CaloHit/interface/PCaloHit.h" -#include "FWCore/Utilities/interface/isFinite.h" -#include "FWCore/Utilities/interface/Exception.h" - -#include "CondFormats/EcalObjects/interface/EcalConstants.h" - -//using namespace ecalPh2; - -EBHitResponse_Ph2::EBHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, - const CaloVShape* shape, - bool apdOnly, - const APDSimParameters* apdPars = nullptr, - const CaloVShape* apdShape = nullptr) - : - - EcalHitResponse_Ph2(parameterMap, shape), - - m_apdOnly(apdOnly), - m_apdPars(apdPars), - m_apdShape(apdShape), - m_timeOffVec(kNOffsets, apdParameters()->timeOffset()), - pcub(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[0]), - pqua(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[1]), - plin(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[2]), - pcon(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[3]), - pelo(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[4]), - pehi(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[5]), - pasy(nullptr == apdPars ? 0 : apdParameters()->nonlParms()[6]), - pext(nullptr == apdPars ? 0 : nonlFunc1(pelo)), - poff(nullptr == apdPars ? 0 : nonlFunc1(pehi)), - pfac(nullptr == apdPars ? 0 : (pasy - poff) * 2. / M_PI), - m_isInitialized(false) { - const EBDetId detId(EBDetId::detIdFromDenseIndex(0)); - const CaloSimParameters& parameters(parameterMap->simParameters(detId)); - - const unsigned int rSize(parameters.readoutFrameSize()); - const unsigned int nPre(parameters.binOfMaximum() - 1); - - const unsigned int size(EBDetId::kSizeForDenseIndexing); - - m_vSam.reserve(size); - - for (unsigned int i(0); i != size; ++i) { - m_vSam.emplace_back(CaloGenericDetId(detId.det(), detId.subdetId(), i), rSize, nPre); - } -} - -EBHitResponse_Ph2::~EBHitResponse_Ph2() {} - -void EBHitResponse_Ph2::initialize(CLHEP::HepRandomEngine* engine) { - m_isInitialized = true; - for (unsigned int i(0); i != kNOffsets; ++i) { - m_timeOffVec[i] += CLHEP::RandGaussQ::shoot(engine, 0, apdParameters()->timeOffWidth()); - } -} - -const APDSimParameters* EBHitResponse_Ph2::apdParameters() const { - assert(nullptr != m_apdPars); - return m_apdPars; -} - -const CaloVShape* EBHitResponse_Ph2::apdShape() const { - assert(nullptr != m_apdShape); - return m_apdShape; -} - -void EBHitResponse_Ph2::putAPDSignal(const DetId& detId, double npe, double time) { - const CaloSimParameters& parameters(*params(detId)); - - const double energyFac(1. / parameters.simHitToPhotoelectrons(detId)); - - // std::cout<<"******** Input APD Npe="<timeToRise() - jitter - offsets()[EBDetId(detId).denseIndex() % kNOffsets] - - ecalPh2::Samp_Period * (parameters.binOfMaximum() - phaseShift())); - - double binTime(tzero); - - EcalSamples& result(*findSignal(detId)); - - for (unsigned int bin(0); bin != result.size(); ++bin) { - result[bin] += (*apdShape())(binTime)*signal; - binTime += ecalPh2::Samp_Period; - } -} - -double EBHitResponse_Ph2::apdSignalAmplitude(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) const { - int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); - assert(1 == iddepth || 2 == iddepth); - - double npe(hit.energy() * (2 == iddepth ? apdParameters()->simToPELow() : apdParameters()->simToPEHigh())); - - // do we need to do Poisson statistics for the photoelectrons? - if (apdParameters()->doPEStats() && !m_apdOnly) { - CLHEP::RandPoissonQ randPoissonQ(*engine, npe); - npe = randPoissonQ.fire(); - } - assert(nullptr != m_intercal); - double fac(1); - findIntercalibConstant(hit.id(), fac); - - npe *= fac; - - // edm::LogError( "EBHitResponse_Ph2" ) << "--- # photoelectrons for " - /* std::cout << "--- # photoelectrons for " - << EBDetId( hit.id() ) - <<" is " << npe //; - <getMap()); - EcalIntercalibConstantMCMap::const_iterator icalit(icalMap.find(detId)); - if (icalit != icalMap.end()) { - thisconst = *icalit; - if (thisconst == 0.) - thisconst = 1.; - } else { - edm::LogError("EBHitResponse_Ph2") << "No intercalib const found for xtal " << detId.rawId() - << "! something wrong with EcalIntercalibConstants in your DB? "; - } - } - icalconst = thisconst; -} - -void EBHitResponse_Ph2::initializeHits() { - if (!index().empty()) - blankOutUsedSamples(); - - const unsigned int bSize(EBDetId::kSizeForDenseIndexing); - - if (m_apdNpeVec.empty()) { - m_apdNpeVec = std::vector(bSize, (double)0.0); - m_apdTimeVec = std::vector(bSize, (double)0.0); - } -} - -void EBHitResponse_Ph2::finalizeHits() { - const unsigned int bSize(EBDetId::kSizeForDenseIndexing); - if (apdParameters()->addToBarrel() || m_apdOnly) { - for (unsigned int i(0); i != bSize; ++i) { - if (0 < m_apdNpeVec[i]) { - putAPDSignal(EBDetId::detIdFromDenseIndex(i), m_apdNpeVec[i], m_apdTimeVec[i]); - - // now zero out for next time - m_apdNpeVec[i] = 0.; - m_apdTimeVec[i] = 0.; - } - } - } -} - -void EBHitResponse_Ph2::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { - if (!edm::isNotFinite(hit.time()) && (nullptr == hitFilter() || hitFilter()->accepts(hit))) { - int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); - if (0 == iddepth) // for now take only nonAPD hits - { - if (!m_apdOnly) - putAnalogSignal(hit, engine); - } else // APD hits here - { - if (apdParameters()->addToBarrel() || m_apdOnly) { - const unsigned int icell(EBDetId(hit.id()).denseIndex()); - m_apdNpeVec[icell] += apdSignalAmplitude(hit, engine); - if (0 == m_apdTimeVec[icell]) - m_apdTimeVec[icell] = hit.time(); - } - } - } -} - -void EBHitResponse_Ph2::run(MixCollection& hits, CLHEP::HepRandomEngine* engine) { - if (!index().empty()) - blankOutUsedSamples(); - - const unsigned int bSize(EBDetId::kSizeForDenseIndexing); - - if (m_apdNpeVec.empty()) { - m_apdNpeVec = std::vector(bSize, (double)0.0); - m_apdTimeVec = std::vector(bSize, (double)0.0); - } - - for (MixCollection::MixItr hitItr(hits.begin()); hitItr != hits.end(); ++hitItr) { - const PCaloHit& hit(*hitItr); - const int bunch(hitItr.bunch()); - if (minBunch() <= bunch && maxBunch() >= bunch && !edm::isNotFinite(hit.time()) && - (nullptr == hitFilter() || hitFilter()->accepts(hit))) { - int iddepth = (hit.depth() & PCaloHit::kEcalDepthIdMask); - if (0 == iddepth) // for now take only nonAPD hits - { - if (!m_apdOnly) - putAnalogSignal(hit, engine); - } else // APD hits here - { - if (apdParameters()->addToBarrel() || m_apdOnly) { - const unsigned int icell(EBDetId(hit.id()).denseIndex()); - m_apdNpeVec[icell] += apdSignalAmplitude(hit, engine); - if (0 == m_apdTimeVec[icell]) - m_apdTimeVec[icell] = hit.time(); - } - } - } - } - - if (apdParameters()->addToBarrel() || m_apdOnly) { - for (unsigned int i(0); i != bSize; ++i) { - if (0 < m_apdNpeVec[i]) { - putAPDSignal(EBDetId::detIdFromDenseIndex(i), m_apdNpeVec[i], m_apdTimeVec[i]); - - // now zero out for next time - m_apdNpeVec[i] = 0.; - m_apdTimeVec[i] = 0.; - } - } - } -} - -unsigned int EBHitResponse_Ph2::samplesSize() const { return m_vSam.size(); } - -unsigned int EBHitResponse_Ph2::samplesSizeAll() const { return m_vSam.size(); } - -const EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::operator[](unsigned int i) const { return &m_vSam[i]; } - -EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::operator[](unsigned int i) { return &m_vSam[i]; } - -EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::vSam(unsigned int i) { return &m_vSam[i]; } - -EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::vSamAll(unsigned int i) { return &m_vSam[i]; } - -const EcalHitResponse_Ph2::EcalSamples* EBHitResponse_Ph2::vSamAll(unsigned int i) const { return &m_vSam[i]; } diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc index 46105d3a9a66c..b875b76473f64 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim_Ph2.cc @@ -1,5 +1,5 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim_Ph2.h" -#include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap_Ph2.h" #include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" @@ -12,7 +12,7 @@ #include EcalElectronicsSim_Ph2::EcalElectronicsSim_Ph2(const EcalSimParameterMap_Ph2* parameterMap, - EcalCoder_Ph2* coder, + EcalLiteDTUCoder* coder, bool applyConstantTerm, double rmsConstantTerm) : m_simMap(parameterMap), m_theCoder(coder), m_thisCT(rmsConstantTerm), m_applyConstantTerm(applyConstantTerm) {} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc deleted file mode 100644 index 788e287baf667..0000000000000 --- a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse_Ph2.cc +++ /dev/null @@ -1,246 +0,0 @@ -#include "SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse_Ph2.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVSimParameterMap.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVShape.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitCorrection.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitFilter.h" -#include "SimCalorimetry/CaloSimAlgos/interface/CaloVPECorrection.h" -#include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" -#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" -#include "Geometry/CaloGeometry/interface/CaloCellGeometry.h" -#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" -#include "DataFormats/EcalDetId/interface/ESDetId.h" -#include "CLHEP/Random/RandPoissonQ.h" -#include "FWCore/Utilities/interface/isFinite.h" - -#include "CLHEP/Units/GlobalPhysicalConstants.h" -#include "CLHEP/Units/GlobalSystemOfUnits.h" -#include - -#include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h" - -#include "CondFormats/EcalObjects/interface/EcalConstants.h" - -EcalHitResponse_Ph2::EcalHitResponse_Ph2(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape) - : m_parameterMap(parameterMap), - m_shape(shape), - m_hitCorrection(nullptr), - m_PECorrection(nullptr), - m_hitFilter(nullptr), - m_geometry(nullptr), - m_lasercals(nullptr), - m_minBunch(-32), - m_maxBunch(10), - m_phaseShift(1), - m_iTime(0), - m_useLCcorrection(false) {} - -EcalHitResponse_Ph2::~EcalHitResponse_Ph2() {} - -const CaloSimParameters* EcalHitResponse_Ph2::params(const DetId& detId) const { - assert(nullptr != m_parameterMap); - return &m_parameterMap->simParameters(detId); -} - -const CaloVShape* EcalHitResponse_Ph2::shape() const { - assert(nullptr != m_shape); - return m_shape; -} - -const CaloSubdetectorGeometry* EcalHitResponse_Ph2::geometry() const { - assert(nullptr != m_geometry); - return m_geometry; -} - -void EcalHitResponse_Ph2::setBunchRange(int minBunch, int maxBunch) { - m_minBunch = minBunch; - m_maxBunch = maxBunch; -} - -void EcalHitResponse_Ph2::setGeometry(const CaloSubdetectorGeometry* geometry) { m_geometry = geometry; } - -void EcalHitResponse_Ph2::setPhaseShift(double phaseShift) { m_phaseShift = phaseShift; } - -double EcalHitResponse_Ph2::phaseShift() const { return m_phaseShift; } - -void EcalHitResponse_Ph2::setHitFilter(const CaloVHitFilter* filter) { m_hitFilter = filter; } - -void EcalHitResponse_Ph2::setHitCorrection(const CaloVHitCorrection* hitCorrection) { m_hitCorrection = hitCorrection; } - -void EcalHitResponse_Ph2::setPECorrection(const CaloVPECorrection* peCorrection) { m_PECorrection = peCorrection; } - -void EcalHitResponse_Ph2::setEventTime(const edm::TimeValue_t& iTime) { - m_iTime = iTime; - //clear the laser cache for each event time - CalibCache().swap(m_laserCalibCache); -} - -void EcalHitResponse_Ph2::setLaserConstants(const EcalLaserDbService* laser, bool& useLCcorrection) { - m_lasercals = laser; - m_useLCcorrection = useLCcorrection; -} - -void EcalHitResponse_Ph2::blankOutUsedSamples() // blank out previously used elements -{ - const unsigned int size(m_index.size()); - - for (unsigned int i(0); i != size; ++i) { - vSamAll(m_index[i])->setZero(); - } - m_index.erase(m_index.begin(), // done and make ready to start over - m_index.end()); -} - -void EcalHitResponse_Ph2::add(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { - if (!edm::isNotFinite(hit.time()) && (nullptr == m_hitFilter || m_hitFilter->accepts(hit))) { - putAnalogSignal(hit, engine); - } -} - -void EcalHitResponse_Ph2::add(const CaloSamples& hit) { - const DetId detId(hit.id()); - - EcalSamples& result(*findSignal(detId)); - - const int rsize(result.size()); - - if (rsize != hit.size()) { - throw cms::Exception("EcalDigitization") << "CaloSamples and EcalSamples have different sizes. Type Mismatach"; - } - - for (int bin(0); bin != rsize; ++bin) { - result[bin] += hit[bin]; - } - - //std::cout<< "rsize: " << rsize << " hit.size: " << hit.size() << "\n" - //<< std::endl; //Not printed. Function apparently never used -} - -bool EcalHitResponse_Ph2::withinBunchRange(int bunchCrossing) const { - return (m_minBunch <= bunchCrossing && m_maxBunch >= bunchCrossing); -} - -void EcalHitResponse_Ph2::initializeHits() { blankOutUsedSamples(); } - -void EcalHitResponse_Ph2::finalizeHits() {} - -void EcalHitResponse_Ph2::run(MixCollection& hits, CLHEP::HepRandomEngine* engine) { - blankOutUsedSamples(); - - for (MixCollection::MixItr hitItr(hits.begin()); hitItr != hits.end(); ++hitItr) { - const PCaloHit& hit(*hitItr); - const int bunch(hitItr.bunch()); - if (withinBunchRange(bunch) && !edm::isNotFinite(hit.time()) && - (nullptr == m_hitFilter || m_hitFilter->accepts(hit))) - putAnalogSignal(hit, engine); - } -} - -void EcalHitResponse_Ph2::putAnalogSignal(const PCaloHit& hit, CLHEP::HepRandomEngine* engine) { - //const EBShape* sh=dynamic_cast (shape()); - //EBShape* csh = const_cast(sh); - //std::cout << " Cast result" << csh << std::endl; - //if (csh) csh->m_shape_print("newshape.txt"); - - const DetId detId(hit.id()); - - const CaloSimParameters* parameters(params(detId)); - - const double signal( - analogSignalAmplitude(detId, hit.energy(), engine)); //Signal amplitude in number of photoelectrons (npe) - - double time = hit.time(); - - if (m_hitCorrection) { - time += m_hitCorrection->delay(hit, engine); - } - - const double jitter(time - timeOfFlight(detId)); - - const double tzero = (shape()->timeToRise() + parameters->timePhase() - jitter - - ecalPh2::Samp_Period * (parameters->binOfMaximum() - m_phaseShift)); - double binTime(tzero); - - EcalSamples& result(*findSignal(detId)); - - const unsigned int rsize(result.size()); - - EBDetId ebid(detId); - - if (hit.energy() > 1.0) { - for (unsigned int bin(0); bin != rsize; ++bin) { - result[bin] += (*shape())(binTime)*signal; - - binTime += ecalPh2::Samp_Period; - } - } -} - -double EcalHitResponse_Ph2::findLaserConstant(const DetId& detId) const { - const edm::Timestamp& evtTimeStamp = edm::Timestamp(m_iTime); - return (m_lasercals->getLaserCorrection(detId, evtTimeStamp)); -} - -EcalHitResponse_Ph2::EcalSamples* EcalHitResponse_Ph2::findSignal(const DetId& detId) { - const unsigned int di(CaloGenericDetId(detId).denseIndex()); - EcalSamples* result(vSamAll(di)); - - if (result->zero()) - m_index.push_back(di); - return result; -} - -double EcalHitResponse_Ph2::analogSignalAmplitude(const DetId& detId, double energy, CLHEP::HepRandomEngine* engine) { - const CaloSimParameters& parameters(*params(detId)); - - // OK, the "energy" in the hit could be a real energy, deposited energy, - // or pe count. This factor converts to photoelectrons - - double lasercalib = 1.; - if (m_useLCcorrection == true && detId.subdetId() != 3) { - auto cache = m_laserCalibCache.find(detId); - if (cache != m_laserCalibCache.end()) { - lasercalib = cache->second; - } else { - lasercalib = 1.0 / findLaserConstant(detId); - m_laserCalibCache.emplace(detId, lasercalib); - } - } - - double npe(energy * lasercalib * parameters.simHitToPhotoelectrons(detId)); - - // do we need to doPoisson statistics for the photoelectrons? Yes, otherwise we just get the "mean value" - if (parameters.doPhotostatistics()) { - npe = CLHEP::RandPoissonQ::shoot(engine, npe); - } - if (nullptr != m_PECorrection) - npe = m_PECorrection->correctPE(detId, npe, engine); - - return npe; -} - -double EcalHitResponse_Ph2::timeOfFlight(const DetId& detId) const { - auto cellGeometry(geometry()->getGeometry(detId)); - assert(nullptr != cellGeometry); - return cellGeometry->getPosition().mag() * cm / c_light; // Units of c_light: mm/ns -} - -void EcalHitResponse_Ph2::add(const EcalSamples* pSam) { - EcalSamples& sam(*findSignal(pSam->id())); - sam += (*pSam); -} - -int EcalHitResponse_Ph2::minBunch() const { return m_minBunch; } - -int EcalHitResponse_Ph2::maxBunch() const { return m_maxBunch; } - -EcalHitResponse_Ph2::VecInd& EcalHitResponse_Ph2::index() { return m_index; } - -const EcalHitResponse_Ph2::VecInd& EcalHitResponse_Ph2::index() const { return m_index; } - -const CaloVHitFilter* EcalHitResponse_Ph2::hitFilter() const { return m_hitFilter; } - -const EcalHitResponse_Ph2::EcalSamples* EcalHitResponse_Ph2::findDetId(const DetId& detId) const { - const unsigned int di(CaloGenericDetId(detId).denseIndex()); - return vSamAll(di); -} diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc b/SimCalorimetry/EcalSimAlgos/src/EcalLiteDTUCoder.cc similarity index 83% rename from SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc rename to SimCalorimetry/EcalSimAlgos/src/EcalLiteDTUCoder.cc index 07cdbd0655fff..3b954c4392280 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalCoder_Ph2.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalLiteDTUCoder.cc @@ -1,4 +1,4 @@ -#include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.h" #include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" @@ -23,10 +23,10 @@ //5 samples prima, il sample saturo e poi 10 samples dopo const float DTUVersion = 1.0; -EcalCoder_Ph2::EcalCoder_Ph2(bool addNoise, +EcalLiteDTUCoder::EcalLiteDTUCoder(bool addNoise, bool PreMix1, - EcalCoder_Ph2::Noisifier* ebCorrNoise0, - EcalCoder_Ph2::Noisifier* ebCorrNoise1) + EcalLiteDTUCoder::Noisifier* ebCorrNoise0, + EcalLiteDTUCoder::Noisifier* ebCorrNoise1) : m_peds(nullptr), m_gainRatios(nullptr), m_intercals(nullptr), @@ -41,32 +41,32 @@ EcalCoder_Ph2::EcalCoder_Ph2(bool addNoise, m_ebCorrNoise[1] = ebCorrNoise1; } -EcalCoder_Ph2::~EcalCoder_Ph2() {} +EcalLiteDTUCoder::~EcalLiteDTUCoder() {} -void EcalCoder_Ph2::setFullScaleEnergy(double EBscale) { +void EcalLiteDTUCoder::setFullScaleEnergy(double EBscale) { // m_maxEneEB = EBscale ; m_maxEneEB = ecalPh2::maxEneEB; //I don 't know where is setFullScaleEnergy first call } -void EcalCoder_Ph2::setPedestals(const EcalLiteDTUPedestalsMap* pedestals) { m_peds = pedestals; } +void EcalLiteDTUCoder::setPedestals(const EcalLiteDTUPedestalsMap* pedestals) { m_peds = pedestals; } -void EcalCoder_Ph2::setGainRatios(const EcalCATIAGainRatios* gainRatios) { m_gainRatios = gainRatios; } +void EcalLiteDTUCoder::setGainRatios(const EcalCATIAGainRatios* gainRatios) { m_gainRatios = gainRatios; } -void EcalCoder_Ph2::setIntercalibConstants(const EcalIntercalibConstantsMC* ical) { m_intercals = ical; } +void EcalLiteDTUCoder::setIntercalibConstants(const EcalIntercalibConstantsMC* ical) { m_intercals = ical; } -double EcalCoder_Ph2::fullScaleEnergy(const DetId& detId) const { +double EcalLiteDTUCoder::fullScaleEnergy(const DetId& detId) const { //return detId.subdetId() == EcalBarrel ? m_maxEneEB : m_maxEneEE ; return m_maxEneEB; } -void EcalCoder_Ph2::analogToDigital(CLHEP::HepRandomEngine* engine, +void EcalLiteDTUCoder::analogToDigital(CLHEP::HepRandomEngine* engine, const EcalSamples& clf, EcalDataFrame_Ph2& df) const { df.setSize(clf.size()); encode(clf, df, engine); } -void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, +void EcalLiteDTUCoder::encode(const EcalSamples& ecalSamples, EcalDataFrame_Ph2& df, CLHEP::HepRandomEngine* engine) const { assert(nullptr != m_peds); @@ -78,7 +78,7 @@ void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, //....initialisation if (ecalSamples[5] > 0.) - LogDebug("EcalCoder_Ph2") << "Input caloSample" + LogDebug("EcalLiteDTUCoder") << "Input caloSample" << "\n" << ecalSamples; @@ -194,17 +194,17 @@ void EcalCoder_Ph2::encode(const EcalSamples& ecalSamples, } } -void EcalCoder_Ph2::findPedestal(const DetId& detId, int gainId, double& ped, double& width) const { +void EcalLiteDTUCoder::findPedestal(const DetId& detId, int gainId, double& ped, double& width) const { EcalLiteDTUPedestalsMap::const_iterator itped = m_peds->getMap().find(detId); ped = (*itped).mean(gainId); width = (*itped).rms(gainId); if ((detId.subdetId() != EcalBarrel) && (detId.subdetId() != EcalEndcap)) { - edm::LogError("EcalCoder_Ph2") << "Could not find pedestal for " << detId.rawId() << " among the " + edm::LogError("EcalLiteDTUCoder") << "Could not find pedestal for " << detId.rawId() << " among the " << m_peds->getMap().size(); } - LogDebug("EcalCoder_Ph2") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" + LogDebug("EcalLiteDTUCoder") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" << "Mean = " << ped << " rms = " << width; } @@ -223,7 +223,7 @@ void EcalCoder_Ph2::findPedestal(const DetId& detId, int gainId, double& ped, do // } -void EcalCoder_Ph2::findIntercalibConstant(const DetId& detId, double& icalconst) const { +void EcalLiteDTUCoder::findIntercalibConstant(const DetId& detId, double& icalconst) const { EcalIntercalibConstantMC thisconst = 1.; // find intercalib constant for this xtal const EcalIntercalibConstantMCMap& icalMap = m_intercals->getMap(); @@ -234,7 +234,7 @@ void EcalCoder_Ph2::findIntercalibConstant(const DetId& detId, double& icalconst thisconst = 1.; } } else { - edm::LogError("EcalCoder_Ph2") << "No intercalib const found for xtal " << detId.rawId() + edm::LogError("EcalLiteDTUCoder") << "No intercalib const found for xtal " << detId.rawId() << "! something wrong with EcalIntercalibConstants in your DB? "; } icalconst = thisconst; diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h index 133852c53dfa4..91625338c772a 100644 --- a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h +++ b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h @@ -15,7 +15,7 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer.h" #include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" - +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h" #include typedef EcalTDigitizer EBDigitizer; @@ -25,7 +25,6 @@ typedef CaloTDigitizer ESOldDigitizer; class ESDigitizer; class APDSimParameters; -class EBHitResponse; class EEHitResponse; class ESHitResponse; class CaloHitResponse; diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h index 74bbb5f895385..6c483e90b4818 100644 --- a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h +++ b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h @@ -12,16 +12,15 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer_Ph2.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits_Ph2.h" #include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" - +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h" #include typedef EcalTDigitizer_Ph2 EBDigitizer_Ph2; class APDSimParameters; -class EBHitResponse_Ph2; class CaloHitResponse; class EcalSimParameterMap_Ph2; -class EcalCoder_Ph2; +class EcalLiteDTUCoder; class EcalElectronicsSim_Ph2; class EcalBaseSignalGenerator; class CaloGeometry; @@ -108,10 +107,10 @@ class EcalDigiProducer_Ph2 : public DigiAccumulatorMixMod { std::unique_ptr m_BarrelDigitizer; std::unique_ptr m_ElectronicsSim; - std::unique_ptr m_Coder; + std::unique_ptr m_Coder; std::unique_ptr m_APDElectronicsSim; - std::unique_ptr m_APDCoder; + std::unique_ptr m_APDCoder; const CaloGeometry* m_Geometry; diff --git a/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc b/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc index 1b687f163f4ba..45eb36566c5cc 100644 --- a/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc +++ b/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc @@ -40,7 +40,7 @@ EcalLiteDTUPedestalsESProducer::ReturnType EcalLiteDTUPedestalsESProducer::produ //std::cout<<"**********Set EB Values "<(ebMatrix[1])); //std::cout<<"[EcalDigiProducer_Ph2] More reset"< fs; //Histograms - for (int isample = 0; isample < ecalPh1::sampleSize; isample++) { + for (unsigned int isample = 0; isample < ecalPh1::sampleSize; isample++) { EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC", isample), 950, 100, 2000); EBGainHisto[isample] = @@ -101,7 +101,7 @@ PhaseIAnalyzer::PhaseIAnalyzer(const edm::ParameterSet& iConfig) { sprintf(histo, "EcalDigiTaskBarrelDigisMultiplicity"); meEBDigiMultiplicity_ = fs->make(histo, histo, 612, 0., 61200); - for (int i = 0; i < ecalPh2::sampleSize; i++) { + for (unsigned int i = 0; i < ecalPh1::sampleSize; i++) { sprintf(histo, "EcalDigiTaskBarrelAnalogPulse%02d", i + 1); meEBDigiADCAnalog_[i] = fs->make(histo, histo, 4000, 0., 400.); diff --git a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc index 1d90aafd49ecd..f657f154962d9 100644 --- a/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc +++ b/SimCalorimetry/PhaseIIAnalyzer/plugins/PhaseIIAnalyzer.cc @@ -27,7 +27,7 @@ #include "FWCore/ParameterSet/interface/ParameterSet.h" //My includes -#include "DataFormats/EcalDigi/interface/EcalDigiCollections_Ph2.h" +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" #include "CondFormats/EcalObjects/interface/EcalPedestals.h" #include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h" #include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" @@ -75,7 +75,7 @@ PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) { edm::Service fs; //Histograms - for (int isample = 0; isample < ecalPh2::sampleSize; isample++) { + for (unsigned int isample = 0; isample < ecalPh2::sampleSize; isample++) { EBEnergyHisto[isample] = fs->make(Form("EnergyEB_%d", isample), Form("Energy sample %d Barrel;ADC", isample), 950, 100, 2000); EBGainHisto[isample] = @@ -99,7 +99,7 @@ PhaseIIAnalyzer::PhaseIIAnalyzer(const edm::ParameterSet& iConfig) { sprintf(histo, "EcalDigiTaskBarrelDigisMultiplicity"); meEBDigiMultiplicity_ = fs->make(histo, histo, 612, 0., 61200); - for (int i = 0; i < ecalPh2::sampleSize; i++) { + for (unsigned int i = 0; i < ecalPh2::sampleSize; i++) { sprintf(histo, "EcalDigiTaskBarrelAnalogPulse%02d", i + 1); meEBDigiADCAnalog_[i] = fs->make(histo, histo, 4000, 0., 400.); From 532b816b3e46507d9283f2076165c254b5116111 Mon Sep 17 00:00:00 2001 From: Dario Date: Thu, 2 Jul 2020 17:51:12 +0200 Subject: [PATCH 10/10] Cfg Reorganisation --- .../python/SimCalorimetry_Ph2_cff.py | 11 -- .../python/ecalDigiSequence_Ph2_cff.py | 28 ----- .../python/ecalDigiSequence_cff.py | 10 +- .../python/ecalDigis_cfi.py | 77 ++++++++++++ .../EcalSimProducers/python/ecaldigi_cfi.py | 2 + .../MixingModule/python/aliases_Ph2_cfi.py | 119 ------------------ SimGeneral/MixingModule/python/aliases_cfi.py | 9 ++ .../MixingModule/python/ecalDigitizer_cfi.py | 7 ++ 8 files changed, 103 insertions(+), 160 deletions(-) delete mode 100644 SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py delete mode 100644 SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py delete mode 100644 SimGeneral/MixingModule/python/aliases_Ph2_cfi.py diff --git a/SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py b/SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py deleted file mode 100644 index ffbfa8302ca40..0000000000000 --- a/SimCalorimetry/Configuration/python/SimCalorimetry_Ph2_cff.py +++ /dev/null @@ -1,11 +0,0 @@ -import FWCore.ParameterSet.Config as cms -from SimCalorimetry.Configuration.ecalDigiSequence_Ph2_cff import * -from SimCalorimetry.Configuration.hcalDigiSequence_cff import * -from SimCalorimetry.Configuration.castorDigiSequence_cff import * - -calDigiTask = cms.Task(ecalDigiTask, hcalDigiTask, castorDigiTask) -calDigi = cms.Sequence(calDigiTask) - -# fastsim has no castor model -from Configuration.Eras.Modifier_fastSim_cff import fastSim -fastSim.toReplaceWith(calDigiTask, calDigiTask.copyAndExclude([castorDigiTask])) diff --git a/SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py b/SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py deleted file mode 100644 index 0a6f0466f9fb3..0000000000000 --- a/SimCalorimetry/Configuration/python/ecalDigiSequence_Ph2_cff.py +++ /dev/null @@ -1,28 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -# unsuppressed digis simulation - fast preshower -from SimCalorimetry.EcalSimProducers.ecaldigi_Ph2_cfi import * -# ECAL Trigger Primitives (needed by SRP) -from SimCalorimetry.EcalTrigPrimProducers.ecalTriggerPrimitiveDigis_cff import * -# Selective Readout Processor producer -from SimCalorimetry.EcalSelectiveReadoutProducers.ecalDigis_cfi import * -# Preshower Zero suppression producer -from SimCalorimetry.EcalZeroSuppressionProducers.ecalPreshowerDigis_cfi import * -# simEcalUnsuppressedDigis is now done inside mixing module -#ecalDigiTask = cms.Task(simEcalTriggerPrimitiveDigis, simEcalDigis, simEcalPreshowerDigis) -ecalDigiTask = cms.Task() -ecalDigiSequence = cms.Sequence(ecalDigiTask) -# -# -## This is extra, since the configuration skips it anyway. Belts and suspenders. -#from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 -#premix_stage1.toReplaceWith(ecalDigiTask, ecalDigiTask.copyAndExclude([simEcalPreshowerDigis])) -# -#from SimCalorimetry.EcalEBTrigPrimProducers.ecalEBTriggerPrimitiveDigis_cff import * -#_phase2_ecalDigiTask = ecalDigiTask.copy() -#_phase2_ecalDigiTask.add(simEcalEBTriggerPrimitiveDigis) -# -#from Configuration.Eras.Modifier_phase2_common_cff import phase2_common -#phase2_common.toReplaceWith(ecalDigiTask,_phase2_ecalDigiTask) -# -# diff --git a/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py b/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py index c8250bc348ae8..c6d368f3569b2 100644 --- a/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py +++ b/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py @@ -18,8 +18,14 @@ premix_stage1.toReplaceWith(ecalDigiTask, ecalDigiTask.copyAndExclude([simEcalPreshowerDigis])) from SimCalorimetry.EcalEBTrigPrimProducers.ecalEBTriggerPrimitiveDigis_cff import * -_phase2_ecalDigiTask = ecalDigiTask.copy() -_phase2_ecalDigiTask.add(simEcalEBTriggerPrimitiveDigis) + +#DARIO COMMENTED: +#_phase2_ecalDigiTask = ecalDigiTask.copy() +#_phase2_ecalDigiTask.add(simEcalEBTriggerPrimitiveDigis) + +#DARIO ADDED: +#_phase2_ecalDigiTask = cms.Task(simEcalDigis) +_phase2_ecalDigiTask = cms.Task() from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toReplaceWith(ecalDigiTask,_phase2_ecalDigiTask) diff --git a/SimCalorimetry/EcalSelectiveReadoutProducers/python/ecalDigis_cfi.py b/SimCalorimetry/EcalSelectiveReadoutProducers/python/ecalDigis_cfi.py index 094977444b01f..170a1381b8f9a 100644 --- a/SimCalorimetry/EcalSelectiveReadoutProducers/python/ecalDigis_cfi.py +++ b/SimCalorimetry/EcalSelectiveReadoutProducers/python/ecalDigis_cfi.py @@ -38,6 +38,7 @@ trigPrimCollection = cms.string(''), #switch to run w/o trigger primitive. For debug use only + trigPrimBypass = cms.bool(False), # Mode selection for "Trig bypass" mode @@ -72,6 +73,82 @@ defaultTtf = cms.int32(4) ) + +simEcalDigisPh2 = cms.EDProducer("EcalSelectiveReadoutProducer", + # Label of input EB and EE digi collections + digiProducer = cms.string('simEcalUnsuppressedDigis'), + + # Instance name of input EB digi collections + EBdigiCollection = cms.string(''), + + # Instance name of input EB digi collections + EEdigiCollection = cms.string(''), + + # Instance name of output EB SR flags collection + EBSrFlagCollection = cms.string('ebSrFlags'), + + # Instance name of output EE SR flags collection + EESrFlagCollection = cms.string('eeSrFlags'), + + # Instance name of output EB digis collection + EBSRPdigiCollection = cms.string('ebDigis'), + + # Instance name of output EE digis collection + EESRPdigiCollection = cms.string('eeDigis'), + + # Switch for reading SRP settings from condition database + configFromCondDB = cms.bool(True), + + # Switch to turn off SRP altogether using special DB payload + UseFullReadout = cms.bool(False), + + # ES label? + # NZSLabel = cms.ESInputTag(' '), + + # Label name of input ECAL trigger primitive collection + trigPrimProducer = cms.string('simEcalTriggerPrimitiveDigis'), + + # Instance name of ECAL trigger primitive collection + trigPrimCollection = cms.string(''), + + #switch to run w/o trigger primitive. For debug use only + trigPrimBypass = cms.bool(True), + + # Mode selection for "Trig bypass" mode + # 0: TT thresholds applied on sum of crystal Et's + # 1: TT thresholds applies on compressed Et from Trigger primitive + # @ee trigPrimByPass_ switch + trigPrimBypassMode = cms.int32(0), + + #for debug mode only: + trigPrimBypassLTH = cms.double(1.0), + + #for debug mode only: + trigPrimBypassHTH = cms.double(1.0), + + #for debug mode only + trigPrimBypassWithPeakFinder = cms.bool(True), + + #number of events whose TT and SR flags must be dumped (for debug purpose): + dumpFlags = cms.untracked.int32(0), + + #logical flag to write out SrFlags + writeSrFlags = cms.untracked.bool(True), + + #switch to apply selective readout decision on the digis and produce + #the "suppressed" digis + produceDigis = cms.untracked.bool(True), + + #Trigger Tower Flag to use when a flag is not found from the input + #Trigger Primitive collection. Must be one of the following values: + # 0: low interest, 1: mid interest, 3: high interest + # 4: forced low interest, 5: forced mid interest, 7: forced high interest + defaultTtf = cms.int32(4) +) + + + + # Turn off SR in Ecal for premixing stage1 from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 premix_stage1.toModify(simEcalDigis, UseFullReadout = True) diff --git a/SimCalorimetry/EcalSimProducers/python/ecaldigi_cfi.py b/SimCalorimetry/EcalSimProducers/python/ecaldigi_cfi.py index 227b080464bd5..957d935ebbacf 100644 --- a/SimCalorimetry/EcalSimProducers/python/ecaldigi_cfi.py +++ b/SimCalorimetry/EcalSimProducers/python/ecaldigi_cfi.py @@ -2,3 +2,5 @@ import FWCore.ParameterSet.Config as cms from SimGeneral.MixingModule.ecalDigitizer_cfi import * + + diff --git a/SimGeneral/MixingModule/python/aliases_Ph2_cfi.py b/SimGeneral/MixingModule/python/aliases_Ph2_cfi.py deleted file mode 100644 index ba6fda722f941..0000000000000 --- a/SimGeneral/MixingModule/python/aliases_Ph2_cfi.py +++ /dev/null @@ -1,119 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -simCastorDigis = cms.EDAlias( - mix = cms.VPSet( - cms.PSet(type = cms.string('CastorDataFramesSorted')) - ) -) - -simEcalUnsuppressedDigis = cms.EDAlias( - mix = cms.VPSet( - cms.PSet(type = cms.string('EBDigiCollectionPh2')) - ) -) - -simHcalUnsuppressedDigis = cms.EDAlias( - mix = cms.VPSet( - cms.PSet(type = cms.string('HBHEDataFramesSorted')), - cms.PSet(type = cms.string('HFDataFramesSorted')), - cms.PSet(type = cms.string('HODataFramesSorted')), - cms.PSet(type = cms.string('ZDCDataFramesSorted')), - cms.PSet(type = cms.string('QIE10DataFrameHcalDataFrameContainer')), - cms.PSet(type = cms.string('QIE11DataFrameHcalDataFrameContainer')) - ) -) - -_pixelCommon = cms.VPSet( - cms.PSet(type = cms.string('PixelDigiedmDetSetVector')), - cms.PSet(type = cms.string('PixelDigiSimLinkedmDetSetVector')) -) - -simSiPixelDigis = cms.EDAlias( - mix = _pixelCommon -) - -simSiStripDigis = cms.EDAlias( - mix = cms.VPSet( - cms.PSet(type = cms.string('SiStripDigiedmDetSetVector')), - cms.PSet(type = cms.string('SiStripRawDigiedmDetSetVector')), - cms.PSet(type = cms.string('StripDigiSimLinkedmDetSetVector')) - ) -) - -simHGCalUnsuppressedDigis = cms.EDAlias( - mix = cms.VPSet( - cms.PSet( - type = cms.string("DetIdHGCSampleHGCDataFramesSorted"), - fromProductInstance = cms.string("HGCDigisEE"), - toProductInstance = cms.string("EE"), - ), - cms.PSet( - type = cms.string("DetIdHGCSampleHGCDataFramesSorted"), - fromProductInstance = cms.string("HGCDigisHEfront"), - toProductInstance = cms.string("HEfront"), - ), - cms.PSet( - type = cms.string("DetIdHGCSampleHGCDataFramesSorted"), - fromProductInstance = cms.string("HGCDigisHEback"), - toProductInstance = cms.string("HEback"), - ), - ) -) - -simHFNoseUnsuppressedDigis = cms.EDAlias( - mix = cms.VPSet( - cms.PSet( - type = cms.string("DetIdHGCSampleHGCDataFramesSorted"), - fromProductInstance = cms.string("HFNoseDigis"), - toProductInstance = cms.string("HFNose"), - ), - ) -) - -#print "loading mix simAPV saturation" -#simAPVsaturation = cms.EDAlias( -# mix = cms.VPSet( -# cms.PSet(type = cms.string('bool')) -# ) -#) - -simAPVsaturation = cms.EDAlias( - mixData = cms.VPSet( - cms.PSet( - type = cms.string('bool'), - fromProductInstance = cms.string('siStripDigisDMSimulatedAPVDynamicGain'), - toProductInstance = cms.string('SimulatedAPVDynamicGain'), - ) - ) -) - - - -from Configuration.Eras.Modifier_run3_common_cff import run3_common -run3_common.toModify(simCastorDigis, mix = None) - -from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal -(~phase2_hgcal).toModify(simHGCalUnsuppressedDigis, mix = None) - -from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 -(premix_stage1 & phase2_hgcal).toModify(simHGCalUnsuppressedDigis, - mix = { - 0 : dict(type = "PHGCSimAccumulator"), - 1 : dict(type = "PHGCSimAccumulator"), - 2 : dict(type = "PHGCSimAccumulator"), - } -) - -from Configuration.Eras.Modifier_phase2_hfnose_cff import phase2_hfnose -(~phase2_hfnose).toModify(simHFNoseUnsuppressedDigis, mix = None) - -from Configuration.Eras.Modifier_phase1Pixel_cff import phase1Pixel -phase1Pixel.toModify(simSiPixelDigis, mix = _pixelCommon + [cms.PSet(type = cms.string('PixelFEDChanneledmNewDetSetVector'))]) - -# no castor,pixel,strip digis in fastsim - -from Configuration.Eras.Modifier_fastSim_cff import fastSim -fastSim.toModify(simCastorDigis, mix = None) -fastSim.toModify(simSiPixelDigis, mix = None) -fastSim.toModify(simSiStripDigis, mix = None) -fastSim.toModify(simAPVsaturation, mix = None) diff --git a/SimGeneral/MixingModule/python/aliases_cfi.py b/SimGeneral/MixingModule/python/aliases_cfi.py index cda36400662b6..511af5789932b 100644 --- a/SimGeneral/MixingModule/python/aliases_cfi.py +++ b/SimGeneral/MixingModule/python/aliases_cfi.py @@ -11,6 +11,15 @@ cms.PSet(type = cms.string('ESDigiCollection')) ) ) + +from Configuration.Eras.Modifier_phase2_ecal_cff import phase2_ecal + +phase2_ecal.toModify(simEcalUnsuppressedDigis, + mix = cms.VPSet( + cms.PSet(type = cms.string('EBDigiCollectionPh2')) + ) +) + simHcalUnsuppressedDigis = cms.EDAlias( mix = cms.VPSet( cms.PSet(type = cms.string('HBHEDataFramesSorted')), diff --git a/SimGeneral/MixingModule/python/ecalDigitizer_cfi.py b/SimGeneral/MixingModule/python/ecalDigitizer_cfi.py index d52c937f94c10..78e47e26a5aea 100644 --- a/SimGeneral/MixingModule/python/ecalDigitizer_cfi.py +++ b/SimGeneral/MixingModule/python/ecalDigitizer_cfi.py @@ -8,6 +8,7 @@ from SimCalorimetry.EcalSimProducers.ecalNotContainmentSim_cff import * from SimCalorimetry.EcalSimProducers.ecalCosmicsSim_cff import * + ecalDigitizer = cms.PSet( ecal_digi_parameters, apd_sim_parameters, @@ -32,3 +33,9 @@ phase2_common.toModify( ecalDigitizer, doES = cms.bool(False) ) from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toModify( ecalDigitizer, doEE = cms.bool(False) ) + + +#phase 2 digitization +from Configuration.Eras.Modifier_phase2_ecal_cff import phase2_ecal +from SimGeneral.MixingModule.ecalDigitizer_Ph2_cfi import * +phase2_ecal.toReplaceWith(ecalDigitizer,ecalDigitizer_Ph2)