CMS 3D CMS Logo
List of all members | Public Member Functions | Private Types | Private Member Functions | Private Attributes
HcalDigitizer Class Reference

#include <HcalDigitizer.h>

Public Member Functions

void accumulate (edm::Event const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *)
 
void accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *)
 
void finalizeEvent (edm::Event &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *)
 
 HcalDigitizer (const edm::ParameterSet &ps, edm::ConsumesCollector &iC)
 
void initializeEvent (edm::Event const &e, edm::EventSetup const &c)
 
void setHBHENoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)
 
void setHFNoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)
 
void setHONoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)
 
void setQIE10NoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)
 
void setQIE11NoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)
 
void setZDCNoiseSignalGenerator (HcalBaseSignalGenerator *noiseGenerator)
 
virtual ~HcalDigitizer ()
 

Private Types

typedef CaloTDigitizer< HBHEDigitizerTraits, CaloTDigitizerQIE8Run > HBHEDigitizer
 
typedef CaloTDigitizer< HFDigitizerTraits, CaloTDigitizerQIE8Run > HFDigitizer
 
typedef CaloTDigitizer< HODigitizerTraits, CaloTDigitizerQIE8Run > HODigitizer
 
typedef CaloTDigitizer< HcalQIE10DigitizerTraits, CaloTDigitizerQIE1011Run > QIE10Digitizer
 
typedef CaloTDigitizer< HcalQIE11DigitizerTraits, CaloTDigitizerQIE1011Run > QIE11Digitizer
 
typedef CaloTDigitizer< ZDCDigitizerTraits, CaloTDigitizerQIE8Run > ZDCDigitizer
 

Private Member Functions

void accumulateCaloHits (edm::Handle< std::vector< PCaloHit >> const &hcalHits, edm::Handle< std::vector< PCaloHit >> const &zdcHits, int bunchCrossing, CLHEP::HepRandomEngine *, const HcalTopology *h)
 
void buildHBHEQIECells (const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)
 
void buildHFQIECells (const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)
 
void buildHOSiPMCells (const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)
 
void checkGeometry (const edm::EventSetup &eventSetup)
 
void darkening (std::vector< PCaloHit > &hcalHits)
 
void fillFakeHits ()
 some hits in each subdetector, just for testing purposes More...
 
void setup (const edm::EventSetup &es)
 
void updateGeometry (const edm::EventSetup &eventSetup)
 

Private Attributes

bool agingFlagHB
 
bool agingFlagHE
 
const edm::ESGetToken< HcalDbService, HcalDbRecord > conditionsToken_
 
bool debugCS_
 
double deliveredLumi
 
bool doHFWindow_
 
std::vector< DetId > hbheCells
 
bool hbhegeo
 
const HcalTimeSlew * hcalTimeSlew_delay_
 
const edm::ESGetToken< HcalTimeSlew, HcalTimeSlewRecord > hcalTimeSlew_delay_token_
 
bool hfgeo
 
std::string hitsProducer_
 
bool hogeo
 
bool ignoreTime_
 
std::vector< PCaloHit > injectedHits_
 
std::vector< int > injectedHitsCells_
 
std::vector< double > injectedHitsEnergy_
 
std::vector< double > injectedHitsTime_
 
bool injectTestHits_
 
bool isHCAL
 
bool isZDC
 
bool killHE_
 
const HBHEDarkening * m_HBDarkening
 
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > m_HBDarkeningToken
 
const HBHEDarkening * m_HEDarkening
 
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > m_HEDarkeningToken
 
std::unique_ptr< HFRecalibration > m_HFRecalibration
 
edm::ESGetToken< HcalMCParams, HcalMCParamsRcd > mcParamsToken_
 
const edm::ESGetToken< HcalQIETypes, HcalQIETypesRcd > qieTypesToken_
 
bool testNumbering_
 
std::unique_ptr< HcalCoderFactory > theCoderFactory
 
const CaloGeometry * theGeometry
 
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord > theGeometryToken
 
edm::ESWatcher< CaloGeometryRecord > theGeometryWatcher_
 
std::unique_ptr< HcalAmplifier > theHBHEAmplifier
 
std::unique_ptr< HBHEDigitizer > theHBHEDigitizer
 
std::unique_ptr< HcalElectronicsSim > theHBHEElectronicsSim
 
HBHEHitFilter theHBHEHitFilter
 
std::unique_ptr< HcalAmplifier > theHBHEQIE11Amplifier
 
std::vector< DetId > theHBHEQIE11DetIds
 
std::unique_ptr< QIE11Digitizer > theHBHEQIE11Digitizer
 
std::unique_ptr< HcalElectronicsSim > theHBHEQIE11ElectronicsSim
 
HBHEHitFilter theHBHEQIE11HitFilter
 
std::vector< DetId > theHBHEQIE8DetIds
 
std::unique_ptr< CaloHitResponse > theHBHEResponse
 
std::unique_ptr< HcalSiPMHitResponse > theHBHESiPMResponse
 
std::unique_ptr< HcalAmplifier > theHFAmplifier
 
std::unique_ptr< HFDigitizer > theHFDigitizer
 
std::unique_ptr< HcalElectronicsSim > theHFElectronicsSim
 
HFHitFilter theHFHitFilter
 
std::unique_ptr< HcalAmplifier > theHFQIE10Amplifier
 
std::vector< DetId > theHFQIE10DetIds
 
std::unique_ptr< QIE10Digitizer > theHFQIE10Digitizer
 
std::unique_ptr< HcalElectronicsSim > theHFQIE10ElectronicsSim
 
HFHitFilter theHFQIE10HitFilter
 
std::unique_ptr< CaloHitResponse > theHFQIE10Response
 
std::vector< DetId > theHFQIE8DetIds
 
std::unique_ptr< CaloHitResponse > theHFResponse
 
std::unique_ptr< HcalAmplifier > theHOAmplifier
 
std::unique_ptr< HODigitizer > theHODigitizer
 
std::unique_ptr< HcalElectronicsSim > theHOElectronicsSim
 
HOHitFilter theHOHitFilter
 
std::vector< DetId > theHOHPDDetIds
 
std::unique_ptr< CaloHitResponse > theHOResponse
 
int theHOSiPMCode
 
std::vector< DetId > theHOSiPMDetIds
 
std::unique_ptr< HODigitizer > theHOSiPMDigitizer
 
HOHitFilter theHOSiPMHitFilter
 
std::unique_ptr< HcalSiPMHitResponse > theHOSiPMResponse
 
std::unique_ptr< HPDIonFeedbackSim > theIonFeedback
 
HcalSimParameterMap theParameterMap
 
const HcalDDDRecConstants * theRecNumber
 
const edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord > theRecNumberToken
 
edm::ESWatcher< HcalRecNumberingRecord > theRecNumberWatcher_
 
std::unique_ptr< HcalHitRelabeller > theRelabeller
 
HcalShapes theShapes
 
std::unique_ptr< HcalTimeSlewSim > theTimeSlewSim
 
std::unique_ptr< HcalAmplifier > theZDCAmplifier
 
std::unique_ptr< ZDCDigitizer > theZDCDigitizer
 
std::unique_ptr< HcalElectronicsSim > theZDCElectronicsSim
 
ZDCHitFilter theZDCHitFilter
 
std::unique_ptr< CaloHitResponse > theZDCResponse
 
const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > topoToken_
 
bool zdcgeo
 

Detailed Description

Definition at line 45 of file HcalDigitizer.h.

Member Typedef Documentation

◆ HBHEDigitizer

typedef CaloTDigitizer<HBHEDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HBHEDigitizer
private

Reconstruction algorithm

Definition at line 99 of file HcalDigitizer.h.

◆ HFDigitizer

typedef CaloTDigitizer<HFDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HFDigitizer
private

Definition at line 101 of file HcalDigitizer.h.

◆ HODigitizer

typedef CaloTDigitizer<HODigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::HODigitizer
private

Definition at line 100 of file HcalDigitizer.h.

◆ QIE10Digitizer

typedef CaloTDigitizer<HcalQIE10DigitizerTraits, CaloTDigitizerQIE1011Run> HcalDigitizer::QIE10Digitizer
private

Definition at line 103 of file HcalDigitizer.h.

◆ QIE11Digitizer

typedef CaloTDigitizer<HcalQIE11DigitizerTraits, CaloTDigitizerQIE1011Run> HcalDigitizer::QIE11Digitizer
private

Definition at line 104 of file HcalDigitizer.h.

◆ ZDCDigitizer

typedef CaloTDigitizer<ZDCDigitizerTraits, CaloTDigitizerQIE8Run> HcalDigitizer::ZDCDigitizer
private

Definition at line 102 of file HcalDigitizer.h.

Constructor & Destructor Documentation

◆ HcalDigitizer()

HcalDigitizer::HcalDigitizer ( const edm::ParameterSet &  ps,
edm::ConsumesCollector &  iC 
)
explicit

Definition at line 34 of file HcalDigitizer.cc.

