diff --git a/CalibFormats/CaloObjects/src/CaloTSamples.cc b/CalibFormats/CaloObjects/src/CaloTSamples.cc index 394eae1f38f60..22612412ba5d7 100644 --- a/CalibFormats/CaloObjects/src/CaloTSamples.cc +++ b/CalibFormats/CaloObjects/src/CaloTSamples.cc @@ -1,7 +1,9 @@ -#include "CalibFormats/CaloObjects/interface/CaloTSamples.icc" #include "CalibFormats/CaloObjects/interface/CaloTSamplesBase.icc" +#include "CalibFormats/CaloObjects/interface/CaloTSamples.icc" +#include "DataFormats/EcalDigi/interface/EcalConstants.h" template class CaloTSamplesBase; -template class CaloTSamples; +template class CaloTSamples; 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..44cd477b836ef --- /dev/null +++ b/CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h @@ -0,0 +1,6 @@ +#ifndef CondFormats_DataRecord_EcalLiteDTUPedestalsRcd_h +#define CondFormats_DataRecord_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..d59977b155288 --- /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..56ba116355817 --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalCATIAGainRatios.h @@ -0,0 +1,10 @@ +#ifndef CondFormats_EcalObjects_EcalCATIAGainRatios_h +#define CondFormats_EcalObjects_EcalCATIAGainRatios_h + +#include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" + +typedef float EcalCATIAGainRatio; +typedef EcalFloatCondObjectContainer EcalCATIAGainRatioMap; +typedef EcalCATIAGainRatioMap EcalCATIAGainRatios; + +#endif diff --git a/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h new file mode 100644 index 0000000000000..fd7b95b502346 --- /dev/null +++ b/CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h @@ -0,0 +1,39 @@ +#ifndef CondFormats_EcalObject_EcalLiteDTUPedestals_h +#define CondFormats_EcalObject_EcalLiteDTUPedestals_h + +#include "CondFormats/Serialization/interface/Serializable.h" +#include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" +#include "DataFormats/EcalDigi/interface/EcalConstants.h" + +class EcalLiteDTUPedestals { +public: + int setMean(unsigned int i, float value) { + if (i >= ecalPh2::NGAINS) + return -1; + else + meanarray[i] = value; + return 1; + } + + int setRMS(unsigned int i, float value) { + if (i >= ecalPh2::NGAINS) + return -1; + else + rmsarray[i] = value; + return 1; + } + + float mean(unsigned int i) const { return meanarray[i]; } + + float rms(unsigned int i) const { return rmsarray[i]; } + +private: + float meanarray[ecalPh2::NGAINS] = {13., 8.}; + float rmsarray[ecalPh2::NGAINS] = {2.8, 1.2}; + COND_SERIALIZABLE; +}; + +typedef EcalCondObjectContainer EcalLiteDTUPedestalsMap; +typedef EcalLiteDTUPedestalsMap::const_iterator EcalLiteDTUPedestalsMapIterator; + +#endif diff --git a/CondFormats/EcalObjects/src/SerializationManual.h b/CondFormats/EcalObjects/src/SerializationManual.h index 5efd2ebcc7440..2f6158477b05d 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); diff --git a/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc new file mode 100644 index 0000000000000..75bcfb76d8b96 --- /dev/null +++ b/CondFormats/EcalObjects/src/T_EventSetup_EcalLiteDTUPedestals.cc @@ -0,0 +1,4 @@ +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(EcalLiteDTUPedestalsMap); diff --git a/CondFormats/EcalObjects/src/classes.h b/CondFormats/EcalObjects/src/classes.h index 265320eb1ddea..2c40d0319ff6b 100644 --- a/CondFormats/EcalObjects/src/classes.h +++ b/CondFormats/EcalObjects/src/classes.h @@ -1,4 +1,4 @@ - +#include #include "CondFormats/EcalObjects/interface/EcalCondObjectContainer.h" #include "CondFormats/EcalObjects/interface/EcalCondTowerObjectContainer.h" #include "CondFormats/EcalObjects/interface/EcalPedestals.h" @@ -64,7 +64,9 @@ #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 { @@ -93,6 +95,11 @@ namespace CondFormats_EcalObjects { EcalContainer ec_ebDetId_ecalPedestal; EcalCondObjectContainer pedmap; //typedef EcalPedestals + //ECAL PH2: + std::vector v_ecalDTUPedestals; + EcalContainer ec_ebDetId_ecalLiteDTUPedestals; + EcalCondObjectContainer pedmapDTU; //typedef EcalPedestals + std::vector v_ecalTPGCrystalStatusCode; EcalContainer ec_eeDetId_ecalTPGCrystalStatusCode; EcalContainer ec_ebDetId_ecalTPGCrystalStatusCode; diff --git a/CondFormats/EcalObjects/src/classes_def.xml b/CondFormats/EcalObjects/src/classes_def.xml index 67d8101caa54e..c5cc8af4e828b 100644 --- a/CondFormats/EcalObjects/src/classes_def.xml +++ b/CondFormats/EcalObjects/src/classes_def.xml @@ -82,6 +82,14 @@ + + + + + + + + diff --git a/Configuration/Eras/python/Modifier_phase2_ecal_devel_cff.py b/Configuration/Eras/python/Modifier_phase2_ecal_devel_cff.py new file mode 100644 index 0000000000000..6165152ea08f0 --- /dev/null +++ b/Configuration/Eras/python/Modifier_phase2_ecal_devel_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +phase2_ecal_devel = cms.Modifier() + diff --git a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py index 348256ce9258b..69b9d379771ec 100644 --- a/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py +++ b/Configuration/PyReleaseValidation/python/upgradeWorkflowComponents.py @@ -584,6 +584,30 @@ def condition(self, fragment, stepList, key, hasHarvest): offset = 0.6, ) +class UpgradeWorkflow_ecalDevel(UpgradeWorkflow): + def setup_(self, step, stepName, stepDict, k, properties): + # temporarily remove trigger & downstream steps + mods = {'--era': stepDict[step][k]['--era']+',phase2_ecal_devel'} + if 'Digi' in step: + mods['-s'] = 'DIGI:pdigi_valid' + stepDict[stepName][k] = merge([mods, stepDict[step][k]]) + def condition(self, fragment, stepList, key, hasHarvest): + return fragment=="TTbar_14TeV" and '2026' in key +upgradeWFs['ecalDevel'] = UpgradeWorkflow_ecalDevel( + steps = [ + 'DigiTrigger', + 'RecoGlobal', + 'HARVESTGlobal', + ], + PU = [ + 'DigiTrigger', + 'RecoGlobal', + 'HARVESTGlobal', + ], + suffix = '_ecalDevel', + offset = 0.61, +) + class UpgradeWorkflow_0T(UpgradeWorkflow): def setup_(self, step, stepName, stepDict, k, properties): myGT=stepDict[step][k]['--conditions'] diff --git a/Configuration/StandardSequences/python/DigiToRaw_cff.py b/Configuration/StandardSequences/python/DigiToRaw_cff.py index 81006f1ec2f16..efa9fba0e02cf 100644 --- a/Configuration/StandardSequences/python/DigiToRaw_cff.py +++ b/Configuration/StandardSequences/python/DigiToRaw_cff.py @@ -55,3 +55,6 @@ from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toReplaceWith(DigiToRawTask, DigiToRawTask.copyAndExclude([siPixelRawData,SiStripDigiToRaw,castorRawData,ctppsRawData])) + +from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel +phase2_ecal_devel.toReplaceWith(DigiToRawTask, DigiToRawTask.copyAndExclude([esDigiToRaw])) diff --git a/Configuration/StandardSequences/python/Eras.py b/Configuration/StandardSequences/python/Eras.py index 5f5524eb6176a..1517cfd8204ef 100644 --- a/Configuration/StandardSequences/python/Eras.py +++ b/Configuration/StandardSequences/python/Eras.py @@ -58,7 +58,7 @@ def __init__(self): 'phase2_common', 'phase2_tracker', 'phase2_muon', 'phase2_GEM', 'phase2_GE0', 'phase2_hgcal', 'phase2_timing', 'phase2_hfnose', 'phase2_hgcalV10', 'phase2_hgcalV11', 'phase2_hgcalV12', - 'phase2_timing_layer', 'phase2_hcal', 'phase2_ecal', + 'phase2_timing_layer', 'phase2_hcal', 'phase2_ecal','phase2_ecal_devel', 'phase2_trigger', 'trackingLowPU', 'trackingPhase1', 'ctpps_2016', 'ctpps_2017', 'ctpps_2018', 'ctpps_2021', 'trackingPhase2PU140','highBetaStar_2018', 'tracker_apv_vfp30_2016', 'pf_badHcalMitigation', 'run2_miniAOD_80XLegacy','run2_miniAOD_94XFall17', 'run2_nanoAOD_92X', diff --git a/DataFormats/EcalDigi/interface/EcalConstants.h b/DataFormats/EcalDigi/interface/EcalConstants.h new file mode 100644 index 0000000000000..3d478730ddad9 --- /dev/null +++ b/DataFormats/EcalDigi/interface/EcalConstants.h @@ -0,0 +1,31 @@ +//Namespaces for Phase1 and Phase2 +#ifndef CondFormats_EcalObject_EcalConstants_h +#define CondFormats_EcalObject_EcalConstants_h + +class ecalPh2 { +public: + static constexpr double Samp_Period = 6.25; + static constexpr unsigned int NGAINS = 2; + static constexpr float gains[NGAINS] = {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 + +class ecalPh1 { +public: + static constexpr double Samp_Period = 25.; + static constexpr unsigned int NGAINS = 4; + static constexpr float gains[NGAINS] = {0., 12., 6., 1.}; + static constexpr unsigned int sampleSize = 10; + static constexpr unsigned int kNOffsets = 2000; +}; // namespace ecalPh1 +#endif diff --git a/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h new file mode 100644 index 0000000000000..dd79ea5e5059f --- /dev/null +++ b/DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h @@ -0,0 +1,40 @@ +#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 "DataFormats/EcalDigi/interface/EcalConstants.h" +#include "DataFormats/EcalDetId/interface/EBDetId.h" + +/** \class EcalDataFrame_Ph2 + +*/ +class EcalDataFrame_Ph2 { +public: + EcalDataFrame_Ph2() {} + 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]; } + + typedef EBDetId key_type; /// For the sorted collection + typedef EcalDataFrame_Ph2 Base; + + void setSize(int) {} + void setSample(int i, EcalLiteDTUSample sam) { m_data[i] = sam; } + + static constexpr 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/EcalDigiCollections.h b/DataFormats/EcalDigi/interface/EcalDigiCollections.h index 3a117d2cc908a..f9a79f9830972 100644 --- a/DataFormats/EcalDigi/interface/EcalDigiCollections.h +++ b/DataFormats/EcalDigi/interface/EcalDigiCollections.h @@ -2,6 +2,7 @@ #define DIGIECAL_ECALDIGICOLLECTION_H #include "DataFormats/EcalDigi/interface/EBDataFrame.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" #include "DataFormats/EcalDigi/interface/EEDataFrame.h" #include "DataFormats/EcalDigi/interface/ESDataFrame.h" #include "DataFormats/EcalDigi/interface/EcalTimeDigi.h" @@ -18,6 +19,29 @@ #include "DataFormats/DetId/interface/DetId.h" #include "DataFormats/EcalDetId/interface/EcalSubdetector.h" #include "DataFormats/Common/interface/DataFrameContainer.h" +#include "DataFormats/EcalDigi/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 EcalDataFrame_Ph2 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 +113,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/EcalLiteDTUSample.h b/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h new file mode 100644 index 0000000000000..1e189ac0936db --- /dev/null +++ b/DataFormats/EcalDigi/interface/EcalLiteDTUSample.h @@ -0,0 +1,47 @@ +#ifndef DataFormats_EcalDigi_EcalLiteDTUSample_h +#define DataFormats_EcalDigi_EcalLiteDTUSample_h + +#include +#include +#include "DataFormats/EcalDigi/interface/EcalConstants.h" + +namespace ecalLiteDTU { + typedef uint16_t sample_type; + + /// get the ADC sample (12 bits) + constexpr int adc(sample_type sample) { return sample & ecalPh2::kAdcMask; } + /// get the gainId (2 bits) + 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 + * + * + */ +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 & ecalPh2::kAdcMask; } + /// get the gainId (2 bits) + int gainId() const { return (theSample >> ecalPh2::NBITS) & ecalPh2::kGainIdMask; } + /// 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/EcalLiteDTUSample.cc b/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc new file mode 100644 index 0000000000000..bb036f3472054 --- /dev/null +++ b/DataFormats/EcalDigi/src/EcalLiteDTUSample.cc @@ -0,0 +1,11 @@ +#include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" +#include + +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(); + return s; +} diff --git a/DataFormats/EcalDigi/src/classes_def.xml b/DataFormats/EcalDigi/src/classes_def.xml index cd9b32c91ae11..9c40edacab4db 100644 --- a/DataFormats/EcalDigi/src/classes_def.xml +++ b/DataFormats/EcalDigi/src/classes_def.xml @@ -72,6 +72,13 @@ + + + + + + + @@ -91,6 +98,8 @@ + + diff --git a/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py b/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py index c8250bc348ae8..50275b8cbbb70 100644 --- a/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py +++ b/SimCalorimetry/Configuration/python/ecalDigiSequence_cff.py @@ -24,4 +24,13 @@ from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toReplaceWith(ecalDigiTask,_phase2_ecalDigiTask) +from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel +_phase2_ecalDigiTask_devel = cms.Task() +phase2_ecal_devel.toReplaceWith(ecalDigiTask,_phase2_ecalDigiTask_devel) +#phase 2 ecal +def _modifyEcalForPh2( process ): + process.load("SimCalorimetry.EcalSimProducers.esEcalLiteDTUPedestalsProducer_cfi") + process.load("SimCalorimetry.EcalSimProducers.esCATIAGainProducer_cfi") + +modifyDigi_Phase2EcalPed = phase2_ecal_devel.makeProcessModifier(_modifyEcalForPh2) diff --git a/SimCalorimetry/EcalSelectiveReadoutProducers/python/ecalDigis_cfi.py b/SimCalorimetry/EcalSelectiveReadoutProducers/python/ecalDigis_cfi.py index 094977444b01f..4bbf23e1e63d3 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 @@ -75,3 +76,7 @@ # Turn off SR in Ecal for premixing stage1 from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 premix_stage1.toModify(simEcalDigis, UseFullReadout = True) + +_simEcalDigisPh2 = simEcalDigis.clone( + trigPrimBypass = True, +) diff --git a/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h index 80699d98f24a7..22407557bcbce 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 "DataFormats/EcalDigi/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*); @@ -58,6 +62,8 @@ class EBHitResponse : public EcalHitResponse { void putAPDSignal(const DetId& detId, double npe, double time); + void putAnalogSignal(const PCaloHit& inputHit, CLHEP::HepRandomEngine*) override; + private: const VecD& offsets() const { return m_timeOffVec; } @@ -95,4 +101,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 65% rename from SimCalorimetry/EcalSimAlgos/src/EBHitResponse.cc rename to SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.icc index c500007a729eb..a416605d67bfc 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EBHitResponse.cc +++ b/SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.icc @@ -4,6 +4,7 @@ #include "SimCalorimetry/CaloSimAlgos/interface/CaloSimParameters.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitFilter.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVShape.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloVHitCorrection.h" #include "Geometry/CaloGeometry/interface/CaloGenericDetId.h" #include "CLHEP/Random/RandPoissonQ.h" #include "CLHEP/Random/RandGaussQ.h" @@ -12,11 +13,12 @@ #include "FWCore/Utilities/interface/isFinite.h" #include "FWCore/Utilities/interface/Exception.h" -EBHitResponse::EBHitResponse(const CaloVSimParameterMap* parameterMap, - const CaloVShape* shape, - bool apdOnly, - const APDSimParameters* apdPars = nullptr, - const CaloVShape* apdShape = nullptr) +template +EBHitResponseImpl::EBHitResponseImpl(const CaloVSimParameterMap* parameterMap, + const CaloVShape* shape, + bool apdOnly, + const APDSimParameters* apdPars, + const CaloVShape* apdShape) : EcalHitResponse(parameterMap, shape), @@ -51,34 +53,35 @@ 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)); - // std::cout<<"******** Input APD Npe="< +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 +180,8 @@ void EBHitResponse::findIntercalibConstant(const DetId& detId, double& icalconst icalconst = thisconst; } -void EBHitResponse::initializeHits() { +template +void EBHitResponseImpl::initializeHits() { if (!index().empty()) blankOutUsedSamples(); @@ -160,7 +193,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 +209,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 +229,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 +276,37 @@ 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/EcalBaseSignalGenerator.h b/SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h index 19c7f6f3f6c0b..d5c307f3939f5 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalBaseSignalGenerator.h @@ -3,7 +3,6 @@ #include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap.h" -class EcalElectronicsSim; class EcalBaseSignalGenerator : public CaloVNoiseSignalGenerator { public: diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h b/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h index e2239f4da5048..dd564c07489c3 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h @@ -3,7 +3,8 @@ #include "DataFormats/Math/interface/Error.h" #include "CalibFormats/CaloObjects/interface/CaloSamples.h" +#include "DataFormats/EcalDigi/interface/EcalConstants.h" -typedef math::ErrorD::type EcalCorrMatrix; - +typedef math::ErrorD::type EcalCorrMatrix; +typedef math::ErrorD::type EcalCorrMatrix_Ph2; #endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h index f5565cc5d9cfd..31aa28a4f04e3 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h @@ -2,6 +2,8 @@ #define EcalSimAlgos_EcalDigitizerTraits_h #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h" #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSimFast.h" #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSim.h" @@ -10,6 +12,7 @@ #include "DataFormats/EcalDigi/interface/EcalDataFrame.h" #include "DataFormats/EcalDigi/interface/EBDataFrame.h" #include "DataFormats/EcalDigi/interface/EEDataFrame.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" class EcalHitResponse; @@ -20,9 +23,8 @@ class EBDigitizerTraits { /// the dataframes typedef EBDataFrame Digi; /// the electronics simulation - typedef EcalElectronicsSim ElectronicsSim; - typedef CaloTSamples EcalSamples; + typedef EcalElectronicsSim ElectronicsSim; static void fix(Digi& digi, edm::DataFrame df){}; }; @@ -34,9 +36,8 @@ class EEDigitizerTraits { /// the dataframes typedef EEDataFrame Digi; /// the electronics simulation - typedef EcalElectronicsSim ElectronicsSim; - typedef CaloTSamples EcalSamples; + typedef EcalElectronicsSim ElectronicsSim; static void fix(Digi& digi, edm::DataFrame df) {} }; @@ -75,4 +76,17 @@ class ESOldDigitizerTraits { // typedef CaloTSamples EcalSamples ; }; +class EBDigitizerTraits_Ph2 { +public: + /// the digis collection + typedef EBDigiCollectionPh2 DigiCollection; + /// the dataframes + typedef EcalDataFrame_Ph2 Digi; + /// the electronics simulation + typedef CaloTSamples EcalSamples; + typedef EcalElectronicsSim ElectronicsSim; + + static void fix(Digi& digi, edm::DataFrame df){}; +}; + #endif diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h index 73f159b2644be..c92221e031c76 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h @@ -1,11 +1,10 @@ #ifndef EcalSimAlgos_EcalElectronicsSim_h -#define EcalSimAlgos_EcalElectronicsSim_h 1 +#define EcalSimAlgos_EcalElectronicsSim_h -#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloVNoiseSignalGenerator.h" +#include "CLHEP/Random/RandGaussQ.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap.h" -class EcalCoder; -class EcalDataFrame; class EcalSimParameterMap; namespace CLHEP { @@ -17,19 +16,22 @@ namespace CLHEP { * */ +template class EcalElectronicsSim { public: - typedef CaloTSamples EcalSamples; - EcalElectronicsSim(const EcalSimParameterMap* parameterMap, - EcalCoder* coder, + CoderType* coder, bool applyConstantTerm, - double rmsConstantTerm); - - ~EcalElectronicsSim(); + double rmsConstantTerm) + : m_simMap(parameterMap), m_theCoder(coder), m_thisCT(rmsConstantTerm), m_applyConstantTerm(applyConstantTerm) {} /// from EcalSamples to EcalDataFrame - void analogToDigital(CLHEP::HepRandomEngine*, EcalSamples& clf, EcalDataFrame& df) const; + + void analogToDigital(CLHEP::HepRandomEngine* engine, SamplesType& clf, DataFrameType& df) const { + // input signal is in pe. Converted in GeV + amplify(clf, engine); + m_theCoder->analogToDigital(engine, clf, df); + } void newEvent() {} @@ -39,7 +41,14 @@ class EcalElectronicsSim { private: /// input signal is in pe. Converted in GeV - void amplify(EcalSamples& clf, CLHEP::HepRandomEngine*) const; + void amplify(SamplesType& 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; + } + } /// map of parameters @@ -47,7 +56,7 @@ class EcalElectronicsSim { const CaloVNoiseSignalGenerator* theNoiseSignalGenerator; - EcalCoder* m_theCoder; + CoderType* m_theCoder; const double m_thisCT; const bool m_applyConstantTerm; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse.h b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse.h index 925080ee2539d..c8433ba932c5b 100644 --- a/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse.h +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalHitResponse.h @@ -8,6 +8,7 @@ #include "SimDataFormats/CaloHit/interface/PCaloHit.h" #include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" #include "DataFormats/Provenance/interface/Timestamp.h" +#include "DataFormats/EcalDigi/interface/EcalConstants.h" #include #include @@ -33,12 +34,12 @@ class EcalHitResponse { typedef std::unordered_map CalibCache; - enum { BUNCHSPACE = 25 }; - EcalHitResponse(const CaloVSimParameterMap* parameterMap, const CaloVShape* shape); virtual ~EcalHitResponse(); + const float kSamplePeriod = ecalPh1::Samp_Period; + void setBunchRange(int minBunch, int maxBunch); void setGeometry(const CaloSubdetectorGeometry* geometry); @@ -116,7 +117,6 @@ class EcalHitResponse { const CaloVHitFilter* hitFilter() const; -private: const CaloVSimParameterMap* m_parameterMap; const CaloVShape* m_shape; const CaloVHitCorrection* m_hitCorrection; @@ -125,6 +125,7 @@ class EcalHitResponse { const CaloSubdetectorGeometry* m_geometry; const EcalLaserDbService* m_lasercals; +private: int m_minBunch; int m_maxBunch; double m_phaseShift; diff --git a/SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h b/SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h new file mode 100644 index 0000000000000..f8f9e5197437b --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h @@ -0,0 +1,75 @@ +#ifndef SimCalorimetry_EcalSimAlgos_EcalLiteDTUCoder_h +#define SimCalorimetry_EcalSimAlgos_EcalLiteDTUCoder_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" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h" +#include "DataFormats/EcalDigi/interface/EcalConstants.h" + +template +class CorrelatedNoisifier; +class EcalLiteDTUSample; +class EcalDataFrame_Ph2; +class DetId; +class EcalLiteDTUPed; + +#include + +namespace CLHEP { + class HepRandomEngine; +} + +class EcalLiteDTUCoder { +public: + typedef CaloTSamples EcalSamples; + + typedef CorrelatedNoisifier Noisifier; + + /// ctor + EcalLiteDTUCoder(bool addNoise, bool PreMix1, Noisifier* ebCorrNoise0, Noisifier* ebCorrNoise1 = nullptr); + + /// dtor + virtual ~EcalLiteDTUCoder(); + + /// can be fetched every event from the EventSetup + void setPedestals(const EcalLiteDTUPedestalsMap* pedestals); + + void setGainRatios(float gainRatios); + + void setFullScaleEnergy(double EBscale); + + void setIntercalibConstants(const EcalIntercalibConstantsMC* ical); + + /// 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_Ph2& 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 EcalLiteDTUPedestalsMap* m_peds; + + float 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[ecalPh2::NGAINS]; +}; + +#endif diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix.cc b/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix.cc index 20d9745aacfb3..02f7e1741a3ca 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalCorrelatedNoiseMatrix.cc @@ -2,7 +2,12 @@ #include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.icc" template class CorrelatedNoisifier; +template class CorrelatedNoisifier; template void CorrelatedNoisifier::noisify(CaloSamples&, CLHEP::HepRandomEngine*, const std::vector* rangau) const; + +template void CorrelatedNoisifier::noisify(CaloSamples&, + CLHEP::HepRandomEngine*, + const std::vector* rangau) const; diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers.cc b/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers.cc index 4c3dc081c69bc..f8ed56952ed27 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalDigitizers.cc @@ -4,3 +4,5 @@ template class EcalTDigitizer; template class EcalTDigitizer; template class EcalTDigitizer; + +template class EcalTDigitizer; diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim.cc b/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim.cc deleted file mode 100644 index 35e7ec36d9ffa..0000000000000 --- a/SimCalorimetry/EcalSimAlgos/src/EcalElectronicsSim.cc +++ /dev/null @@ -1,37 +0,0 @@ -#include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h" -#include "SimCalorimetry/EcalSimAlgos/interface/EcalCoder.h" -#include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap.h" - -#include "CLHEP/Random/RandGaussQ.h" - -#include -#include -#include -#include -#include - -EcalElectronicsSim::EcalElectronicsSim(const EcalSimParameterMap* parameterMap, - EcalCoder* coder, - bool applyConstantTerm, - double rmsConstantTerm) - : m_simMap(parameterMap), m_theCoder(coder), m_thisCT(rmsConstantTerm), m_applyConstantTerm(applyConstantTerm) {} - -EcalElectronicsSim::~EcalElectronicsSim() {} - -void EcalElectronicsSim::analogToDigital(CLHEP::HepRandomEngine* engine, - EcalElectronicsSim::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::amplify(EcalElectronicsSim::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.cc b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc index b86a7f949a051..02b9e45f8ce34 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc @@ -145,7 +145,7 @@ void EcalHitResponse::putAnalogSignal(const PCaloHit& hit, CLHEP::HepRandomEngin const double jitter(time - timeOfFlight(detId)); const double tzero = (shape()->timeToRise() + parameters->timePhase() - jitter - - BUNCHSPACE * (parameters->binOfMaximum() - m_phaseShift)); + kSamplePeriod * (parameters->binOfMaximum() - m_phaseShift)); double binTime(tzero); EcalSamples& result(*findSignal(detId)); @@ -154,7 +154,7 @@ void EcalHitResponse::putAnalogSignal(const PCaloHit& hit, CLHEP::HepRandomEngin for (unsigned int bin(0); bin != rsize; ++bin) { result[bin] += (*shape())(binTime)*signal; - binTime += BUNCHSPACE; + binTime += kSamplePeriod; } } diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalLiteDTUCoder.cc b/SimCalorimetry/EcalSimAlgos/src/EcalLiteDTUCoder.cc new file mode 100644 index 0000000000000..b595b4f5d5973 --- /dev/null +++ b/SimCalorimetry/EcalSimAlgos/src/EcalLiteDTUCoder.cc @@ -0,0 +1,181 @@ +#include "SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "SimGeneral/NoiseGenerators/interface/CorrelatedNoisifier.h" +#include "DataFormats/EcalDigi/interface/EcalLiteDTUSample.h" +#include "DataFormats/EcalDigi/interface/EcalDataFrame_Ph2.h" + +#include + +EcalLiteDTUCoder::EcalLiteDTUCoder(bool addNoise, + bool PreMix1, + EcalLiteDTUCoder::Noisifier* ebCorrNoise0, + EcalLiteDTUCoder::Noisifier* ebCorrNoise1) + : m_peds(nullptr), + m_gainRatios(0), + m_intercals(nullptr), + m_maxEneEB(ecalPh2::maxEneEB), // Maximum for CATIA: LSB gain 10: 0.048 MeV + m_addNoise(addNoise), + m_PreMix1(PreMix1), + m_ebCorrNoise{ebCorrNoise0, ebCorrNoise1} + +{} + +EcalLiteDTUCoder::~EcalLiteDTUCoder() {} + +void EcalLiteDTUCoder::setFullScaleEnergy(double EBscale) { m_maxEneEB = ecalPh2::maxEneEB; } + +void EcalLiteDTUCoder::setPedestals(const EcalLiteDTUPedestalsMap* pedestals) { m_peds = pedestals; } + +void EcalLiteDTUCoder::setGainRatios(float gainRatios) { m_gainRatios = gainRatios; } + +void EcalLiteDTUCoder::setIntercalibConstants(const EcalIntercalibConstantsMC* ical) { m_intercals = ical; } + +double EcalLiteDTUCoder::fullScaleEnergy(const DetId& detId) const { return m_maxEneEB; } + +void EcalLiteDTUCoder::analogToDigital(CLHEP::HepRandomEngine* engine, + const EcalSamples& clf, + EcalDataFrame_Ph2& df) const { + df.setSize(clf.size()); + encode(clf, df, engine); +} + +void EcalLiteDTUCoder::encode(const EcalSamples& ecalSamples, + EcalDataFrame_Ph2& df, + CLHEP::HepRandomEngine* engine) const { + const int nSamples(ecalSamples.size()); + + DetId detId = ecalSamples.id(); + double Emax = fullScaleEnergy(detId); + + //N Gains set to 2 in the .h + double pedestals[ecalPh2::NGAINS]; + double widths[ecalPh2::NGAINS]; + double LSB[ecalPh2::NGAINS]; + double trueRMS[ecalPh2::NGAINS]; + int nSaturatedSamples = 0; + double icalconst = 1.; + findIntercalibConstant(detId, icalconst); + + for (unsigned int igain(0); igain < ecalPh2::NGAINS; ++igain) { + // fill in the pedestal and width + findPedestal(detId, igain, pedestals[igain], widths[igain]); + // insert an absolute value in the trueRMS + trueRMS[igain] = std::sqrt(std::abs(widths[igain] * widths[igain] - 1. / 12.)); + + LSB[igain] = Emax / (ecalPh2::MAXADC * ecalPh2::gains[igain]); + } + + CaloSamples noiseframe[ecalPh2::NGAINS] = { + CaloSamples(detId, nSamples), + CaloSamples(detId, nSamples), + }; + + const Noisifier* noisy[ecalPh2::NGAINS] = {m_ebCorrNoise[0], m_ebCorrNoise[1]}; + + if (m_addNoise) { + for (unsigned int ig = 0; ig < ecalPh2::NGAINS; ++ig) { + noisy[ig]->noisify(noiseframe[ig], engine); + } + } + + std::vector> adctrace(nSamples); + int firstSaturatedSample[ecalPh2::NGAINS] = {0, 0}; + + for (int i(0); i != nSamples; ++i) + adctrace[i].resize(ecalPh2::NGAINS); + + for (unsigned int igain = 0; igain < ecalPh2::NGAINS; ++igain) { + for (int i(0); i != nSamples; ++i) { + adctrace[i][igain] = -1; + } + } + + // fill ADC trace in gain 0 (x10) and gain 1 (x1) + for (unsigned int igain = 0; igain < ecalPh2::NGAINS; ++igain) { + for (int i(0); i != nSamples; ++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; + + unsigned int adc = asignal - (double)isignal < 0.5 ? isignal : isignal + 1; + // gain 0 (x10) channel is saturated, readout will use gain 1 (x10), but I count the number of saturated samples + if (adc > ecalPh2::MAXADC) { + adc = ecalPh2::MAXADC; + if (nSaturatedSamples == 0) + firstSaturatedSample[igain] = i; + nSaturatedSamples++; + } + adctrace[i][igain] = adc; + } + if (nSaturatedSamples == 0) { + break; // gain 0 (x10) is not saturated, so don't bother with gain 1 + } + } // for igain + + int igain = 0; + + //Limits of gain 1: + //The Lite DTU sends 5 samples before the saturating one, and 10 after with gain 1. + //we put the maximum in bin 5, but could happen that the system saturates before. + + int previousSaturatedSamples = 5; + int nextSaturatedSamples = 10; + int startingLowerGainSample = 0; + int endingLowerGainSample = (firstSaturatedSample[0] + nextSaturatedSamples + (nSaturatedSamples)); + + if (nSaturatedSamples != 0 and (firstSaturatedSample[0] - previousSaturatedSamples) < 0) { + startingLowerGainSample = 0; + } else { + startingLowerGainSample = (firstSaturatedSample[0] - previousSaturatedSamples); + } + + //Setting values to the samples: + for (int j = 0; j < nSamples; ++j) { + if (nSaturatedSamples != 0 and j >= startingLowerGainSample and j < endingLowerGainSample) { + igain = 1; + } else { + igain = 0; + } + df.setSample(j, EcalLiteDTUSample(adctrace[j][igain], igain)); + } +} + +void EcalLiteDTUCoder::findPedestal(const DetId& detId, int gainId, double& ped, double& width) const { + EcalLiteDTUPedestalsMap::const_iterator itped = m_peds->getMap().find(detId); + if (itped != m_peds->getMap().end()) { + ped = (*itped).mean(gainId); + width = (*itped).rms(gainId); + LogDebug("EcalLiteDTUCoder") << "Pedestals for " << detId.rawId() << " gain range " << gainId << " : \n" + << "Mean = " << ped << " rms = " << width; + } else { + LogDebug("EcalLiteDTUCoder") << "Pedestals not found, put default values (ped: 12; width: 2.5) \n"; + ped = 12.; + width = 2.5; + } +} + +void EcalLiteDTUCoder::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); + } else { + LogDebug("EcalLiteDTUCoder") << "Intercalib Constant not found, put default value \n"; + thisconst = 1.; + } + + if (icalconst == 0.) + thisconst = 1.; + + icalconst = thisconst; +} diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h index 133852c53dfa4..e54f8332d7570 100644 --- a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h +++ b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer.h @@ -2,10 +2,12 @@ #define SimCalorimetry_EcalSimProducers_EcalDigiProducer_h #include "DataFormats/Math/interface/Error.h" +#include "CalibFormats/CaloObjects/interface/CaloTSamples.h" #include "FWCore/Framework/interface/ProducesCollector.h" #include "SimCalorimetry/EcalSimAlgos/interface/APDShape.h" #include "SimCalorimetry/EcalSimAlgos/interface/EBShape.h" #include "SimCalorimetry/EcalSimAlgos/interface/EEShape.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalElectronicsSim.h" #include "SimCalorimetry/EcalSimAlgos/interface/ESElectronicsSim.h" #include "SimCalorimetry/EcalSimAlgos/interface/ESShape.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalCorrelatedNoiseMatrix.h" @@ -16,6 +18,7 @@ #include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer.h" #include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h" #include typedef EcalTDigitizer EBDigitizer; @@ -25,13 +28,11 @@ typedef CaloTDigitizer ESOldDigitizer; class ESDigitizer; class APDSimParameters; -class EBHitResponse; class EEHitResponse; class ESHitResponse; class CaloHitResponse; class EcalSimParameterMap; class EcalCoder; -class EcalElectronicsSim; class ESElectronicsSim; class ESElectronicsSimFast; class EcalBaseSignalGenerator; @@ -141,10 +142,13 @@ class EcalDigiProducer : public DigiAccumulatorMixMod { std::unique_ptr m_BarrelDigitizer; std::unique_ptr m_EndcapDigitizer; - std::unique_ptr m_ElectronicsSim; + typedef CaloTSamples EcalSamples; + + typedef EcalElectronicsSim EcalElectronicsSim_Ph1; + std::unique_ptr m_ElectronicsSim; std::unique_ptr m_Coder; - std::unique_ptr m_APDElectronicsSim; + std::unique_ptr m_APDElectronicsSim; std::unique_ptr m_APDCoder; const CaloGeometry *m_Geometry; diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h new file mode 100644 index 0000000000000..40132d66b04f9 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h @@ -0,0 +1,136 @@ +#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.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloTDigitizer.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalTDigitizer.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalDigitizerTraits.h" +#include "SimGeneral/MixingModule/interface/DigiAccumulatorMixMod.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h" +#include +#include "CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h" +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbRecord.h" +#include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h" +#include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h" +#include "CondFormats/EcalObjects/interface/EcalIntercalibConstants.h" +#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h" +#include "Geometry/CaloGeometry/interface/CaloGeometry.h" +#include "Geometry/Records/interface/CaloGeometryRecord.h" + +class APDSimParameters; +class CaloHitResponse; +class EcalSimParameterMap; +class EcalLiteDTUCoder; + +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 edm + +namespace CLHEP { + class HepRandomEngine; +} + +class EcalDigiProducer_Ph2 : public DigiAccumulatorMixMod { +public: + typedef EcalTDigitizer EBDigitizer_Ph2; + typedef EBDigitizerTraits_Ph2::ElectronicsSim EcalElectronicsSim_Ph2; + + 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; + + edm::ESGetToken pedestalToken_; + edm::ESGetToken laserToken_; + edm::ESGetToken agcToken_; + edm::ESGetToken icalToken_; + edm::ESGetToken geom_token_; + 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; + + std::unique_ptr m_APDDigitizer; + std::unique_ptr m_BarrelDigitizer; + + std::unique_ptr m_ElectronicsSim; + std::unique_ptr m_Coder; + + typedef CaloTSamples EcalSamples_Ph2; + std::unique_ptr > m_APDElectronicsSim; + std::unique_ptr m_APDCoder; + + const CaloGeometry* m_Geometry; + + std::array >, 2> m_EBCorrNoise; + + CLHEP::HepRandomEngine* randomEngine_ = nullptr; +}; + +#endif diff --git a/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer.h b/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer.h index f54cc7106b631..5bd90ff357fed 100644 --- a/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer.h +++ b/SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer.h @@ -40,26 +40,21 @@ class EcalTimeDigiProducer : public DigiAccumulatorMixMod { private: typedef edm::Handle> HitsHandle; - void accumulateCaloHits(HitsHandle const &ebHandle, HitsHandle const &eeHandle, int bunchCrossing); + void accumulateCaloHits(HitsHandle const &ebHandle, int bunchCrossing); void checkGeometry(const edm::EventSetup &eventSetup); void updateGeometry(); const std::string m_EBdigiCollection; - const std::string m_EEdigiCollection; const edm::InputTag m_hitsProducerTagEB; - const edm::InputTag m_hitsProducerTagEE; const edm::EDGetTokenT> m_hitsProducerTokenEB; - const edm::EDGetTokenT> m_hitsProducerTokenEE; private: int m_timeLayerEB; - int m_timeLayerEE; const CaloGeometry *m_Geometry; EcalTimeMapDigitizer *m_BarrelDigitizer; - EcalTimeMapDigitizer *m_EndcapDigitizer; }; #endif diff --git a/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc b/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc new file mode 100644 index 0000000000000..e66d3b2b5fe9d --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/plugins/EcalCATIAGainRatiosESProducer.cc @@ -0,0 +1,49 @@ +#include +#include +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#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 = ecalPh2::kEBChannels; + +class EcalCATIAGainRatiosESProducer : public edm::ESProducer { +public: + EcalCATIAGainRatiosESProducer(const edm::ParameterSet& p); + + typedef std::unique_ptr ReturnType; + + ReturnType produce(const EcalCATIAGainRatiosRcd& iRecord); + +private: + double catiaGainRatio_; +}; + +using namespace edm; + +EcalCATIAGainRatiosESProducer::EcalCATIAGainRatiosESProducer(const edm::ParameterSet& p) { + std::string myname = p.getParameter("ComponentName"); + catiaGainRatio_ = p.getParameter("CATIAGainRatio"); + setWhatProduced(this); +} +//// +EcalCATIAGainRatiosESProducer::ReturnType EcalCATIAGainRatiosESProducer::produce(const EcalCATIAGainRatiosRcd& iRecord) { + auto prod = std::make_unique(); + for (int iChannel = 0; iChannel < kEBChannels; iChannel++) { + EBDetId myEBDetId = EBDetId::unhashIndex(iChannel); + double val = catiaGainRatio_; + prod->setValue(myEBDetId.rawId(), val); + } + + return prod; +} + +//Define this as a plug-in +DEFINE_FWK_EVENTSETUP_MODULE(EcalCATIAGainRatiosESProducer); diff --git a/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc b/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc new file mode 100644 index 0000000000000..6b17ea87a543f --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/plugins/EcalLiteDTUPedestalsESProducer.cc @@ -0,0 +1,66 @@ +#include +#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/EcalLiteDTUPedestalsRcd.h" +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "CondFormats/EcalObjects/src/classes.h" +#include "DataFormats/EcalDigi/interface/EcalConstants.h" + +// +// class declaration +// + +class EcalLiteDTUPedestalsESProducer : public edm::ESProducer { +public: + EcalLiteDTUPedestalsESProducer(const edm::ParameterSet& p); + + typedef std::unique_ptr ReturnType; + + ReturnType produce(const EcalLiteDTUPedestalsRcd& iRecord); + //Add 2 nov 2020: + edm::ESGetToken pedestalToken_; + /////////////////////////////// +private: + double meanPedestalsGain10_; + double rmsPedestalsGain10_; + double meanPedestalsGain1_; + double rmsPedestalsGain1_; +}; + +using namespace edm; + +EcalLiteDTUPedestalsESProducer::EcalLiteDTUPedestalsESProducer(const edm::ParameterSet& p) { + std::string myname = p.getParameter("ComponentName"); + meanPedestalsGain10_ = p.getParameter("MeanPedestalsGain10"); + rmsPedestalsGain10_ = p.getParameter("RMSPedestalsGain10"); + meanPedestalsGain1_ = p.getParameter("MeanPedestalsGain1"); + rmsPedestalsGain1_ = p.getParameter("RMSPedestalsGain1"); + auto cc = setWhatProduced(this); + pedestalToken_ = cc.consumes(); +} +//// +EcalLiteDTUPedestalsESProducer::ReturnType EcalLiteDTUPedestalsESProducer::produce( + const EcalLiteDTUPedestalsRcd& iRecord) { + auto prod = std::make_unique(); + + for (unsigned int iChannel = 0; iChannel < ecalPh2::kEBChannels; iChannel++) { + EBDetId myEBDetId = EBDetId::unhashIndex(iChannel); + EcalLiteDTUPedestals ped; + ped.setMean(0, meanPedestalsGain10_); + ped.setRMS(0, rmsPedestalsGain10_); + + ped.setMean(1, meanPedestalsGain1_); + ped.setRMS(1, rmsPedestalsGain1_); + + prod->insert(std::make_pair(myEBDetId, ped)); + } + + return prod; +} + +//Define this as a plug-in +DEFINE_FWK_EVENTSETUP_MODULE(EcalLiteDTUPedestalsESProducer); 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/ecalDigiParameters_Ph2_cff.py b/SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py new file mode 100644 index 0000000000000..d692fd21de0e9 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/python/ecalDigiParameters_Ph2_cff.py @@ -0,0 +1,23 @@ +import FWCore.ParameterSet.Config as cms + +ecal_digi_parameters = cms.PSet( + EBdigiCollectionPh2 = cms.string(''), + UseLCcorrection = cms.untracked.bool(True), + + #NOTE: Phase2 noise correlation matrices with fake numbers to simply test the code flow. + + EBCorrNoiseMatrixG10Ph2 = cms.vdouble ( + 1.00000, 0.71073, 0.55721, 0.46089, 0.40449, + 0.35931, 0.33924, 0.32439, 0.31581, 0.30481, 0.40449,0.40449,0.40449,0.40449,0.40449,0.40449) , + + EBCorrNoiseMatrixG01Ph2 = cms.vdouble ( + 1.00000, 0.73354, 0.64442, 0.58851, 0.55425, + 0.53082, 0.51916, 0.51097, 0.50732, 0.50409, 0.40449,0.40449,0.40449,0.40449,0.40449,0.40449) , + + EcalPreMixStage1 = cms.bool(False), + EcalPreMixStage2 = cms.bool(False) + +) + +from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 +premix_stage1.toModify(ecal_digi_parameters, EcalPreMixStage1 = True) diff --git a/SimCalorimetry/EcalSimProducers/python/ecalElectronicsSim_Ph2_cff.py b/SimCalorimetry/EcalSimProducers/python/ecalElectronicsSim_Ph2_cff.py new file mode 100644 index 0000000000000..be96c1118914f --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/python/ecalElectronicsSim_Ph2_cff.py @@ -0,0 +1,13 @@ +import FWCore.ParameterSet.Config as cms + +ecal_electronics_sim = cms.PSet( + doENoise = cms.bool(True), + ConstantTerm = cms.double(0.003), + applyConstantTerm = cms.bool(True) +) + +from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 +premix_stage1.toModify(ecal_electronics_sim, + doENoise = False, + applyConstantTerm = False, +) diff --git a/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py b/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py index e265e6ea80c6c..c88bc9b0c5bd2 100644 --- a/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py +++ b/SimCalorimetry/EcalSimProducers/python/ecalSimParameterMap_cff.py @@ -2,7 +2,6 @@ ecal_sim_parameter_map = cms.PSet( photoelectronsToAnalogEndcap = cms.double(0.000555555), - readoutFrameSize = cms.int32(10), binOfMaximum = cms.int32(6), simHitToPhotoelectronsEndcap = cms.double(1800.0), samplingFactor = cms.double(1.0), @@ -14,3 +13,13 @@ timeDependent = cms.bool(False) ) +ecal_sim_parameter_map_ph2 = cms.PSet( + binOfMaximum = cms.int32(6), + 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) +) + diff --git a/SimCalorimetry/EcalSimProducers/python/esCATIAGainProducer_cfi.py b/SimCalorimetry/EcalSimProducers/python/esCATIAGainProducer_cfi.py new file mode 100644 index 0000000000000..83f9d520655fe --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/python/esCATIAGainProducer_cfi.py @@ -0,0 +1,12 @@ +import FWCore.ParameterSet.Config as cms + +EcalCATIAGainRatiosRcd = cms.ESSource("EmptyESSource", + recordName = cms.string("EcalCATIAGainRatiosRcd"), + firstValid = cms.vuint32(1), + iovIsRunNotTime = cms.bool(True) + ) + +EcalCATIAGainRatios = cms.ESProducer("EcalCATIAGainRatiosESProducer", + ComponentName = cms.string('EcalCatiaGainProducer'), + CATIAGainRatio = cms.double(10.)) + diff --git a/SimCalorimetry/EcalSimProducers/python/esEcalLiteDTUPedestalsProducer_cfi.py b/SimCalorimetry/EcalSimProducers/python/esEcalLiteDTUPedestalsProducer_cfi.py new file mode 100644 index 0000000000000..e34957bb7baac --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/python/esEcalLiteDTUPedestalsProducer_cfi.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms + +EcalLiteDTUPedestalsRcd = cms.ESSource("EmptyESSource", + recordName = cms.string("EcalLiteDTUPedestalsRcd"), + firstValid = cms.vuint32(1), + iovIsRunNotTime = cms.bool(True) + ) + +EcalLiteDTUPedestals = cms.ESProducer( + "EcalLiteDTUPedestalsESProducer", + ComponentName = cms.string('EcalLiteDTUPedestalProducer'), + MeanPedestalsGain10 = cms.double(12), + RMSPedestalsGain10 = cms.double(2.5), + MeanPedestalsGain1 = cms.double(12.), + RMSPedestalsGain1 = cms.double(2.) +) diff --git a/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer.cc b/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer.cc index 250a823c52e02..ceb79769f5ebd 100644 --- a/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer.cc +++ b/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer.cc @@ -1,3 +1,5 @@ +#include + #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" #include "FWCore/Framework/interface/Event.h" #include "SimCalorimetry/CaloSimAlgos/interface/CaloHitResponse.h" @@ -81,7 +83,7 @@ EcalDigiProducer::EcalDigiProducer(const edm::ParameterSet ¶ms, edm::Consume m_EBs25notCont(params.getParameter("EBs25notContainment")), m_EEs25notCont(params.getParameter("EEs25notContainment")), - m_readoutFrameSize(params.getParameter("readoutFrameSize")), + m_readoutFrameSize(ecalPh1::sampleSize), m_ParameterMap(new EcalSimParameterMap(params.getParameter("simHitToPhotoelectronsBarrel"), params.getParameter("simHitToPhotoelectronsEndcap"), params.getParameter("photoelectronsToAnalogBarrel"), @@ -220,47 +222,47 @@ EcalDigiProducer::EcalDigiProducer(const edm::ParameterSet ¶ms, edm::Consume } } - m_EBCorrNoise[0].reset(new CorrelatedNoisifier(ebMatrix[0])); - m_EECorrNoise[0].reset(new CorrelatedNoisifier(eeMatrix[0])); - m_EBCorrNoise[1].reset(new CorrelatedNoisifier(ebMatrix[1])); - m_EECorrNoise[1].reset(new CorrelatedNoisifier(eeMatrix[1])); - m_EBCorrNoise[2].reset(new CorrelatedNoisifier(ebMatrix[2])); - m_EECorrNoise[2].reset(new CorrelatedNoisifier(eeMatrix[2])); - - m_Coder.reset(new EcalCoder(addNoise, - m_PreMix1, - m_EBCorrNoise[0].get(), - m_EECorrNoise[0].get(), - m_EBCorrNoise[1].get(), - m_EECorrNoise[1].get(), - m_EBCorrNoise[2].get(), - m_EECorrNoise[2].get())); - - m_ElectronicsSim.reset( - new EcalElectronicsSim(m_ParameterMap.get(), m_Coder.get(), applyConstantTerm, rmsConstantTerm)); + m_EBCorrNoise[0] = std::make_unique>(ebMatrix[0]); + m_EECorrNoise[0] = std::make_unique>(eeMatrix[0]); + m_EBCorrNoise[1] = std::make_unique>(ebMatrix[1]); + m_EECorrNoise[1] = std::make_unique>(eeMatrix[1]); + m_EBCorrNoise[2] = std::make_unique>(ebMatrix[2]); + m_EECorrNoise[2] = std::make_unique>(eeMatrix[2]); + + m_Coder = std::make_unique(addNoise, + m_PreMix1, + m_EBCorrNoise[0].get(), + m_EECorrNoise[0].get(), + m_EBCorrNoise[1].get(), + m_EECorrNoise[1].get(), + m_EBCorrNoise[2].get(), + m_EECorrNoise[2].get()); + + m_ElectronicsSim = + std::make_unique(m_ParameterMap.get(), m_Coder.get(), applyConstantTerm, rmsConstantTerm); if (m_apdSeparateDigi) { - m_APDCoder.reset(new EcalCoder(false, - m_PreMix1, - m_EBCorrNoise[0].get(), - m_EECorrNoise[0].get(), - m_EBCorrNoise[1].get(), - m_EECorrNoise[1].get(), - m_EBCorrNoise[2].get(), - m_EECorrNoise[2].get())); - - m_APDElectronicsSim.reset( - new EcalElectronicsSim(m_ParameterMap.get(), m_APDCoder.get(), applyConstantTerm, rmsConstantTerm)); - - m_APDDigitizer.reset(new EBDigitizer(m_APDResponse.get(), m_APDElectronicsSim.get(), false)); + m_APDCoder = std::make_unique(false, + m_PreMix1, + m_EBCorrNoise[0].get(), + m_EECorrNoise[0].get(), + m_EBCorrNoise[1].get(), + m_EECorrNoise[1].get(), + m_EBCorrNoise[2].get(), + m_EECorrNoise[2].get()); + + m_APDElectronicsSim = std::make_unique( + m_ParameterMap.get(), m_APDCoder.get(), applyConstantTerm, rmsConstantTerm); + + m_APDDigitizer = std::make_unique(m_APDResponse.get(), m_APDElectronicsSim.get(), false); } if (m_doEB) { - m_BarrelDigitizer.reset(new EBDigitizer(m_EBResponse.get(), m_ElectronicsSim.get(), addNoise)); + m_BarrelDigitizer = std::make_unique(m_EBResponse.get(), m_ElectronicsSim.get(), addNoise); } if (m_doEE) { - m_EndcapDigitizer.reset(new EEDigitizer(m_EEResponse.get(), m_ElectronicsSim.get(), addNoise)); + m_EndcapDigitizer = std::make_unique(m_EEResponse.get(), m_ElectronicsSim.get(), addNoise); } } diff --git a/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer_Ph2.cc b/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer_Ph2.cc new file mode 100644 index 0000000000000..f116d10f052b2 --- /dev/null +++ b/SimCalorimetry/EcalSimProducers/src/EcalDigiProducer_Ph2.cc @@ -0,0 +1,332 @@ +#include "FWCore/Framework/interface/Event.h" +#include "SimCalorimetry/EcalSimProducers/interface/EcalDigiProducer_Ph2.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EBHitResponse.h" +#include "SimCalorimetry/CaloSimAlgos/interface/CaloHitResponse.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalSimParameterMap.h" +#include "SimCalorimetry/EcalSimAlgos/interface/APDSimParameters.h" +#include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" +#include "SimCalorimetry/EcalSimAlgos/interface/EcalLiteDTUCoder.h" +#include "Geometry/CaloGeometry/interface/CaloGeometry.h" +#include "CalibFormats/CaloObjects/interface/CaloSamples.h" +#include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Framework/interface/ProducerBase.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/LuminosityBlock.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Utilities/interface/RandomNumberGenerator.h" +#include "FWCore/Utilities/interface/StreamID.h" +#include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h" +#include "SimDataFormats/CaloHit/interface/PCaloHit.h" +#include "Geometry/Records/interface/CaloGeometryRecord.h" +#include "CondFormats/EcalObjects/interface/EcalLiteDTUPedestals.h" +#include "CondFormats/DataRecord/interface/EcalLiteDTUPedestalsRcd.h" +#include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsMC.h" +#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsMCRcd.h" +#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbService.h" +#include "CalibCalorimetry/EcalLaserCorrection/interface/EcalLaserDbRecord.h" +#include "CondFormats/EcalObjects/interface/EcalADCToGeVConstant.h" +#include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h" + +//*****************************************// +//Ecal Digi Producer for PhaseII data format +//Removed EE and ES +//Moved to EBDigiCollectionPh2 +//Moved to 2 Gains instead of 3, and from 10 to 16 ecal digi samples +//This producer calls the EcalLiteDTUCoder, the PhaseII noise matrices and the EcalLiteDTUPedestals +//*****************************************// +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(ecalPh2::sampleSize), + + m_ParameterMap(std::make_unique(params.getParameter("simHitToPhotoelectronsBarrel"), + 0, // endcap parameters not needed + params.getParameter("photoelectronsToAnalogBarrel"), + 0, + params.getParameter("samplingFactor"), + params.getParameter("timePhase"), + m_readoutFrameSize, + params.getParameter("binOfMaximum"), + params.getParameter("doPhotostatistics"), + params.getParameter("syncPhase"))), + + m_apdDigiTag(params.getParameter("apdDigiTag")), + m_apdParameters(std::make_unique(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 + : std::make_unique( + m_ParameterMap.get(), &m_EBShape, true, m_apdParameters.get(), &m_APDShape)), + + m_EBResponse(std::make_unique(m_ParameterMap.get(), + &m_EBShape, + false, // barrel + m_apdParameters.get(), + &m_APDShape)), + + m_PreMix1(params.getParameter("EcalPreMixStage1")), + m_PreMix2(params.getParameter("EcalPreMixStage2")), + + 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}}) + +{ + iC.consumes>(edm::InputTag(m_hitsProducerTag, "EcalHitsEB")); + pedestalToken_ = iC.esConsumes(); + laserToken_ = iC.esConsumes(); + agcToken_ = iC.esConsumes(); + icalToken_ = iC.esConsumes(); + geom_token_ = iC.esConsumes(); + + 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) { + m_EBResponse->setPhaseShift(1. + cosmicsShift); + } + + EcalCorrMatrix_Ph2 ebMatrix[2]; + const double errorCorrelation = 1.e-7; + assert(ebCorMatG10Ph2.size() == m_readoutFrameSize); + assert(ebCorMatG01Ph2.size() == m_readoutFrameSize); + + assert(errorCorrelation > std::abs(ebCorMatG10Ph2[0] - 1.0)); + assert(errorCorrelation > std::abs(ebCorMatG01Ph2[0] - 1.0)); + + for (unsigned int row(0); row != m_readoutFrameSize; ++row) { + assert(0 == row || 1. >= ebCorMatG10Ph2[row]); + assert(0 == row || 1. >= ebCorMatG01Ph2[row]); + + for (unsigned int column(0); column <= row; ++column) { + const unsigned int index(row - column); + ebMatrix[0](row, column) = ebCorMatG10Ph2[index]; + ebMatrix[1](row, column) = ebCorMatG01Ph2[index]; + } + } + m_EBCorrNoise[0] = std::make_unique>(ebMatrix[0]); + m_EBCorrNoise[1] = std::make_unique>(ebMatrix[1]); + m_Coder = std::make_unique(addNoise, m_PreMix1, m_EBCorrNoise[0].get(), m_EBCorrNoise[1].get()); + m_ElectronicsSim = + std::make_unique(m_ParameterMap.get(), m_Coder.get(), applyConstantTerm, rmsConstantTerm); + + if (m_apdSeparateDigi) { + m_APDCoder = std::make_unique(false, m_PreMix1, m_EBCorrNoise[0].get(), m_EBCorrNoise[1].get()); + + m_APDElectronicsSim = std::make_unique( + m_ParameterMap.get(), m_APDCoder.get(), applyConstantTerm, rmsConstantTerm); + + m_APDDigitizer = std::make_unique(m_APDResponse.get(), m_APDElectronicsSim.get(), false); + } + + m_BarrelDigitizer = std::make_unique(m_EBResponse.get(), m_ElectronicsSim.get(), addNoise); +} + +EcalDigiProducer_Ph2::~EcalDigiProducer_Ph2() {} + +void EcalDigiProducer_Ph2::initializeEvent(edm::Event const& event, edm::EventSetup const& eventSetup) { + edm::Service rng; + randomEngine_ = &rng->getEngine(event.streamID()); + + checkGeometry(eventSetup); + checkCalibrations(event, eventSetup); + + m_BarrelDigitizer->initializeHits(); + if (m_apdSeparateDigi) { + m_APDDigitizer->initializeHits(); + } +} + +void EcalDigiProducer_Ph2::accumulateCaloHits(HitsHandle const& ebHandle, int bunchCrossing) { + if (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; + + 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; + + 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(nullptr); + std::unique_ptr barrelResult = std::make_unique(); + if (m_apdSeparateDigi) { + apdResult = std::make_unique(); + } + // run the algorithm + + 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 + + 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 (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 + auto pedestals = &eventSetup.getData(pedestalToken_); + + m_Coder->setPedestals(pedestals); + if (nullptr != m_APDCoder) + m_APDCoder->setPedestals(pedestals); + + // Ecal Intercalibration Constants + auto ical = &eventSetup.getData(icalToken_); + + 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 + auto laser = &eventSetup.getData(laserToken_); + + const edm::TimeValue_t eventTimeValue = event.time().value(); + + m_EBResponse->setEventTime(eventTimeValue); + m_EBResponse->setLaserConstants(laser, m_useLCcorrection); + + // ADC -> GeV Scale + auto agc = &eventSetup.getData(agcToken_); + + m_Coder->setGainRatios(ecalPh2::gains[0] / ecalPh2::gains[1]); + if (nullptr != m_APDCoder) + m_APDCoder->setGainRatios(ecalPh2::gains[0] / ecalPh2::gains[1]); + + const double EBscale((agc->getEBValue()) * ecalPh2::gains[1] * (ecalPh2::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.getHandle(geom_token_); + const CaloGeometry* pGeometry = &*hGeometry; + + if (pGeometry != m_Geometry) { + m_Geometry = pGeometry; + updateGeometry(); + } +} + +void EcalDigiProducer_Ph2::updateGeometry() { + 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) { + 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.cc b/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer.cc index c6f7f9268bf80..2be3d9f5c9f8f 100644 --- a/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer.cc +++ b/SimCalorimetry/EcalSimProducers/src/EcalTimeDigiProducer.cc @@ -1,17 +1,12 @@ #include "FWCore/Framework/interface/Event.h" #include "SimCalorimetry/EcalSimAlgos/interface/EcalTimeMapDigitizer.h" #include "SimCalorimetry/EcalSimProducers/interface/EcalTimeDigiProducer.h" - #include "CalibFormats/CaloObjects/interface/CaloSamples.h" - #include "Geometry/CaloGeometry/interface/CaloGeometry.h" #include "Geometry/CaloGeometry/interface/CaloSubdetectorGeometry.h" -#include "Geometry/EcalAlgo/interface/EcalEndcapGeometry.h" #include "Geometry/Records/interface/CaloGeometryRecord.h" - #include "DataFormats/Common/interface/Handle.h" #include "FWCore/Framework/interface/ESHandle.h" - #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/EventSetup.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" @@ -25,27 +20,20 @@ EcalTimeDigiProducer::EcalTimeDigiProducer(const edm::ParameterSet ¶ms, edm::ConsumesCollector &sumes) : DigiAccumulatorMixMod(), m_EBdigiCollection(params.getParameter("EBtimeDigiCollection")), - m_EEdigiCollection(params.getParameter("EEtimeDigiCollection")), m_hitsProducerTagEB(params.getParameter("hitsProducerEB")), - m_hitsProducerTagEE(params.getParameter("hitsProducerEE")), m_hitsProducerTokenEB(sumes.consumes>(m_hitsProducerTagEB)), - m_hitsProducerTokenEE(sumes.consumes>(m_hitsProducerTagEE)), m_timeLayerEB(params.getParameter("timeLayerBarrel")), - m_timeLayerEE(params.getParameter("timeLayerEndcap")), m_Geometry(nullptr) { producesCollector.produces(m_EBdigiCollection); - producesCollector.produces(m_EEdigiCollection); m_BarrelDigitizer = new EcalTimeMapDigitizer(EcalBarrel); - m_EndcapDigitizer = new EcalTimeMapDigitizer(EcalEndcap); #ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer]::Create EB " << m_EBdigiCollection << " and EE " << m_EEdigiCollection - << " collections and digitizers" << std::endl; + std::cout << "[EcalTimeDigiProducer]::Create EB " << m_EBdigiCollection << " " + << " collection and digitizer" << std::endl; #endif m_BarrelDigitizer->setTimeLayerId(m_timeLayerEB); - m_EndcapDigitizer->setTimeLayerId(m_timeLayerEE); } EcalTimeDigiProducer::~EcalTimeDigiProducer() {} @@ -55,21 +43,14 @@ void EcalTimeDigiProducer::initializeEvent(edm::Event const &event, edm::EventSe // checkCalibrations( event, eventSetup ); // here the methods to clean the maps m_BarrelDigitizer->initializeMap(); - m_EndcapDigitizer->initializeMap(); } -void EcalTimeDigiProducer::accumulateCaloHits(HitsHandle const &ebHandle, - HitsHandle const &eeHandle, - int bunchCrossing) { +void EcalTimeDigiProducer::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); } - - if (eeHandle.isValid()) { - m_EndcapDigitizer->add(*eeHandle.product(), bunchCrossing); - } } void EcalTimeDigiProducer::accumulate(edm::Event const &e, edm::EventSetup const &eventSetup) { @@ -77,14 +58,11 @@ void EcalTimeDigiProducer::accumulate(edm::Event const &e, edm::EventSetup const edm::Handle> ebHandle; e.getByToken(m_hitsProducerTokenEB, ebHandle); - edm::Handle> eeHandle; - e.getByToken(m_hitsProducerTokenEE, eeHandle); - #ifdef ecal_time_debug std::cout << "[EcalTimeDigiProducer]::Accumulate Hits HS event" << std::endl; #endif - accumulateCaloHits(ebHandle, eeHandle, 0); + accumulateCaloHits(ebHandle, 0); } void EcalTimeDigiProducer::accumulate(PileUpEventPrincipal const &e, @@ -93,18 +71,14 @@ void EcalTimeDigiProducer::accumulate(PileUpEventPrincipal const &e, edm::Handle> ebHandle; e.getByLabel(m_hitsProducerTagEB, ebHandle); - edm::Handle> eeHandle; - e.getByLabel(m_hitsProducerTagEE, eeHandle); - #ifdef ecal_time_debug std::cout << "[EcalTimeDigiProducer]::Accumulate Hits for BC " << e.bunchCrossing() << std::endl; #endif - accumulateCaloHits(ebHandle, eeHandle, e.bunchCrossing()); + accumulateCaloHits(ebHandle, e.bunchCrossing()); } void EcalTimeDigiProducer::finalizeEvent(edm::Event &event, edm::EventSetup const &eventSetup) { - std::unique_ptr barrelResult(new EcalTimeDigiCollection()); - std::unique_ptr endcapResult(new EcalTimeDigiCollection()); + std::unique_ptr barrelResult = std::make_unique(); #ifdef ecal_time_debug std::cout << "[EcalTimeDigiProducer]::finalizeEvent" << std::endl; @@ -119,20 +93,11 @@ void EcalTimeDigiProducer::finalizeEvent(edm::Event &event, edm::EventSetup cons edm::LogInfo("TimeDigiInfo") << "EB time Digis: " << barrelResult->size(); - m_EndcapDigitizer->run(*endcapResult); - -#ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer]::EE Digi size " << endcapResult->size() << std::endl; -#endif - - edm::LogInfo("TimeDigiInfo") << "EE Digis: " << endcapResult->size(); - #ifdef ecal_time_debug - std::cout << "[EcalTimeDigiProducer]::putting collections into the event " << std::endl; + std::cout << "[EcalTimeDigiProducer]::putting EcalTimeDigiCollection into the event " << std::endl; #endif event.put(std::move(barrelResult), m_EBdigiCollection); - event.put(std::move(endcapResult), m_EEdigiCollection); } void EcalTimeDigiProducer::checkGeometry(const edm::EventSetup &eventSetup) { @@ -150,5 +115,4 @@ void EcalTimeDigiProducer::checkGeometry(const edm::EventSetup &eventSetup) { void EcalTimeDigiProducer::updateGeometry() { m_BarrelDigitizer->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalBarrel)); - m_EndcapDigitizer->setGeometry(m_Geometry->getSubdetectorGeometry(DetId::Ecal, EcalEndcap)); } diff --git a/SimGeneral/MixingModule/python/aliases_cfi.py b/SimGeneral/MixingModule/python/aliases_cfi.py index ab7507921b55c..94b5ba5acde0d 100644 --- a/SimGeneral/MixingModule/python/aliases_cfi.py +++ b/SimGeneral/MixingModule/python/aliases_cfi.py @@ -12,6 +12,15 @@ cms.PSet(type = cms.string('ESDigiCollection')) ) ) + +from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel +phase2_ecal_devel.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_Ph2_cfi.py b/SimGeneral/MixingModule/python/ecalDigitizer_Ph2_cfi.py new file mode 100644 index 0000000000000..27cd2c54e1567 --- /dev/null +++ b/SimGeneral/MixingModule/python/ecalDigitizer_Ph2_cfi.py @@ -0,0 +1,26 @@ +import FWCore.ParameterSet.Config as cms + +from SimCalorimetry.EcalSimProducers.ecalDigiParameters_Ph2_cff import * +from SimCalorimetry.EcalSimProducers.apdSimParameters_cff import * +from SimCalorimetry.EcalSimProducers.ecalSimParameterMap_cff import * +from SimCalorimetry.EcalSimProducers.ecalElectronicsSim_Ph2_cff import * +from SimCalorimetry.EcalSimProducers.ecalNotContainmentSim_cff import * +from SimCalorimetry.EcalSimProducers.ecalCosmicsSim_cff import * + + +ecalDigitizer_Ph2 = cms.PSet( + ecal_digi_parameters, + apd_sim_parameters, + ecal_electronics_sim, + ecal_cosmics_sim, + ecal_sim_parameter_map_ph2, + ecal_notCont_sim, + hitsProducer = cms.string('g4SimHits'), + accumulatorType = cms.string("EcalDigiProducer_Ph2"), + makeDigiSimLinks = cms.untracked.bool(False), + doEB = cms.bool(True) +) + +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toModify(ecalDigitizer_Ph2, hitsProducer = "fastSimProducer") + diff --git a/SimGeneral/MixingModule/python/ecalDigitizer_cfi.py b/SimGeneral/MixingModule/python/ecalDigitizer_cfi.py index d52c937f94c10..bc87cb6cf33c8 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, @@ -28,7 +29,15 @@ ecalDigitizer.doEE = cms.bool(True) ecalDigitizer.doES = cms.bool(True) -from Configuration.Eras.Modifier_phase2_common_cff import phase2_common -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) ) + +from Configuration.Eras.Modifier_phase2_common_cff import phase2_common +phase2_common.toModify( ecalDigitizer, doES = cms.bool(False) ) + +#phase 2 digitization +from Configuration.Eras.Modifier_phase2_ecal_devel_cff import phase2_ecal_devel +from SimGeneral.MixingModule.ecalDigitizer_Ph2_cfi import ecalDigitizer_Ph2 as _ecalDigitizer_Ph2 +phase2_ecal_devel.toReplaceWith(ecalDigitizer,_ecalDigitizer_Ph2)