35  : conditionsToken_(iC.esConsumes()),
36  topoToken_(iC.esConsumes()),
37  hcalTimeSlew_delay_token_(iC.esConsumes(edm::ESInputTag("", "HBHE"))),
38  theGeometryToken(iC.esConsumes()),
39  theRecNumberToken(iC.esConsumes()),
40  qieTypesToken_(iC.esConsumes()),
41  theGeometry(nullptr),
42  theRecNumber(nullptr),
43  theParameterMap(ps),
44  theShapes(),
45  theHBHEResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
46  theHBHESiPMResponse(std::make_unique<HcalSiPMHitResponse>(
47  &theParameterMap, &theShapes, ps.getParameter<bool>("HcalPreMixStage1"), true)),
48  theHOResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
49  theHOSiPMResponse(std::make_unique<HcalSiPMHitResponse>(
50  &theParameterMap, &theShapes, ps.getParameter<bool>("HcalPreMixStage1"), false)),
51  theHFResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
52  theHFQIE10Response(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
53  theZDCResponse(std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes)),
54  theHBHEAmplifier(nullptr),
55  theHFAmplifier(nullptr),
56  theHOAmplifier(nullptr),
57  theZDCAmplifier(nullptr),
58  theHFQIE10Amplifier(nullptr),
59  theHBHEQIE11Amplifier(nullptr),
60  theIonFeedback(nullptr),
61  theCoderFactory(nullptr),
62  theHBHEElectronicsSim(nullptr),
63  theHFElectronicsSim(nullptr),
64  theHOElectronicsSim(nullptr),
65  theZDCElectronicsSim(nullptr),
66  theHFQIE10ElectronicsSim(nullptr),
67  theHBHEQIE11ElectronicsSim(nullptr),
68  theHBHEHitFilter(),
69  theHBHEQIE11HitFilter(),
70  theHFHitFilter(),
71  theHFQIE10HitFilter(),
72  theHOHitFilter(),
73  theHOSiPMHitFilter(),
74  theZDCHitFilter(),
75  theHBHEDigitizer(nullptr),
76  theHODigitizer(nullptr),
77  theHOSiPMDigitizer(nullptr),
78  theHFDigitizer(nullptr),
79  theZDCDigitizer(nullptr),
80  theHFQIE10Digitizer(nullptr),
81  theHBHEQIE11Digitizer(nullptr),
82  theRelabeller(nullptr),
83  isZDC(true),
84  isHCAL(true),
85  zdcgeo(true),
86  hbhegeo(true),
87  hogeo(true),
88  hfgeo(true),
89  doHFWindow_(ps.getParameter<bool>("doHFWindow")),
90  killHE_(ps.getParameter<bool>("killHE")),
91  debugCS_(ps.getParameter<bool>("debugCaloSamples")),
92  ignoreTime_(ps.getParameter<bool>("ignoreGeantTime")),
93  injectTestHits_(ps.getParameter<bool>("injectTestHits")),
94  hitsProducer_(ps.getParameter<std::string>("hitsProducer")),
95  theHOSiPMCode(ps.getParameter<edm::ParameterSet>("ho").getParameter<int>("siPMCode")),
96  deliveredLumi(0.),
97  agingFlagHB(ps.getParameter<bool>("HBDarkening")),
98  agingFlagHE(ps.getParameter<bool>("HEDarkening")),
99  m_HBDarkening(nullptr),
100  m_HEDarkening(nullptr),
101  m_HFRecalibration(nullptr),
102  injectedHitsEnergy_(ps.getParameter<std::vector<double>>("injectTestHitsEnergy")),
103  injectedHitsTime_(ps.getParameter<std::vector<double>>("injectTestHitsTime")),
104  injectedHitsCells_(ps.getParameter<std::vector<int>>("injectTestHitsCells")) {
105  iC.consumes<std::vector<PCaloHit>>(edm::InputTag(hitsProducer_, "ZDCHITS"));
106  iC.consumes<std::vector<PCaloHit>>(edm::InputTag(hitsProducer_, "HcalHits"));
107 
108  if (agingFlagHB) {
109  m_HBDarkeningToken = iC.esConsumes(edm::ESInputTag("", "HB"));
110  }
111  if (agingFlagHE) {
112  m_HEDarkeningToken = iC.esConsumes(edm::ESInputTag("", "HE"));
113  }
114  if (theHOSiPMCode == 2) {
115  mcParamsToken_ = iC.esConsumes();
116  }
117 
118  bool doNoise = ps.getParameter<bool>("doNoise");
119 
120  bool PreMix1 = ps.getParameter<bool>("HcalPreMixStage1"); // special threshold/pedestal treatment
121  bool PreMix2 = ps.getParameter<bool>("HcalPreMixStage2"); // special threshold/pedestal treatment
122  bool doEmpty = ps.getParameter<bool>("doEmpty");
123  deliveredLumi = ps.getParameter<double>("DelivLuminosity");
124  bool agingFlagHF = ps.getParameter<bool>("HFDarkening");
125  double minFCToDelay = ps.getParameter<double>("minFCToDelay");
126 
127  if (PreMix1 && PreMix2) {
128  throw cms::Exception("Configuration") << "HcalDigitizer cannot operate in PreMixing digitization and "
129  "PreMixing\n"
130  "digi combination modes at the same time. Please set one mode to "
131  "False\n"
132  "in the configuration file.";
133  }
134 
135  // need to make copies, because they might get different noise generators
136  theHBHEAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
137  theHFAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
138  theHOAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
139  theZDCAmplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
140  theHFQIE10Amplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
141  theHBHEQIE11Amplifier = std::make_unique<HcalAmplifier>(&theParameterMap, doNoise, PreMix1, PreMix2);
142 
143  theCoderFactory = std::make_unique<HcalCoderFactory>(HcalCoderFactory::DB);
144 
145  theHBHEElectronicsSim =
146  std::make_unique<HcalElectronicsSim>(&theParameterMap, theHBHEAmplifier.get(), theCoderFactory.get(), PreMix1);
147  theHFElectronicsSim =
148  std::make_unique<HcalElectronicsSim>(&theParameterMap, theHFAmplifier.get(), theCoderFactory.get(), PreMix1);
149  theHOElectronicsSim =
150  std::make_unique<HcalElectronicsSim>(&theParameterMap, theHOAmplifier.get(), theCoderFactory.get(), PreMix1);
151  theZDCElectronicsSim =
152  std::make_unique<HcalElectronicsSim>(&theParameterMap, theZDCAmplifier.get(), theCoderFactory.get(), PreMix1);
153  theHFQIE10ElectronicsSim =
154  std::make_unique<HcalElectronicsSim>(&theParameterMap,
155  theHFQIE10Amplifier.get(),
156  theCoderFactory.get(),
157  PreMix1); // should this use a different coder factory?
158  theHBHEQIE11ElectronicsSim =
159  std::make_unique<HcalElectronicsSim>(&theParameterMap,
160  theHBHEQIE11Amplifier.get(),
161  theCoderFactory.get(),
162  PreMix1); // should this use a different coder factory?
163 
164  bool doHOHPD = (theHOSiPMCode != 1);
165  bool doHOSiPM = (theHOSiPMCode != 0);
166  if (doHOHPD) {
167  theHOResponse = std::make_unique<CaloHitResponse>(&theParameterMap, &theShapes);
168  theHOResponse->setHitFilter(&theHOHitFilter);
169  theHODigitizer = std::make_unique<HODigitizer>(theHOResponse.get(), theHOElectronicsSim.get(), doEmpty);
170  }
171  if (doHOSiPM) {
172  theHOSiPMResponse->setHitFilter(&theHOSiPMHitFilter);
173  theHOSiPMDigitizer = std::make_unique<HODigitizer>(theHOSiPMResponse.get(), theHOElectronicsSim.get(), doEmpty);
174  }
175 
176  theHBHEResponse->setHitFilter(&theHBHEHitFilter);
177  theHBHESiPMResponse->setHitFilter(&theHBHEQIE11HitFilter);
178 
179  // QIE8 and QIE11 can coexist in HBHE
180  theHBHEQIE11Digitizer =
181  std::make_unique<QIE11Digitizer>(theHBHESiPMResponse.get(), theHBHEQIE11ElectronicsSim.get(), doEmpty);
182  theHBHEDigitizer = std::make_unique<HBHEDigitizer>(theHBHEResponse.get(), theHBHEElectronicsSim.get(), doEmpty);
183 
184  bool doTimeSlew = ps.getParameter<bool>("doTimeSlew");
185  // initialize: they won't be called later if flag is set
186  hcalTimeSlew_delay_ = nullptr;
187  theTimeSlewSim.reset(nullptr);
188  if (doTimeSlew) {
189  // no time slewing for HF
190  theTimeSlewSim = std::make_unique<HcalTimeSlewSim>(&theParameterMap, minFCToDelay);
191  theHBHEAmplifier->setTimeSlewSim(theTimeSlewSim.get());
192  theHBHEQIE11Amplifier->setTimeSlewSim(theTimeSlewSim.get());
193  theHOAmplifier->setTimeSlewSim(theTimeSlewSim.get());
194  theZDCAmplifier->setTimeSlewSim(theTimeSlewSim.get());
195  }
196 
197  theHFResponse->setHitFilter(&theHFHitFilter);
198  theHFQIE10Response->setHitFilter(&theHFQIE10HitFilter);
199  theZDCResponse->setHitFilter(&theZDCHitFilter);
200 
201  // QIE8 and QIE10 can coexist in HF
202  theHFQIE10Digitizer =
203  std::make_unique<QIE10Digitizer>(theHFQIE10Response.get(), theHFQIE10ElectronicsSim.get(), doEmpty);
204  theHFDigitizer = std::make_unique<HFDigitizer>(theHFResponse.get(), theHFElectronicsSim.get(), doEmpty);
205 
206  theZDCDigitizer = std::make_unique<ZDCDigitizer>(theZDCResponse.get(), theZDCElectronicsSim.get(), doEmpty);
207 
208  testNumbering_ = ps.getParameter<bool>("TestNumbering");
209  // std::cout << "Flag to see if Hit Relabeller to be initiated " <<
210  // testNumbering_ << std::endl;
211  if (testNumbering_)
212  theRelabeller = std::make_unique<HcalHitRelabeller>(ps.getParameter<bool>("doNeutralDensityFilter"));
213 
214  if (ps.getParameter<bool>("doIonFeedback") && theHBHEResponse) {
215  theIonFeedback = std::make_unique<HPDIonFeedbackSim>(ps, &theShapes);
216  theHBHEResponse->setPECorrection(theIonFeedback.get());
217  if (ps.getParameter<bool>("doThermalNoise")) {
218  theHBHEAmplifier->setIonFeedbackSim(theIonFeedback.get());
219  }
220  }
221 
222  // option to save CaloSamples as event product for debugging
223  if (debugCS_) {
224  if (theHBHEDigitizer)
225  theHBHEDigitizer->setDebugCaloSamples(true);
226  if (theHBHEQIE11Digitizer)
227  theHBHEQIE11Digitizer->setDebugCaloSamples(true);
228  if (theHODigitizer)
229  theHODigitizer->setDebugCaloSamples(true);
230  if (theHOSiPMDigitizer)
231  theHOSiPMDigitizer->setDebugCaloSamples(true);
232  if (theHFDigitizer)
233  theHFDigitizer->setDebugCaloSamples(true);
234  if (theHFQIE10Digitizer)
235  theHFQIE10Digitizer->setDebugCaloSamples(true);
236  theZDCDigitizer->setDebugCaloSamples(true);
237  }
238 
239  // option to ignore Geant time distribution in SimHits, for debugging
240  if (ignoreTime_) {
241  theHBHEResponse->setIgnoreGeantTime(ignoreTime_);
242  theHBHESiPMResponse->setIgnoreGeantTime(ignoreTime_);
243  theHOResponse->setIgnoreGeantTime(ignoreTime_);
244  theHOSiPMResponse->setIgnoreGeantTime(ignoreTime_);
245  theHFResponse->setIgnoreGeantTime(ignoreTime_);
246  theHFQIE10Response->setIgnoreGeantTime(ignoreTime_);
247  theZDCResponse->setIgnoreGeantTime(ignoreTime_);
248  }
249 
250  if (agingFlagHF)
251  m_HFRecalibration = std::make_unique<HFRecalibration>(ps.getParameter<edm::ParameterSet>("HFRecalParameterBlock"));
252 }

References agingFlagHB, agingFlagHE, edm::ConsumesCollector::consumes(), HcalCoderFactory::DB, debugCS_, deliveredLumi, DataMixerDataOnData_cff::doEmpty, DigiDM_cff::doNoise, hcalUnsuppressedDigis_cfi::doTimeSlew, edm::ConsumesCollector::esConsumes(), Exception, edm::ParameterSet::getParameter(), hcalTimeSlew_delay_, hitsProducer_, ignoreTime_, HLT_FULL_cff::InputTag, m_HBDarkeningToken, m_HEDarkeningToken, m_HFRecalibration, mcParamsToken_, hcalUnsuppressedDigis_cfi::minFCToDelay, testNumbering_, theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, theHBHEHitFilter, theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, theHBHEQIE11HitFilter, theHBHEResponse, theHBHESiPMResponse, theHFAmplifier, theHFDigitizer, theHFElectronicsSim, theHFHitFilter, theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, theHFQIE10HitFilter, theHFQIE10Response, theHFResponse, theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOHitFilter, theHOResponse, theHOSiPMCode, theHOSiPMDigitizer, theHOSiPMHitFilter, theHOSiPMResponse, theIonFeedback, theParameterMap, theRelabeller, theShapes, theTimeSlewSim, theZDCAmplifier, theZDCDigitizer, theZDCElectronicsSim, theZDCHitFilter, and theZDCResponse.

◆ ~HcalDigitizer()

HcalDigitizer::~HcalDigitizer ( )
virtual

Definition at line 254 of file HcalDigitizer.cc.

254 {}

Member Function Documentation

◆ accumulate() [1/2]

void HcalDigitizer::accumulate ( edm::Event const &  e,
edm::EventSetup const &  c,
CLHEP::HepRandomEngine *  engine 
)

Definition at line 426 of file HcalDigitizer.cc.

426  {
427  // Step A: Get Inputs
428  edm::InputTag zdcTag(hitsProducer_, "ZDCHITS");
429  edm::Handle<std::vector<PCaloHit>> zdcHandle;
430  e.getByLabel(zdcTag, zdcHandle);
431  isZDC = zdcHandle.isValid();
432 
433  edm::InputTag hcalTag(hitsProducer_, "HcalHits");
434  edm::Handle<std::vector<PCaloHit>> hcalHandle;
435  e.getByLabel(hcalTag, hcalHandle);
436  isHCAL = hcalHandle.isValid() or injectTestHits_;
437 
438  const HcalTopology *htopoP = &eventSetup.getData(topoToken_);
439 
440  accumulateCaloHits(hcalHandle, zdcHandle, 0, engine, htopoP);
441 }

References accumulateCaloHits(), MillePedeFileConverter_cfg::e, edm::EventSetup::getData(), hitsProducer_, injectTestHits_, isHCAL, edm::HandleBase::isValid(), isZDC, or, and topoToken_.

Referenced by HcalDigiProducer::accumulate().

◆ accumulate() [2/2]

void HcalDigitizer::accumulate ( PileUpEventPrincipal const &  e,
edm::EventSetup const &  c,
CLHEP::HepRandomEngine *  engine 
)

Definition at line 443 of file HcalDigitizer.cc.

445  {
446  // Step A: Get Inputs
447  edm::InputTag zdcTag(hitsProducer_, "ZDCHITS");
448  edm::Handle<std::vector<PCaloHit>> zdcHandle;
449  e.getByLabel(zdcTag, zdcHandle);
450  isZDC = zdcHandle.isValid();
451 
452  edm::InputTag hcalTag(hitsProducer_, "HcalHits");
453  edm::Handle<std::vector<PCaloHit>> hcalHandle;
454  e.getByLabel(hcalTag, hcalHandle);
455  isHCAL = hcalHandle.isValid();
456 
457  const HcalTopology *htopoP = &eventSetup.getData(topoToken_);
458 
459  accumulateCaloHits(hcalHandle, zdcHandle, e.bunchCrossing(), engine, htopoP);
460 }

References accumulateCaloHits(), MillePedeFileConverter_cfg::e, edm::EventSetup::getData(), hitsProducer_, isHCAL, edm::HandleBase::isValid(), isZDC, and topoToken_.

◆ accumulateCaloHits()

void HcalDigitizer::accumulateCaloHits ( edm::Handle< std::vector< PCaloHit >> const &  hcalHits,
edm::Handle< std::vector< PCaloHit >> const &  zdcHits,
int  bunchCrossing,
CLHEP::HepRandomEngine *  engine,
const HcalTopology *  h 
)
private

Definition at line 342 of file HcalDigitizer.cc.

346  {
347  // Step A: pass in inputs, and accumulate digis
348  if (isHCAL) {
349  std::vector<PCaloHit> hcalHitsOrig = *hcalHandle.product();
350  if (injectTestHits_)
351  hcalHitsOrig = injectedHits_;
352  std::vector<PCaloHit> hcalHits;
353  hcalHits.reserve(hcalHitsOrig.size());
354 
355  // evaluate darkening before relabeling
356  if (testNumbering_) {
357  if (m_HBDarkening || m_HEDarkening || m_HFRecalibration) {
358  darkening(hcalHitsOrig);
359  }
360  // Relabel PCaloHits if necessary
361  edm::LogInfo("HcalDigitizer") << "Calling Relabeller";
362  theRelabeller->process(hcalHitsOrig);
363  }
364 
365  // eliminate bad hits
366  for (unsigned int i = 0; i < hcalHitsOrig.size(); i++) {
367  DetId id(hcalHitsOrig[i].id());
368  HcalDetId hid(id);
369  if (!htopoP->validHcal(hid)) {
370  edm::LogError("HcalDigitizer") << "bad hcal id found in digitizer. Skipping " << id.rawId() << " " << hid
371  << std::endl;
372  continue;
373  } else if (hid.subdet() == HcalForward && !doHFWindow_ && hcalHitsOrig[i].depth() != 0) {
374  // skip HF window hits unless desired
375  continue;
376  } else if (killHE_ && hid.subdet() == HcalEndcap) {
377  // remove HE hits if asked for (phase 2)
378  continue;
379  } else {
380 #ifdef DebugLog
381  std::cout << "HcalDigitizer format " << hid.oldFormat() << " for " << hid << std::endl;
382 #endif
383  DetId newid = DetId(hid.newForm());
384 #ifdef DebugLog
385  std::cout << "Hit " << i << " out of " << hcalHits.size() << " " << std::hex << id.rawId() << " --> "
386  << newid.rawId() << std::dec << " " << HcalDetId(newid.rawId()) << '\n';
387 #endif
388  hcalHitsOrig[i].setID(newid.rawId());
389  hcalHits.push_back(hcalHitsOrig[i]);
390  }
391  }
392 
393  if (hbhegeo) {
394  if (theHBHEDigitizer)
395  theHBHEDigitizer->add(hcalHits, bunchCrossing, engine);
396  if (theHBHEQIE11Digitizer)
397  theHBHEQIE11Digitizer->add(hcalHits, bunchCrossing, engine);
398  }
399 
400  if (hogeo) {
401  if (theHODigitizer)
402  theHODigitizer->add(hcalHits, bunchCrossing, engine);
403  if (theHOSiPMDigitizer)
404  theHOSiPMDigitizer->add(hcalHits, bunchCrossing, engine);
405  }
406 
407  if (hfgeo) {
408  if (theHFDigitizer)
409  theHFDigitizer->add(hcalHits, bunchCrossing, engine);
410  if (theHFQIE10Digitizer)
411  theHFQIE10Digitizer->add(hcalHits, bunchCrossing, engine);
412  }
413  } else {
414  edm::LogInfo("HcalDigitizer") << "We don't have HCAL hit collection available ";
415  }
416 
417  if (isZDC) {
418  if (zdcgeo) {
419  theZDCDigitizer->add(*zdcHandle.product(), bunchCrossing, engine);
420  }
421  } else {
422  edm::LogInfo("HcalDigitizer") << "We don't have ZDC hit collection available ";
423  }
424 }

References gather_cfg::cout, darkening(), TauDecayModes::dec, doHFWindow_, hbhegeo, HcalEndcap, HcalForward, hfgeo, hogeo, mps_fire::i, triggerObjects_cff::id, injectedHits_, injectTestHits_, isHCAL, isZDC, killHE_, m_HBDarkening, m_HEDarkening, m_HFRecalibration, HcalDetId::newForm(), HcalDetId::oldFormat(), DetId::rawId(), HcalDetId::subdet(), testNumbering_, theHBHEDigitizer, theHBHEQIE11Digitizer, theHFDigitizer, theHFQIE10Digitizer, theHODigitizer, theHOSiPMDigitizer, theRelabeller, theZDCDigitizer, HcalTopology::validHcal(), and zdcgeo.

Referenced by accumulate().

◆ buildHBHEQIECells()

void HcalDigitizer::buildHBHEQIECells ( const std::vector< DetId > &  allCells,
const edm::EventSetup &  eventSetup 
)
private

Definition at line 723 of file HcalDigitizer.cc.

723  {
724  // if results are already cached, no need to look again
725  if (!theHBHEQIE8DetIds.empty() || !theHBHEQIE11DetIds.empty())
726  return;
727 
728  // get the QIETypes
729  // intentional copy
730  HcalQIETypes qieTypes = eventSetup.getData(qieTypesToken_);
731  if (qieTypes.topo() == nullptr) {
732  qieTypes.setTopo(&eventSetup.getData(topoToken_));
733  }
734 
735  for (std::vector<DetId>::const_iterator detItr = allCells.begin(); detItr != allCells.end(); ++detItr) {
736  HcalQIENum qieType = HcalQIENum(qieTypes.getValues(*detItr)->getValue());
737  if (qieType == QIE8) {
738  theHBHEQIE8DetIds.push_back(*detItr);
739  } else if (qieType == QIE11) {
740  theHBHEQIE11DetIds.push_back(*detItr);
741  } else { // default is QIE8
742  theHBHEQIE8DetIds.push_back(*detItr);
743  }
744  }
745 
746  if (!theHBHEQIE8DetIds.empty())
747  theHBHEDigitizer->setDetIds(theHBHEQIE8DetIds);
748  else {
749  theHBHEDigitizer.reset();
750  }
751 
752  if (!theHBHEQIE11DetIds.empty())
753  theHBHEQIE11Digitizer->setDetIds(theHBHEQIE11DetIds);
754  else {
755  theHBHEQIE11Digitizer.reset();
756  }
757 
758  if (!theHBHEQIE8DetIds.empty() && !theHBHEQIE11DetIds.empty()) {
759  theHBHEHitFilter.setDetIds(theHBHEQIE8DetIds);
760  theHBHEQIE11HitFilter.setDetIds(theHBHEQIE11DetIds);
761  }
762 }

References edm::EventSetup::getData(), HcalQIEType::getValue(), HcalCondObjectContainer< Item >::getValues(), QIE11, QIE8, qieTypesToken_, HcalHitFilter< subdets >::setDetIds(), HcalCondObjectContainerBase::setTopo(), theHBHEDigitizer, theHBHEHitFilter, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, theHBHEQIE11HitFilter, theHBHEQIE8DetIds, HcalCondObjectContainerBase::topo(), and topoToken_.

Referenced by updateGeometry().

◆ buildHFQIECells()

void HcalDigitizer::buildHFQIECells ( const std::vector< DetId > &  allCells,
const edm::EventSetup &  eventSetup 
)
private

Definition at line 687 of file HcalDigitizer.cc.

687  {
688  // if results are already cached, no need to look again
689  if (!theHFQIE8DetIds.empty() || !theHFQIE10DetIds.empty())
690  return;
691 
692  // get the QIETypes
693  // intentional copy
694  HcalQIETypes qieTypes = eventSetup.getData(qieTypesToken_);
695  if (qieTypes.topo() == nullptr) {
696  qieTypes.setTopo(&eventSetup.getData(topoToken_));
697  }
698 
699  for (std::vector<DetId>::const_iterator detItr = allCells.begin(); detItr != allCells.end(); ++detItr) {
700  HcalQIENum qieType = HcalQIENum(qieTypes.getValues(*detItr)->getValue());
701  if (qieType == QIE8) {
702  theHFQIE8DetIds.push_back(*detItr);
703  } else if (qieType == QIE10) {
704  theHFQIE10DetIds.push_back(*detItr);
705  } else { // default is QIE8
706  theHFQIE8DetIds.push_back(*detItr);
707  }
708  }
709 
710  if (!theHFQIE8DetIds.empty())
711  theHFDigitizer->setDetIds(theHFQIE8DetIds);
712  else {
713  theHFDigitizer.reset();
714  }
715 
716  if (!theHFQIE10DetIds.empty())
717  theHFQIE10Digitizer->setDetIds(theHFQIE10DetIds);
718  else {
719  theHFQIE10Digitizer.reset();
720  }
721 }

References edm::EventSetup::getData(), HcalQIEType::getValue(), HcalCondObjectContainer< Item >::getValues(), QIE10, QIE8, qieTypesToken_, HcalCondObjectContainerBase::setTopo(), theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, theHFQIE8DetIds, HcalCondObjectContainerBase::topo(), and topoToken_.

Referenced by updateGeometry().

◆ buildHOSiPMCells()

void HcalDigitizer::buildHOSiPMCells ( const std::vector< DetId > &  allCells,
const edm::EventSetup &  eventSetup 
)
private

Definition at line 764 of file HcalDigitizer.cc.

764  {
765  // all HPD
766 
767  if (theHOSiPMCode == 0) {
768  theHODigitizer->setDetIds(allCells);
769  } else if (theHOSiPMCode == 1) {
770  theHOSiPMDigitizer->setDetIds(allCells);
771  // FIXME pick Zecotek or hamamatsu?
772  } else if (theHOSiPMCode == 2) {
773  std::vector<HcalDetId> zecotekDetIds, hamamatsuDetIds;
774 
775  // intentional copy
776  HcalMCParams mcParams = eventSetup.getData(mcParamsToken_);
777  if (mcParams.topo() == nullptr) {
778  mcParams.setTopo(&eventSetup.getData(topoToken_));
779  }
780 
781  for (std::vector<DetId>::const_iterator detItr = allCells.begin(); detItr != allCells.end(); ++detItr) {
782  int shapeType = mcParams.getValues(*detItr)->signalShape();
783  if (shapeType == HcalShapes::ZECOTEK) {
784  zecotekDetIds.emplace_back(*detItr);
785  theHOSiPMDetIds.push_back(*detItr);
786  } else if (shapeType == HcalShapes::HAMAMATSU) {
787  hamamatsuDetIds.emplace_back(*detItr);
788  theHOSiPMDetIds.push_back(*detItr);
789  } else {
790  theHOHPDDetIds.push_back(*detItr);
791  }
792  }
793 
794  if (!theHOHPDDetIds.empty())
795  theHODigitizer->setDetIds(theHOHPDDetIds);
796  else {
797  theHODigitizer.reset();
798  }
799 
800  if (!theHOSiPMDetIds.empty())
801  theHOSiPMDigitizer->setDetIds(theHOSiPMDetIds);
802  else {
803  theHOSiPMDigitizer.reset();
804  }
805 
806  if (!theHOHPDDetIds.empty() && !theHOSiPMDetIds.empty()) {
807  theHOSiPMHitFilter.setDetIds(theHOSiPMDetIds);
808  theHOHitFilter.setDetIds(theHOHPDDetIds);
809  }
810 
811  theParameterMap.setHOZecotekDetIds(zecotekDetIds);
812  theParameterMap.setHOHamamatsuDetIds(hamamatsuDetIds);
813 
814  // make sure we don't got through this exercise again
815  theHOSiPMCode = -2;
816  }
817 }

References edm::EventSetup::getData(), HcalCondObjectContainer< Item >::getValues(), HcalShapes::HAMAMATSU, mcParamsToken_, HcalHitFilter< subdets >::setDetIds(), HcalSimParameterMap::setHOHamamatsuDetIds(), HcalSimParameterMap::setHOZecotekDetIds(), HcalCondObjectContainerBase::setTopo(), HcalMCParam::signalShape(), theHODigitizer, theHOHitFilter, theHOHPDDetIds, theHOSiPMCode, theHOSiPMDetIds, theHOSiPMDigitizer, theHOSiPMHitFilter, theParameterMap, HcalCondObjectContainerBase::topo(), topoToken_, and HcalShapes::ZECOTEK.

Referenced by updateGeometry().

◆ checkGeometry()

void HcalDigitizer::checkGeometry ( const edm::EventSetup &  eventSetup)
private

make sure the digitizer has the correct list of all cells that exist in the geometry

Definition at line 581 of file HcalDigitizer.cc.

581  {
582  theGeometry = &eventSetup.getData(theGeometryToken);
583  theRecNumber = &eventSetup.getData(theRecNumberToken);
584 
585  if (theHBHEResponse)
586  theHBHEResponse->setGeometry(theGeometry);
587  if (theHBHESiPMResponse)
588  theHBHESiPMResponse->setGeometry(theGeometry);
589  if (theHOResponse)
590  theHOResponse->setGeometry(theGeometry);
591  if (theHOSiPMResponse)
592  theHOSiPMResponse->setGeometry(theGeometry);
593  theHFResponse->setGeometry(theGeometry);
594  theHFQIE10Response->setGeometry(theGeometry);
595  theZDCResponse->setGeometry(theGeometry);
596  if (theRelabeller)
597  theRelabeller->setGeometry(theRecNumber);
598 
599  // See if it's been updated
600  bool check1 = theGeometryWatcher_.check(eventSetup);
601  bool check2 = theRecNumberWatcher_.check(eventSetup);
602  if (check1 or check2) {
603  updateGeometry(eventSetup);
604  }
605 }

References edm::ESWatcher< T >::check(), edm::EventSetup::getData(), or, theGeometry, theGeometryToken, theGeometryWatcher_, theHBHEResponse, theHBHESiPMResponse, theHFQIE10Response, theHFResponse, theHOResponse, theHOSiPMResponse, theRecNumber, theRecNumberToken, theRecNumberWatcher_, theRelabeller, theZDCResponse, and updateGeometry().

Referenced by setup().

◆ darkening()

void HcalDigitizer::darkening ( std::vector< PCaloHit > &  hcalHits)
private

Definition at line 819 of file HcalDigitizer.cc.

819  {
820  for (unsigned int ii = 0; ii < hcalHits.size(); ++ii) {
821  uint32_t tmpId = hcalHits[ii].id();
822  int det, z, depth, ieta, phi, lay;
823  HcalTestNumbering::unpackHcalIndex(tmpId, det, z, depth, ieta, phi, lay);
824 
825  bool darkened = false;
826  float dweight = 1.;
827 
828  if (det == int(HcalBarrel) && m_HBDarkening) {
829  // HB darkening
830  dweight = m_HBDarkening->degradation(deliveredLumi, ieta, lay);
831  darkened = true;
832  } else if (det == int(HcalEndcap) && m_HEDarkening) {
833  // HE darkening
834  dweight = m_HEDarkening->degradation(deliveredLumi, ieta, lay);
835  darkened = true;
836  } else if (det == int(HcalForward) && m_HFRecalibration) {
837  // HF darkening - approximate: invert recalibration factor
838  dweight = 1.0 / m_HFRecalibration->getCorr(ieta, depth, deliveredLumi);
839  darkened = true;
840  }
841 
842  // reset hit energy
843  if (darkened)
844  hcalHits[ii].setEnergy(hcalHits[ii].energy() * dweight);
845  }
846 }

References HBHEDarkening::degradation(), deliveredLumi, LEDCalibrationChannels::depth, HCALHighEnergyHPDFilter_cfi::energy, HcalBarrel, HcalEndcap, HcalForward, LEDCalibrationChannels::ieta, cuy::ii, m_HBDarkening, m_HEDarkening, m_HFRecalibration, phi, HcalTestNumbering::unpackHcalIndex(), and z.

Referenced by accumulateCaloHits().

◆ fillFakeHits()

void HcalDigitizer::fillFakeHits ( )
private

some hits in each subdetector, just for testing purposes

◆ finalizeEvent()

void HcalDigitizer::finalizeEvent ( edm::Event &  e,
edm::EventSetup const &  c,
CLHEP::HepRandomEngine *  engine 
)

Definition at line 462 of file HcalDigitizer.cc.

462  {
463  // Step B: Create empty output
464  std::unique_ptr<HBHEDigiCollection> hbheResult(new HBHEDigiCollection());
465  std::unique_ptr<HODigiCollection> hoResult(new HODigiCollection());
466  std::unique_ptr<HFDigiCollection> hfResult(new HFDigiCollection());
467  std::unique_ptr<ZDCDigiCollection> zdcResult(new ZDCDigiCollection());
468  std::unique_ptr<QIE10DigiCollection> hfQIE10Result(new QIE10DigiCollection(
469  !theHFQIE10DetIds.empty() ? theParameterMap.simParameters(theHFQIE10DetIds[0]).readoutFrameSize()
470  : QIE10DigiCollection::MAXSAMPLES));
471  std::unique_ptr<QIE11DigiCollection> hbheQIE11Result(new QIE11DigiCollection(
472  !theHBHEQIE11DetIds.empty() ? theHBHESiPMResponse.get()->getReadoutFrameSize(theHBHEQIE11DetIds[0]) :
473  // theParameterMap->simParameters(theHBHEQIE11DetIds[0]).readoutFrameSize()
474  // :
475  QIE11DigiCollection::MAXSAMPLES));
476 
477  // Step C: Invoke the algorithm, getting back outputs.
478  if (isHCAL && hbhegeo) {
479  if (theHBHEDigitizer)
480  theHBHEDigitizer->run(*hbheResult, engine);
481  if (theHBHEQIE11Digitizer)
482  theHBHEQIE11Digitizer->run(*hbheQIE11Result, engine);
483  }
484  if (isHCAL && hogeo) {
485  if (theHODigitizer)
486  theHODigitizer->run(*hoResult, engine);
487  if (theHOSiPMDigitizer)
488  theHOSiPMDigitizer->run(*hoResult, engine);
489  }
490  if (isHCAL && hfgeo) {
491  if (theHFDigitizer)
492  theHFDigitizer->run(*hfResult, engine);
493  if (theHFQIE10Digitizer)
494  theHFQIE10Digitizer->run(*hfQIE10Result, engine);
495  }
496  if (isZDC && zdcgeo) {
497  theZDCDigitizer->run(*zdcResult, engine);
498  }
499 
500  edm::LogInfo("HcalDigitizer") << "HCAL HBHE digis : " << hbheResult->size();
501  edm::LogInfo("HcalDigitizer") << "HCAL HO digis : " << hoResult->size();
502  edm::LogInfo("HcalDigitizer") << "HCAL HF digis : " << hfResult->size();
503  edm::LogInfo("HcalDigitizer") << "HCAL ZDC digis : " << zdcResult->size();
504  edm::LogInfo("HcalDigitizer") << "HCAL HF QIE10 digis : " << hfQIE10Result->size();
505  edm::LogInfo("HcalDigitizer") << "HCAL HBHE QIE11 digis : " << hbheQIE11Result->size();
506 
507 #ifdef DebugLog
508  std::cout << std::endl;
509  std::cout << "HCAL HBHE digis : " << hbheResult->size() << std::endl;
510  std::cout << "HCAL HO digis : " << hoResult->size() << std::endl;
511  std::cout << "HCAL HF digis : " << hfResult->size() << std::endl;
512  std::cout << "HCAL ZDC digis : " << zdcResult->size() << std::endl;
513  std::cout << "HCAL HF QIE10 digis : " << hfQIE10Result->size() << std::endl;
514  std::cout << "HCAL HBHE QIE11 digis : " << hbheQIE11Result->size() << std::endl;
515 #endif
516 
517  // Step D: Put outputs into event
518  e.put(std::move(hbheResult));
519  e.put(std::move(hoResult));
520  e.put(std::move(hfResult));
521  e.put(std::move(zdcResult));
522  e.put(std::move(hfQIE10Result), "HFQIE10DigiCollection");
523  e.put(std::move(hbheQIE11Result), "HBHEQIE11DigiCollection");
524 
525  if (debugCS_) {
526  std::unique_ptr<CaloSamplesCollection> csResult(new CaloSamplesCollection());
527  // smush together all the results
528  if (theHBHEDigitizer)
529  csResult->insert(
530  csResult->end(), theHBHEDigitizer->getCaloSamples().begin(), theHBHEDigitizer->getCaloSamples().end());
531  if (theHBHEQIE11Digitizer)
532  csResult->insert(csResult->end(),
533  theHBHEQIE11Digitizer->getCaloSamples().begin(),
534  theHBHEQIE11Digitizer->getCaloSamples().end());
535  if (theHODigitizer)
536  csResult->insert(
537  csResult->end(), theHODigitizer->getCaloSamples().begin(), theHODigitizer->getCaloSamples().end());
538  if (theHOSiPMDigitizer)
539  csResult->insert(
540  csResult->end(), theHOSiPMDigitizer->getCaloSamples().begin(), theHOSiPMDigitizer->getCaloSamples().end());
541  if (theHFDigitizer)
542  csResult->insert(
543  csResult->end(), theHFDigitizer->getCaloSamples().begin(), theHFDigitizer->getCaloSamples().end());
544  if (theHFQIE10Digitizer)
545  csResult->insert(
546  csResult->end(), theHFQIE10Digitizer->getCaloSamples().begin(), theHFQIE10Digitizer->getCaloSamples().end());
547  csResult->insert(
548  csResult->end(), theZDCDigitizer->getCaloSamples().begin(), theZDCDigitizer->getCaloSamples().end());
549  e.put(std::move(csResult), "HcalSamples");
550  }
551 
552  if (injectTestHits_) {
553  std::unique_ptr<edm::PCaloHitContainer> pcResult(new edm::PCaloHitContainer());
554  pcResult->insert(pcResult->end(), injectedHits_.begin(), injectedHits_.end());
555  e.put(std::move(pcResult), "HcalHits");
556  }
557 
558 #ifdef DebugLog
559  std::cout << std::endl << "========> HcalDigitizer e.put " << std::endl << std::endl;
560 #endif
561 }

References gather_cfg::cout, debugCS_, MillePedeFileConverter_cfg::e, hbhegeo, hfgeo, hogeo, injectedHits_, injectTestHits_, isHCAL, isZDC, HcalDataFrameContainer< Digi >::MAXSAMPLES, eostools::move(), CaloSimParameters::readoutFrameSize(), HcalSimParameterMap::simParameters(), theHBHEDigitizer, theHBHEQIE11DetIds, theHBHEQIE11Digitizer, theHBHESiPMResponse, theHFDigitizer, theHFQIE10DetIds, theHFQIE10Digitizer, theHODigitizer, theHOSiPMDigitizer, theParameterMap, theZDCDigitizer, and zdcgeo.

Referenced by HcalDigiProducer::finalizeEvent().

◆ initializeEvent()

void HcalDigitizer::initializeEvent ( edm::Event const &  e,
edm::EventSetup const &  c 
)

Produces the EDM products,

Definition at line 305 of file HcalDigitizer.cc.

305  {
306  setup(eventSetup);
307 
308  // get the appropriate gains, noises, & widths for this event
309  const HcalDbService *conditions = &eventSetup.getData(conditionsToken_);
310 
311  theShapes.setDbService(conditions);
312 
313  theHBHEAmplifier->setDbService(conditions);
314  theHFAmplifier->setDbService(conditions);
315  theHOAmplifier->setDbService(conditions);
316  theZDCAmplifier->setDbService(conditions);
317  theHFQIE10Amplifier->setDbService(conditions);
318  theHBHEQIE11Amplifier->setDbService(conditions);
319 
320  theHFQIE10ElectronicsSim->setDbService(conditions);
321  theHBHEQIE11ElectronicsSim->setDbService(conditions);
322 
323  theCoderFactory->setDbService(conditions);
324  theParameterMap.setDbService(conditions);
325 
326  // initialize hits
327  if (theHBHEDigitizer)
328  theHBHEDigitizer->initializeHits();
329  if (theHBHEQIE11Digitizer)
330  theHBHEQIE11Digitizer->initializeHits();
331  if (theHODigitizer)
332  theHODigitizer->initializeHits();
333  if (theHOSiPMDigitizer)
334  theHOSiPMDigitizer->initializeHits();
335  if (theHFQIE10Digitizer)
336  theHFQIE10Digitizer->initializeHits();
337  if (theHFDigitizer)
338  theHFDigitizer->initializeHits();
339  theZDCDigitizer->initializeHits();
340 }

References submitPVValidationJobs::conditions, conditionsToken_, edm::EventSetup::getData(), HcalShapes::setDbService(), HcalSimParameterMap::setDbService(), setup(), theCoderFactory, theHBHEAmplifier, theHBHEDigitizer, theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, theHFAmplifier, theHFDigitizer, theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, theHOAmplifier, theHODigitizer, theHOSiPMDigitizer, theParameterMap, theShapes, theZDCAmplifier, and theZDCDigitizer.

Referenced by HcalDigiProducer::initializeEvent().

◆ setHBHENoiseSignalGenerator()

void HcalDigitizer::setHBHENoiseSignalGenerator ( HcalBaseSignalGenerator *  noiseGenerator)

Definition at line 256 of file HcalDigitizer.cc.

256  {
257  noiseGenerator->setParameterMap(&theParameterMap);
258  noiseGenerator->setElectronicsSim(theHBHEElectronicsSim.get());
259  if (theHBHEDigitizer)
260  theHBHEDigitizer->setNoiseSignalGenerator(noiseGenerator);
261  theHBHEAmplifier->setNoiseSignalGenerator(noiseGenerator);
262 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHBHEAmplifier, theHBHEDigitizer, theHBHEElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setHBHENoiseSignalGenerator().

◆ setHFNoiseSignalGenerator()

void HcalDigitizer::setHFNoiseSignalGenerator ( HcalBaseSignalGenerator *  noiseGenerator)

Definition at line 272 of file HcalDigitizer.cc.

272  {
273  noiseGenerator->setParameterMap(&theParameterMap);
274  noiseGenerator->setElectronicsSim(theHFElectronicsSim.get());
275  if (theHFDigitizer)
276  theHFDigitizer->setNoiseSignalGenerator(noiseGenerator);
277  theHFAmplifier->setNoiseSignalGenerator(noiseGenerator);
278 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHFAmplifier, theHFDigitizer, theHFElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setHFNoiseSignalGenerator().

◆ setHONoiseSignalGenerator()

void HcalDigitizer::setHONoiseSignalGenerator ( HcalBaseSignalGenerator *  noiseGenerator)

Definition at line 288 of file HcalDigitizer.cc.

288  {
289  noiseGenerator->setParameterMap(&theParameterMap);
290  noiseGenerator->setElectronicsSim(theHOElectronicsSim.get());
291  if (theHODigitizer)
292  theHODigitizer->setNoiseSignalGenerator(noiseGenerator);
293  if (theHOSiPMDigitizer)
294  theHOSiPMDigitizer->setNoiseSignalGenerator(noiseGenerator);
295  theHOAmplifier->setNoiseSignalGenerator(noiseGenerator);
296 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHOAmplifier, theHODigitizer, theHOElectronicsSim, theHOSiPMDigitizer, and theParameterMap.

Referenced by HcalDigiProducer::setHONoiseSignalGenerator().

◆ setQIE10NoiseSignalGenerator()

void HcalDigitizer::setQIE10NoiseSignalGenerator ( HcalBaseSignalGenerator *  noiseGenerator)

Definition at line 280 of file HcalDigitizer.cc.

280  {
281  noiseGenerator->setParameterMap(&theParameterMap);
282  noiseGenerator->setElectronicsSim(theHFQIE10ElectronicsSim.get());
283  if (theHFQIE10Digitizer)
284  theHFQIE10Digitizer->setNoiseSignalGenerator(noiseGenerator);
285  theHFQIE10Amplifier->setNoiseSignalGenerator(noiseGenerator);
286 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHFQIE10Amplifier, theHFQIE10Digitizer, theHFQIE10ElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setQIE10NoiseSignalGenerator().

◆ setQIE11NoiseSignalGenerator()

void HcalDigitizer::setQIE11NoiseSignalGenerator ( HcalBaseSignalGenerator *  noiseGenerator)

Definition at line 264 of file HcalDigitizer.cc.

264  {
265  noiseGenerator->setParameterMap(&theParameterMap);
266  noiseGenerator->setElectronicsSim(theHBHEQIE11ElectronicsSim.get());
267  if (theHBHEQIE11Digitizer)
268  theHBHEQIE11Digitizer->setNoiseSignalGenerator(noiseGenerator);
269  theHBHEQIE11Amplifier->setNoiseSignalGenerator(noiseGenerator);
270 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theHBHEQIE11Amplifier, theHBHEQIE11Digitizer, theHBHEQIE11ElectronicsSim, and theParameterMap.

Referenced by HcalDigiProducer::setQIE11NoiseSignalGenerator().

◆ setup()

void HcalDigitizer::setup ( const edm::EventSetup &  es)
private

Definition at line 563 of file HcalDigitizer.cc.

563  {
564  checkGeometry(es);
565 
566  if (agingFlagHB) {
567  m_HBDarkening = &es.getData(m_HBDarkeningToken);
568  }
569  if (agingFlagHE) {
570  m_HEDarkening = &es.getData(m_HEDarkeningToken);
571  }
572 
573  hcalTimeSlew_delay_ = &es.getData(hcalTimeSlew_delay_token_);
574 
575  theHBHEAmplifier->setTimeSlew(hcalTimeSlew_delay_);
576  theHBHEQIE11Amplifier->setTimeSlew(hcalTimeSlew_delay_);
577  theHOAmplifier->setTimeSlew(hcalTimeSlew_delay_);
578  theZDCAmplifier->setTimeSlew(hcalTimeSlew_delay_);
579 }

References agingFlagHB, agingFlagHE, checkGeometry(), edm::EventSetup::getData(), hcalTimeSlew_delay_, hcalTimeSlew_delay_token_, m_HBDarkening, m_HBDarkeningToken, m_HEDarkening, m_HEDarkeningToken, theHBHEAmplifier, theHBHEQIE11Amplifier, theHOAmplifier, and theZDCAmplifier.

Referenced by initializeEvent().

◆ setZDCNoiseSignalGenerator()

void HcalDigitizer::setZDCNoiseSignalGenerator ( HcalBaseSignalGenerator *  noiseGenerator)

Definition at line 298 of file HcalDigitizer.cc.

298  {
299  noiseGenerator->setParameterMap(&theParameterMap);
300  noiseGenerator->setElectronicsSim(theZDCElectronicsSim.get());
301  theZDCDigitizer->setNoiseSignalGenerator(noiseGenerator);
302  theZDCAmplifier->setNoiseSignalGenerator(noiseGenerator);
303 }

References HcalBaseSignalGenerator::setElectronicsSim(), HcalBaseSignalGenerator::setParameterMap(), theParameterMap, theZDCAmplifier, theZDCDigitizer, and theZDCElectronicsSim.

Referenced by HcalDigiProducer::setZDCNoiseSignalGenerator().

◆ updateGeometry()

void HcalDigitizer::updateGeometry ( const edm::EventSetup &  eventSetup)
private

Definition at line 607 of file HcalDigitizer.cc.

607  {
608  const std::vector<DetId> &hbCells = theGeometry->getValidDetIds(DetId::Hcal, HcalBarrel);
609  const std::vector<DetId> &heCells = theGeometry->getValidDetIds(DetId::Hcal, HcalEndcap);
610  const std::vector<DetId> &hoCells = theGeometry->getValidDetIds(DetId::Hcal, HcalOuter);
611  const std::vector<DetId> &hfCells = theGeometry->getValidDetIds(DetId::Hcal, HcalForward);
612  const std::vector<DetId> &zdcCells = theGeometry->getValidDetIds(DetId::Calo, HcalZDCDetId::SubdetectorId);
613  // const std::vector<DetId>& hcalTrigCells =
614  // geometry->getValidDetIds(DetId::Hcal, HcalTriggerTower); const
615  // std::vector<DetId>& hcalCalib = geometry->getValidDetIds(DetId::Calo,
616  // HcalCastorDetId::SubdetectorId);
617  // std::cout<<"HcalDigitizer::CheckGeometry number of cells:
618  // "<<zdcCells.size()<<std::endl;
619  if (zdcCells.empty())
620  zdcgeo = false;
621  if (hbCells.empty() && heCells.empty())
622  hbhegeo = false;
623  if (hoCells.empty())
624  hogeo = false;
625  if (hfCells.empty())
626  hfgeo = false;
627  // combine HB & HE
628 
629  hbheCells = hbCells;
630  if (!killHE_) {
631  hbheCells.insert(hbheCells.end(), heCells.begin(), heCells.end());
632  }
633  // handle mixed QIE8/11 scenario in HBHE
634  buildHBHEQIECells(hbheCells, eventSetup);
635  if (theHBHESiPMResponse)
636  theHBHESiPMResponse->setDetIds(theHBHEQIE11DetIds);
637 
638  if (theHOSiPMDigitizer) {
639  buildHOSiPMCells(hoCells, eventSetup);
640  if (theHOSiPMResponse)
641  theHOSiPMResponse->setDetIds(hoCells);
642  }
643 
644  // handle mixed QIE8/10 scenario in HF
645  buildHFQIECells(hfCells, eventSetup);
646 
647  theZDCDigitizer->setDetIds(zdcCells);
648 
649  // fill test hits collection if desired and empty
650  if (injectTestHits_ && injectedHits_.empty() && !injectedHitsCells_.empty() && !injectedHitsEnergy_.empty()) {
651  // make list of specified cells if desired
652  std::vector<DetId> testCells;
653  if (injectedHitsCells_.size() >= 4) {
654  testCells.reserve(injectedHitsCells_.size() / 4);
655  for (unsigned ic = 0; ic < injectedHitsCells_.size(); ic += 4) {
656  if (ic + 4 > injectedHitsCells_.size())
657  break;
658  testCells.push_back(HcalDetId((HcalSubdetector)injectedHitsCells_[ic],
659  injectedHitsCells_[ic + 1],
660  injectedHitsCells_[ic + 2],
661  injectedHitsCells_[ic + 3]));
662  }
663  } else {
664  int testSubdet = injectedHitsCells_[0];
665  if (testSubdet == HcalBarrel)
666  testCells = hbCells;
667  else if (testSubdet == HcalEndcap)
668  testCells = heCells;
669  else if (testSubdet == HcalForward)
670  testCells = hfCells;
671  else if (testSubdet == HcalOuter)
672  testCells = hoCells;
673  else
674  throw cms::Exception("Configuration") << "Unknown subdet " << testSubdet << " for HCAL test hit injection";
675  }
676  bool useHitTimes = (injectedHitsTime_.size() == injectedHitsEnergy_.size());
677  injectedHits_.reserve(testCells.size() * injectedHitsEnergy_.size());
678  for (unsigned ih = 0; ih < injectedHitsEnergy_.size(); ++ih) {
679  double tmp = useHitTimes ? injectedHitsTime_[ih] : 0.;
680  for (auto &aCell : testCells) {
681  injectedHits_.emplace_back(aCell, injectedHitsEnergy_[ih], tmp);
682  }
683  }
684  }
685 }

References buildHBHEQIECells(), buildHFQIECells(), buildHOSiPMCells(), DetId::Calo, Exception, CaloGeometry::getValidDetIds(), hbheCells, hbhegeo, DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, hfgeo, hogeo, injectedHits_, injectedHitsCells_, injectedHitsEnergy_, injectedHitsTime_, injectTestHits_, killHE_, HcalZDCDetId::SubdetectorId, theGeometry, theHBHEQIE11DetIds, theHBHESiPMResponse, theHOSiPMDigitizer, theHOSiPMResponse, theZDCDigitizer, createJobs::tmp, and zdcgeo.

Referenced by checkGeometry().

Member Data Documentation

◆ agingFlagHB

bool HcalDigitizer::agingFlagHB
private

Definition at line 176 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

◆ agingFlagHE

bool HcalDigitizer::agingFlagHE
private

Definition at line 176 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

◆ conditionsToken_

const edm::ESGetToken<HcalDbService, HcalDbRecord> HcalDigitizer::conditionsToken_
private

Definition at line 76 of file HcalDigitizer.h.

Referenced by initializeEvent().

◆ debugCS_

bool HcalDigitizer::debugCS_
private

Definition at line 167 of file HcalDigitizer.h.

Referenced by finalizeEvent(), and HcalDigitizer().

◆ deliveredLumi

double HcalDigitizer::deliveredLumi
private

Definition at line 175 of file HcalDigitizer.h.

Referenced by darkening(), and HcalDigitizer().

◆ doHFWindow_

bool HcalDigitizer::doHFWindow_
private

Definition at line 165 of file HcalDigitizer.h.

Referenced by accumulateCaloHits().

◆ hbheCells

std::vector<DetId> HcalDigitizer::hbheCells
private

Definition at line 157 of file HcalDigitizer.h.

Referenced by updateGeometry().

◆ hbhegeo

bool HcalDigitizer::hbhegeo
private

Definition at line 163 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

◆ hcalTimeSlew_delay_

const HcalTimeSlew* HcalDigitizer::hcalTimeSlew_delay_
private

Definition at line 181 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

◆ hcalTimeSlew_delay_token_

const edm::ESGetToken<HcalTimeSlew, HcalTimeSlewRecord> HcalDigitizer::hcalTimeSlew_delay_token_
private

Definition at line 80 of file HcalDigitizer.h.

Referenced by setup().

◆ hfgeo

bool HcalDigitizer::hfgeo
private

Definition at line 163 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

◆ hitsProducer_

std::string HcalDigitizer::hitsProducer_
private

Definition at line 171 of file HcalDigitizer.h.

Referenced by accumulate(), and HcalDigitizer().

◆ hogeo

bool HcalDigitizer::hogeo
private

Definition at line 163 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

◆ ignoreTime_

bool HcalDigitizer::ignoreTime_
private

Definition at line 168 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

◆ injectedHits_

std::vector<PCaloHit> HcalDigitizer::injectedHits_
private

Definition at line 186 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

◆ injectedHitsCells_

std::vector<int> HcalDigitizer::injectedHitsCells_
private

Definition at line 185 of file HcalDigitizer.h.

Referenced by updateGeometry().

◆ injectedHitsEnergy_

std::vector<double> HcalDigitizer::injectedHitsEnergy_
private

Definition at line 183 of file HcalDigitizer.h.

Referenced by updateGeometry().

◆ injectedHitsTime_

std::vector<double> HcalDigitizer::injectedHitsTime_
private

Definition at line 184 of file HcalDigitizer.h.

Referenced by updateGeometry().

◆ injectTestHits_

bool HcalDigitizer::injectTestHits_
private

Definition at line 169 of file HcalDigitizer.h.

Referenced by accumulate(), accumulateCaloHits(), finalizeEvent(), and updateGeometry().

◆ isHCAL

bool HcalDigitizer::isHCAL
private

Definition at line 163 of file HcalDigitizer.h.

Referenced by accumulate(), accumulateCaloHits(), and finalizeEvent().

◆ isZDC

bool HcalDigitizer::isZDC
private

Definition at line 163 of file HcalDigitizer.h.

Referenced by accumulate(), accumulateCaloHits(), and finalizeEvent().

◆ killHE_

bool HcalDigitizer::killHE_
private

Definition at line 166 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and updateGeometry().

◆ m_HBDarkening

const HBHEDarkening* HcalDigitizer::m_HBDarkening
private

Definition at line 177 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), darkening(), and setup().

◆ m_HBDarkeningToken

edm::ESGetToken<HBHEDarkening, HBHEDarkeningRecord> HcalDigitizer::m_HBDarkeningToken
private

Definition at line 78 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

◆ m_HEDarkening

const HBHEDarkening* HcalDigitizer::m_HEDarkening
private

Definition at line 178 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), darkening(), and setup().

◆ m_HEDarkeningToken

edm::ESGetToken<HBHEDarkening, HBHEDarkeningRecord> HcalDigitizer::m_HEDarkeningToken
private

Definition at line 79 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setup().

◆ m_HFRecalibration

std::unique_ptr<HFRecalibration> HcalDigitizer::m_HFRecalibration
private

Definition at line 179 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), darkening(), and HcalDigitizer().

◆ mcParamsToken_

edm::ESGetToken<HcalMCParams, HcalMCParamsRcd> HcalDigitizer::mcParamsToken_
private

Definition at line 84 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

◆ qieTypesToken_

const edm::ESGetToken<HcalQIETypes, HcalQIETypesRcd> HcalDigitizer::qieTypesToken_
private

Definition at line 83 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and buildHFQIECells().

◆ testNumbering_

bool HcalDigitizer::testNumbering_
private

Definition at line 164 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), and HcalDigitizer().

◆ theCoderFactory

std::unique_ptr<HcalCoderFactory> HcalDigitizer::theCoderFactory
private

Definition at line 127 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and initializeEvent().

◆ theGeometry

const CaloGeometry* HcalDigitizer::theGeometry
private

Definition at line 87 of file HcalDigitizer.h.

Referenced by checkGeometry(), and updateGeometry().

◆ theGeometryToken

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> HcalDigitizer::theGeometryToken
private

Definition at line 81 of file HcalDigitizer.h.

Referenced by checkGeometry().

◆ theGeometryWatcher_

edm::ESWatcher<CaloGeometryRecord> HcalDigitizer::theGeometryWatcher_
private

Definition at line 85 of file HcalDigitizer.h.

Referenced by checkGeometry().

◆ theHBHEAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHBHEAmplifier
private

Definition at line 119 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setHBHENoiseSignalGenerator(), and setup().

◆ theHBHEDigitizer

std::unique_ptr<HBHEDigitizer> HcalDigitizer::theHBHEDigitizer
private

Definition at line 146 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHBHEQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setHBHENoiseSignalGenerator().

◆ theHBHEElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHBHEElectronicsSim
private

Definition at line 129 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHBHENoiseSignalGenerator().

◆ theHBHEHitFilter

HBHEHitFilter HcalDigitizer::theHBHEHitFilter
private

Definition at line 136 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

◆ theHBHEQIE11Amplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHBHEQIE11Amplifier
private

Definition at line 124 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setQIE11NoiseSignalGenerator(), and setup().

◆ theHBHEQIE11DetIds

std::vector<DetId> HcalDigitizer::theHBHEQIE11DetIds
private

Definition at line 158 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), finalizeEvent(), and updateGeometry().

◆ theHBHEQIE11Digitizer

std::unique_ptr<QIE11Digitizer> HcalDigitizer::theHBHEQIE11Digitizer
private

Definition at line 152 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHBHEQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setQIE11NoiseSignalGenerator().

◆ theHBHEQIE11ElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHBHEQIE11ElectronicsSim
private

Definition at line 134 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setQIE11NoiseSignalGenerator().

◆ theHBHEQIE11HitFilter

HBHEHitFilter HcalDigitizer::theHBHEQIE11HitFilter
private

Definition at line 137 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells(), and HcalDigitizer().

◆ theHBHEQIE8DetIds

std::vector<DetId> HcalDigitizer::theHBHEQIE8DetIds
private

Definition at line 158 of file HcalDigitizer.h.

Referenced by buildHBHEQIECells().

◆ theHBHEResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHBHEResponse
private

Definition at line 109 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

◆ theHBHESiPMResponse

std::unique_ptr<HcalSiPMHitResponse> HcalDigitizer::theHBHESiPMResponse
private

Definition at line 110 of file HcalDigitizer.h.

Referenced by checkGeometry(), finalizeEvent(), HcalDigitizer(), and updateGeometry().

◆ theHFAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHFAmplifier
private

Definition at line 120 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setHFNoiseSignalGenerator().

◆ theHFDigitizer

std::unique_ptr<HFDigitizer> HcalDigitizer::theHFDigitizer
private

Definition at line 149 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHFQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setHFNoiseSignalGenerator().

◆ theHFElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHFElectronicsSim
private

Definition at line 130 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHFNoiseSignalGenerator().

◆ theHFHitFilter

HFHitFilter HcalDigitizer::theHFHitFilter
private

Definition at line 138 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

◆ theHFQIE10Amplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHFQIE10Amplifier
private

Definition at line 123 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setQIE10NoiseSignalGenerator().

◆ theHFQIE10DetIds

std::vector<DetId> HcalDigitizer::theHFQIE10DetIds
private

Definition at line 161 of file HcalDigitizer.h.

Referenced by buildHFQIECells(), and finalizeEvent().

◆ theHFQIE10Digitizer

std::unique_ptr<QIE10Digitizer> HcalDigitizer::theHFQIE10Digitizer
private

Definition at line 151 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHFQIECells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setQIE10NoiseSignalGenerator().

◆ theHFQIE10ElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHFQIE10ElectronicsSim
private

Definition at line 133 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), and setQIE10NoiseSignalGenerator().

◆ theHFQIE10HitFilter

HFHitFilter HcalDigitizer::theHFQIE10HitFilter
private

Definition at line 139 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

◆ theHFQIE10Response

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHFQIE10Response
private

Definition at line 114 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

◆ theHFQIE8DetIds

std::vector<DetId> HcalDigitizer::theHFQIE8DetIds
private

Definition at line 161 of file HcalDigitizer.h.

Referenced by buildHFQIECells().

◆ theHFResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHFResponse
private

Definition at line 113 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

◆ theHOAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theHOAmplifier
private

Definition at line 121 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setHONoiseSignalGenerator(), and setup().

◆ theHODigitizer

std::unique_ptr<HODigitizer> HcalDigitizer::theHODigitizer
private

Definition at line 147 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHOSiPMCells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), and setHONoiseSignalGenerator().

◆ theHOElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theHOElectronicsSim
private

Definition at line 131 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setHONoiseSignalGenerator().

◆ theHOHitFilter

HOHitFilter HcalDigitizer::theHOHitFilter
private

Definition at line 140 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

◆ theHOHPDDetIds

std::vector<DetId> HcalDigitizer::theHOHPDDetIds
private

Definition at line 159 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

◆ theHOResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theHOResponse
private

Definition at line 111 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

◆ theHOSiPMCode

int HcalDigitizer::theHOSiPMCode
private

Definition at line 173 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

◆ theHOSiPMDetIds

std::vector<DetId> HcalDigitizer::theHOSiPMDetIds
private

Definition at line 160 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells().

◆ theHOSiPMDigitizer

std::unique_ptr<HODigitizer> HcalDigitizer::theHOSiPMDigitizer
private

Definition at line 148 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), buildHOSiPMCells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), setHONoiseSignalGenerator(), and updateGeometry().

◆ theHOSiPMHitFilter

HOHitFilter HcalDigitizer::theHOSiPMHitFilter
private

Definition at line 141 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), and HcalDigitizer().

◆ theHOSiPMResponse

std::unique_ptr<HcalSiPMHitResponse> HcalDigitizer::theHOSiPMResponse
private

Definition at line 112 of file HcalDigitizer.h.

Referenced by checkGeometry(), HcalDigitizer(), and updateGeometry().

◆ theIonFeedback

std::unique_ptr<HPDIonFeedbackSim> HcalDigitizer::theIonFeedback
private

Definition at line 126 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

◆ theParameterMap

HcalSimParameterMap HcalDigitizer::theParameterMap
private

Definition at line 106 of file HcalDigitizer.h.

Referenced by buildHOSiPMCells(), finalizeEvent(), HcalDigitizer(), initializeEvent(), setHBHENoiseSignalGenerator(), setHFNoiseSignalGenerator(), setHONoiseSignalGenerator(), setQIE10NoiseSignalGenerator(), setQIE11NoiseSignalGenerator(), and setZDCNoiseSignalGenerator().

◆ theRecNumber

const HcalDDDRecConstants* HcalDigitizer::theRecNumber
private

Definition at line 88 of file HcalDigitizer.h.

Referenced by checkGeometry().

◆ theRecNumberToken

const edm::ESGetToken<HcalDDDRecConstants, HcalRecNumberingRecord> HcalDigitizer::theRecNumberToken
private

Definition at line 82 of file HcalDigitizer.h.

Referenced by checkGeometry().

◆ theRecNumberWatcher_

edm::ESWatcher<HcalRecNumberingRecord> HcalDigitizer::theRecNumberWatcher_
private

Definition at line 86 of file HcalDigitizer.h.

Referenced by checkGeometry().

◆ theRelabeller

std::unique_ptr<HcalHitRelabeller> HcalDigitizer::theRelabeller
private

Definition at line 153 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), checkGeometry(), and HcalDigitizer().

◆ theShapes

HcalShapes HcalDigitizer::theShapes
private

Definition at line 107 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and initializeEvent().

◆ theTimeSlewSim

std::unique_ptr<HcalTimeSlewSim> HcalDigitizer::theTimeSlewSim
private

Definition at line 144 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

◆ theZDCAmplifier

std::unique_ptr<HcalAmplifier> HcalDigitizer::theZDCAmplifier
private

Definition at line 122 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), initializeEvent(), setup(), and setZDCNoiseSignalGenerator().

◆ theZDCDigitizer

std::unique_ptr<ZDCDigitizer> HcalDigitizer::theZDCDigitizer
private

Definition at line 150 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), HcalDigitizer(), initializeEvent(), setZDCNoiseSignalGenerator(), and updateGeometry().

◆ theZDCElectronicsSim

std::unique_ptr<HcalElectronicsSim> HcalDigitizer::theZDCElectronicsSim
private

Definition at line 132 of file HcalDigitizer.h.

Referenced by HcalDigitizer(), and setZDCNoiseSignalGenerator().

◆ theZDCHitFilter

ZDCHitFilter HcalDigitizer::theZDCHitFilter
private

Definition at line 142 of file HcalDigitizer.h.

Referenced by HcalDigitizer().

◆ theZDCResponse

std::unique_ptr<CaloHitResponse> HcalDigitizer::theZDCResponse
private

Definition at line 115 of file HcalDigitizer.h.

Referenced by checkGeometry(), and HcalDigitizer().

◆ topoToken_

const edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> HcalDigitizer::topoToken_
private

Definition at line 77 of file HcalDigitizer.h.

Referenced by accumulate(), buildHBHEQIECells(), buildHFQIECells(), and buildHOSiPMCells().

◆ zdcgeo

bool HcalDigitizer::zdcgeo
private

Definition at line 163 of file HcalDigitizer.h.

Referenced by accumulateCaloHits(), finalizeEvent(), and updateGeometry().

HcalDigitizer::theHFQIE8DetIds
std::vector< DetId > theHFQIE8DetIds
Definition: HcalDigitizer.h:161
edm::ESWatcher::check
bool check(const edm::EventSetup &iSetup)
Definition: ESWatcher.h:57
HcalDigitizer::theHFQIE10Digitizer
std::unique_ptr< QIE10Digitizer > theHFQIE10Digitizer
Definition: HcalDigitizer.h:151
HcalDigitizer::theZDCElectronicsSim
std::unique_ptr< HcalElectronicsSim > theZDCElectronicsSim
Definition: HcalDigitizer.h:132
HcalDigitizer::testNumbering_
bool testNumbering_
Definition: HcalDigitizer.h:164
mps_fire.i
i
Definition: mps_fire.py:428
HcalBaseSignalGenerator::setParameterMap
void setParameterMap(HcalSimParameterMap *map)
Definition: HcalBaseSignalGenerator.h:14
HcalDigitizer::theHBHEResponse
std::unique_ptr< CaloHitResponse > theHBHEResponse
Definition: HcalDigitizer.h:109
edm::ESInputTag
Definition: ESInputTag.h:87
HcalDigitizer::injectedHitsEnergy_
std::vector< double > injectedHitsEnergy_
Definition: HcalDigitizer.h:183
HcalDigitizer::theHOHPDDetIds
std::vector< DetId > theHOHPDDetIds
Definition: HcalDigitizer.h:159
HcalDigitizer::theShapes
HcalShapes theShapes
Definition: HcalDigitizer.h:107
HcalDigitizer::theZDCResponse
std::unique_ptr< CaloHitResponse > theZDCResponse
Definition: HcalDigitizer.h:115
HcalMCParams
Definition: HcalMCParams.h:9
HcalDigitizer::ignoreTime_
bool ignoreTime_
Definition: HcalDigitizer.h:168
HcalCondObjectContainerBase::setTopo
void setTopo(const HcalTopology *topo)
Definition: HcalCondObjectContainerBase.cc:17
QIE8
Definition: HcalQIENum.h:4
HcalDigitizer::killHE_
bool killHE_
Definition: HcalDigitizer.h:166
HcalDigitizer::debugCS_
bool debugCS_
Definition: HcalDigitizer.h:167
CaloSimParameters::readoutFrameSize
int readoutFrameSize() const
for now, the LinearFrames and trhe digis will be one-to-one.
Definition: CaloSimParameters.h:45
HcalDigitizer::topoToken_
const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > topoToken_
Definition: HcalDigitizer.h:77
HcalDigitizer::theHOResponse
std::unique_ptr< CaloHitResponse > theHOResponse
Definition: HcalDigitizer.h:111
HcalDigitizer::qieTypesToken_
const edm::ESGetToken< HcalQIETypes, HcalQIETypesRcd > qieTypesToken_
Definition: HcalDigitizer.h:83
HcalQIENum
HcalQIENum
Definition: HcalQIENum.h:4
HcalDigitizer::theIonFeedback
std::unique_ptr< HPDIonFeedbackSim > theIonFeedback
Definition: HcalDigitizer.h:126
HcalDigitizer::theHFQIE10Response
std::unique_ptr< CaloHitResponse > theHFQIE10Response
Definition: HcalDigitizer.h:114
HcalShapes::setDbService
void setDbService(const HcalDbService *service)
Definition: HcalShapes.h:24
HcalDigitizer::accumulateCaloHits
void accumulateCaloHits(edm::Handle< std::vector< PCaloHit >> const &hcalHits, edm::Handle< std::vector< PCaloHit >> const &zdcHits, int bunchCrossing, CLHEP::HepRandomEngine *, const HcalTopology *h)
Definition: HcalDigitizer.cc:342
HcalDigitizer::injectTestHits_
bool injectTestHits_
Definition: HcalDigitizer.h:169
gather_cfg.cout
cout
Definition: gather_cfg.py:144
HcalTopology
Definition: HcalTopology.h:26
DetId::Hcal
Definition: DetId.h:28
HcalDigitizer::theGeometryWatcher_
edm::ESWatcher< CaloGeometryRecord > theGeometryWatcher_
Definition: HcalDigitizer.h:85
HcalQIEType::getValue
int getValue() const
Definition: HcalQIEType.h:19
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89301
HcalDigitizer::isZDC
bool isZDC
Definition: HcalDigitizer.h:163
HcalDigitizer::theHBHEQIE11ElectronicsSim
std::unique_ptr< HcalElectronicsSim > theHBHEQIE11ElectronicsSim
Definition: HcalDigitizer.h:134
HcalDigitizer::theHBHEQIE11Digitizer
std::unique_ptr< QIE11Digitizer > theHBHEQIE11Digitizer
Definition: HcalDigitizer.h:152
HcalDigitizer::hfgeo
bool hfgeo
Definition: HcalDigitizer.h:163
HcalDigitizer::theGeometry
const CaloGeometry * theGeometry
Definition: HcalDigitizer.h:87
edm::LogInfo
Log< level::Info, false > LogInfo
Definition: MessageLogger.h:125
HcalBarrel
Definition: HcalAssistant.h:33
HODigiCollection
edm::SortedCollection< HODataFrame > HODigiCollection
Definition: HcalDigiCollections.h:21
HcalDigitizer::theHOSiPMDetIds
std::vector< DetId > theHOSiPMDetIds
Definition: HcalDigitizer.h:160
HcalDigitizer::theHOAmplifier
std::unique_ptr< HcalAmplifier > theHOAmplifier
Definition: HcalDigitizer.h:121
HcalDigitizer::theHOSiPMHitFilter
HOHitFilter theHOSiPMHitFilter
Definition: HcalDigitizer.h:141
HcalDigitizer::theHOSiPMResponse
std::unique_ptr< HcalSiPMHitResponse > theHOSiPMResponse
Definition: HcalDigitizer.h:112
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
HcalDigitizer::hbheCells
std::vector< DetId > hbheCells
Definition: HcalDigitizer.h:157
edm::ConsumesCollector::esConsumes
auto esConsumes()
Definition: ConsumesCollector.h:97
edm::Handle
Definition: AssociativeIterator.h:50
HcalSimParameterMap::setDbService
void setDbService(const HcalDbService *service)
Definition: HcalSimParameterMap.cc:57
DetId::Calo
Definition: DetId.h:29
HcalDigitizer::m_HBDarkening
const HBHEDarkening * m_HBDarkening
Definition: HcalDigitizer.h:177
HcalCondObjectContainer::getValues
const Item * getValues(DetId fId, bool throwOnFail=true) const
Definition: HcalCondObjectContainer.h:159
HcalDigitizer::theParameterMap
HcalSimParameterMap theParameterMap
Definition: HcalDigitizer.h:106
HcalDigitizer::theHOElectronicsSim
std::unique_ptr< HcalElectronicsSim > theHOElectronicsSim
Definition: HcalDigitizer.h:131
HcalDigitizer::theHBHEElectronicsSim
std::unique_ptr< HcalElectronicsSim > theHBHEElectronicsSim
Definition: HcalDigitizer.h:129
QIE10DigiCollection
HcalDataFrameContainer< QIE10DataFrame > QIE10DigiCollection
Definition: HcalDigiCollections.h:52
HcalDigitizer::theHBHEQIE11HitFilter
HBHEHitFilter theHBHEQIE11HitFilter
Definition: HcalDigitizer.h:137
DigiDM_cff.doNoise
doNoise
Definition: DigiDM_cff.py:32
DetId
Definition: DetId.h:17
HcalDigitizer::theZDCAmplifier
std::unique_ptr< HcalAmplifier > theZDCAmplifier
Definition: HcalDigitizer.h:122
HcalDigitizer::theHBHEHitFilter
HBHEHitFilter theHBHEHitFilter
Definition: HcalDigitizer.h:136
HcalDigitizer::mcParamsToken_
edm::ESGetToken< HcalMCParams, HcalMCParamsRcd > mcParamsToken_
Definition: HcalDigitizer.h:84
HcalDigitizer::conditionsToken_
const edm::ESGetToken< HcalDbService, HcalDbRecord > conditionsToken_
Definition: HcalDigitizer.h:76
HcalDigitizer::theHFQIE10Amplifier
std::unique_ptr< HcalAmplifier > theHFQIE10Amplifier
Definition: HcalDigitizer.h:123
HcalTestNumbering::unpackHcalIndex
static void unpackHcalIndex(const uint32_t &idx, int &det, int &z, int &depth, int &eta, int &phi, int &lay)
Definition: HcalTestNumbering.cc:18
ZDCDigiCollection
edm::SortedCollection< ZDCDataFrame > ZDCDigiCollection
Definition: HcalDigiCollections.h:26
HcalDataFrameContainer::MAXSAMPLES
static const size_type MAXSAMPLES
Definition: HcalDigiCollections.h:38
DDAxes::z
DataMixerDataOnData_cff.doEmpty
doEmpty
Definition: DataMixerDataOnData_cff.py:54
HcalShapes::HAMAMATSU
Definition: HcalShapes.h:20
edm::ConsumesCollector::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: ConsumesCollector.h:55
HcalOuter
Definition: HcalAssistant.h:35
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5
HcalZDCDetId::SubdetectorId
static const int SubdetectorId
Definition: HcalZDCDetId.h:25
HcalDigitizer::injectedHits_
std::vector< PCaloHit > injectedHits_
Definition: HcalDigitizer.h:186
HcalBaseSignalGenerator::setElectronicsSim
void setElectronicsSim(HcalElectronicsSim *electronicsSim)
Definition: HcalBaseSignalGenerator.h:17
HcalDigitizer::buildHFQIECells
void buildHFQIECells(const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)
Definition: HcalDigitizer.cc:687
HcalDigitizer::agingFlagHB
bool agingFlagHB
Definition: HcalDigitizer.h:176
hcalUnsuppressedDigis_cfi.doTimeSlew
doTimeSlew
Definition: hcalUnsuppressedDigis_cfi.py:20
LEDCalibrationChannels.depth
depth
Definition: LEDCalibrationChannels.py:65
HcalDigitizer::hcalTimeSlew_delay_token_
const edm::ESGetToken< HcalTimeSlew, HcalTimeSlewRecord > hcalTimeSlew_delay_token_
Definition: HcalDigitizer.h:80
HcalDigitizer::theHBHEQIE8DetIds
std::vector< DetId > theHBHEQIE8DetIds
Definition: HcalDigitizer.h:158
HcalDigitizer::theHFQIE10HitFilter
HFHitFilter theHFQIE10HitFilter
Definition: HcalDigitizer.h:139
HcalSimParameterMap::setHOZecotekDetIds
void setHOZecotekDetIds(const std::vector< HcalDetId > &ids)
Definition: HcalSimParameterMap.h:33
LEDCalibrationChannels.ieta
ieta
Definition: LEDCalibrationChannels.py:63
HcalDigitizer::theRelabeller
std::unique_ptr< HcalHitRelabeller > theRelabeller
Definition: HcalDigitizer.h:153
edm::ParameterSet
Definition: ParameterSet.h:47
HcalDigitizer::hbhegeo
bool hbhegeo
Definition: HcalDigitizer.h:163
HcalDigitizer::theHFHitFilter
HFHitFilter theHFHitFilter
Definition: HcalDigitizer.h:138
HcalDigitizer::theRecNumber
const HcalDDDRecConstants * theRecNumber
Definition: HcalDigitizer.h:88
HcalDigitizer::updateGeometry
void updateGeometry(const edm::EventSetup &eventSetup)
Definition: HcalDigitizer.cc:607
HcalShapes::ZECOTEK
Definition: HcalShapes.h:20
HcalCondObjectContainerBase::topo
const HcalTopology * topo() const
Definition: HcalCondObjectContainer.h:22
HcalDigitizer::buildHBHEQIECells
void buildHBHEQIECells(const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)
Definition: HcalDigitizer.cc:723
HcalDigitizer::theTimeSlewSim
std::unique_ptr< HcalTimeSlewSim > theTimeSlewSim
Definition: HcalDigitizer.h:144
HcalDetId
Definition: HcalDetId.h:12
HcalDigitizer::setup
void setup(const edm::EventSetup &es)
Definition: HcalDigitizer.cc:563
HcalDigitizer::theRecNumberToken
const edm::ESGetToken< HcalDDDRecConstants, HcalRecNumberingRecord > theRecNumberToken
Definition: HcalDigitizer.h:82
HcalDigitizer::zdcgeo
bool zdcgeo
Definition: HcalDigitizer.h:163
HcalDigitizer::theHBHEAmplifier
std::unique_ptr< HcalAmplifier > theHBHEAmplifier
Definition: HcalDigitizer.h:119
HcalDigitizer::theHBHEQIE11DetIds
std::vector< DetId > theHBHEQIE11DetIds
Definition: HcalDigitizer.h:158
HcalHitFilter::setDetIds
void setDetIds(const std::vector< DetId > &detIds)
Definition: HcalHitFilter.h:17
HcalQIETypes
Definition: HcalQIETypes.h:17
edm::LogError
Log< level::Error, false > LogError
Definition: MessageLogger.h:123
QIE11DigiCollection
HcalDataFrameContainer< QIE11DataFrame > QIE11DigiCollection
Definition: HcalDigiCollections.h:53
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HcalDigitizer::theHFQIE10DetIds
std::vector< DetId > theHFQIE10DetIds
Definition: HcalDigitizer.h:161
HcalDigitizer::theZDCDigitizer
std::unique_ptr< ZDCDigitizer > theZDCDigitizer
Definition: HcalDigitizer.h:150
HcalDigitizer::darkening
void darkening(std::vector< PCaloHit > &hcalHits)
Definition: HcalDigitizer.cc:819
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:127
HcalDigitizer::injectedHitsCells_
std::vector< int > injectedHitsCells_
Definition: HcalDigitizer.h:185
HcalSubdetector
HcalSubdetector
Definition: HcalAssistant.h:31
HcalForward
Definition: HcalAssistant.h:36
DDAxes::phi
HcalMCParam::signalShape
unsigned int signalShape() const
Definition: HcalMCParam.h:38
HcalDbService
Definition: HcalDbService.h:23
submitPVValidationJobs.conditions
list conditions
Definition: submitPVValidationJobs.py:674
eostools.move
def move(src, dest)
Definition: eostools.py:511
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
CaloGeometry::getValidDetIds
std::vector< DetId > getValidDetIds() const
Get the list of all valid detector ids.
Definition: CaloGeometry.cc:75
HBHEDarkening::degradation
float degradation(float intlumi, int ieta, int lay) const
Definition: HBHEDarkening.cc:98
HcalEndcap
Definition: HcalAssistant.h:34
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:29
HcalDigitizer::theHFResponse
std::unique_ptr< CaloHitResponse > theHFResponse
Definition: HcalDigitizer.h:113
HcalDigitizer::theGeometryToken
const edm::ESGetToken< CaloGeometry, CaloGeometryRecord > theGeometryToken
Definition: HcalDigitizer.h:81
HcalDigitizer::theZDCHitFilter
ZDCHitFilter theZDCHitFilter
Definition: HcalDigitizer.h:142
HcalDigitizer::theHBHESiPMResponse
std::unique_ptr< HcalSiPMHitResponse > theHBHESiPMResponse
Definition: HcalDigitizer.h:110
HcalDigitizer::theHODigitizer
std::unique_ptr< HODigitizer > theHODigitizer
Definition: HcalDigitizer.h:147
Exception
Definition: hltDiff.cc:245
HcalDigitizer::doHFWindow_
bool doHFWindow_
Definition: HcalDigitizer.h:165
HcalDigitizer::theHFAmplifier
std::unique_ptr< HcalAmplifier > theHFAmplifier
Definition: HcalDigitizer.h:120
HcalSimParameterMap::setHOHamamatsuDetIds
void setHOHamamatsuDetIds(const std::vector< HcalDetId > &ids)
Definition: HcalSimParameterMap.h:34
edm::PCaloHitContainer
std::vector< PCaloHit > PCaloHitContainer
Definition: PCaloHitContainer.h:8
HcalDigitizer::m_HBDarkeningToken
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > m_HBDarkeningToken
Definition: HcalDigitizer.h:78
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
HcalDigitizer::hogeo
bool hogeo
Definition: HcalDigitizer.h:163
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
HcalDigitizer::theCoderFactory
std::unique_ptr< HcalCoderFactory > theCoderFactory
Definition: HcalDigitizer.h:127
HcalDigitizer::theHOSiPMCode
int theHOSiPMCode
Definition: HcalDigitizer.h:173
HcalDigitizer::theHBHEDigitizer
std::unique_ptr< HBHEDigitizer > theHBHEDigitizer
Definition: HcalDigitizer.h:146
HcalDigitizer::m_HFRecalibration
std::unique_ptr< HFRecalibration > m_HFRecalibration
Definition: HcalDigitizer.h:179
HcalDigitizer::injectedHitsTime_
std::vector< double > injectedHitsTime_
Definition: HcalDigitizer.h:184
HcalDigitizer::theHFQIE10ElectronicsSim
std::unique_ptr< HcalElectronicsSim > theHFQIE10ElectronicsSim
Definition: HcalDigitizer.h:133
HcalDigitizer::m_HEDarkening
const HBHEDarkening * m_HEDarkening
Definition: HcalDigitizer.h:178
HcalDigitizer::theHOHitFilter
HOHitFilter theHOHitFilter
Definition: HcalDigitizer.h:140
HcalCoderFactory::DB
Definition: HcalCoderFactory.h:10
HFDigiCollection
edm::SortedCollection< HFDataFrame > HFDigiCollection
Definition: HcalDigiCollections.h:22
HcalDigitizer::m_HEDarkeningToken
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > m_HEDarkeningToken
Definition: HcalDigitizer.h:79
hcalUnsuppressedDigis_cfi.minFCToDelay
minFCToDelay
Definition: hcalUnsuppressedDigis_cfi.py:29
HcalDigitizer::theRecNumberWatcher_
edm::ESWatcher< HcalRecNumberingRecord > theRecNumberWatcher_
Definition: HcalDigitizer.h:86
HcalDigitizer::theHFElectronicsSim
std::unique_ptr< HcalElectronicsSim > theHFElectronicsSim
Definition: HcalDigitizer.h:130
HcalDigitizer::isHCAL
bool isHCAL
Definition: HcalDigitizer.h:163
CaloSamplesCollection
std::vector< CaloSamples > CaloSamplesCollection
Definition: CaloSamples.h:99
HBHEDigiCollection
edm::SortedCollection< HBHEDataFrame > HBHEDigiCollection
Definition: HcalDigiCollections.h:20
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
HcalDigitizer::hitsProducer_
std::string hitsProducer_
Definition: HcalDigitizer.h:171
HcalDigitizer::deliveredLumi
double deliveredLumi
Definition: HcalDigitizer.h:175
QIE11
Definition: HcalQIENum.h:4
HcalDigitizer::theHOSiPMDigitizer
std::unique_ptr< HODigitizer > theHOSiPMDigitizer
Definition: HcalDigitizer.h:148
HcalSimParameterMap::simParameters
const CaloSimParameters & simParameters(const DetId &id) const override
Definition: HcalSimParameterMap.cc:30
HcalDigitizer::checkGeometry
void checkGeometry(const edm::EventSetup &eventSetup)
Definition: HcalDigitizer.cc:581
TauDecayModes.dec
dec
Definition: TauDecayModes.py:142
HcalDigitizer::hcalTimeSlew_delay_
const HcalTimeSlew * hcalTimeSlew_delay_
Definition: HcalDigitizer.h:181
cuy.ii
ii
Definition: cuy.py:589
edm::InputTag
Definition: InputTag.h:15
HcalDigitizer::agingFlagHE
bool agingFlagHE
Definition: HcalDigitizer.h:176
HcalDigitizer::theHBHEQIE11Amplifier
std::unique_ptr< HcalAmplifier > theHBHEQIE11Amplifier
Definition: HcalDigitizer.h:124
QIE10
Definition: HcalQIENum.h:4
HcalDigitizer::buildHOSiPMCells
void buildHOSiPMCells(const std::vector< DetId > &allCells, const edm::EventSetup &eventSetup)
Definition: HcalDigitizer.cc:764
HcalDigitizer::theHFDigitizer
std::unique_ptr< HFDigitizer > theHFDigitizer
Definition: HcalDigitizer.h:149
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
Generated for CMSSW Reference Manual by doxygen 1.8.16