CMS 3D CMS Logo

DataMixingHcalDigiWorker.cc
Go to the documentation of this file.
1 // File: DataMixingHcalDigiWorker.cc
2 // Description: see DataMixingHcalDigiWorker.h
3 // Author: Mike Hildreth, University of Notre Dame
4 //
5 //--------------------------------------------
6 
7 #include <map>
8 #include <memory>
18 // calibration headers, for future reference
23 //
24 //
26 
27 using namespace std;
28 
29 namespace {
30 
31  typedef std::multimap<DetId, CaloSamples> HcalDigiMap;
32 
33  template <class DIGI>
34  void convertFc2adc (const CaloSamples& fC, const HcalDbService& conditions, DIGI& digi, int capIdOffset = 0) {
35  HcalDetId id = fC.id();
36  const HcalQIECoder* channelCoder = conditions.getHcalCoder (id);
37  const HcalQIEShape* shape = conditions.getHcalShape (channelCoder);
38  HcalCoderDb coder (*channelCoder, *shape);
39  coder.fC2adc(fC, digi, capIdOffset);
40  }
41 
42  template <class DIGI>
43  void convertAdc2fChelper (const DIGI& digi, const HcalDbService& conditions, CaloSamples& fC, const HcalDetId& id) {
44  const HcalCalibrations& calib = conditions.getHcalCalibrations(id);
45  for (int i = 0; i < digi.size(); ++i) {
46  int capId (digi.sample(i).capid());
47  fC[i] -= calib.pedestal (capId);
48  }
49  }
50 
51  template <>
52  void convertAdc2fChelper<QIE10DataFrame> (const QIE10DataFrame& digi, const HcalDbService& conditions, CaloSamples& fC, const HcalDetId& id) {
53  const HcalCalibrations& calib = conditions.getHcalCalibrations(id);
54  for (int i = 0; i < digi.samples(); ++i) {
55  int capId (digi[i].capid());
56  fC[i] -= calib.pedestal (capId);
57  }
58  }
59 
60  template <>
61  void convertAdc2fChelper<QIE11DataFrame> (const QIE11DataFrame& digi, const HcalDbService& conditions, CaloSamples& fC, const HcalDetId& id) {
62  const HcalCalibrations& calib = conditions.getHcalCalibrations(id);
63  for (int i = 0; i < digi.samples(); ++i) {
64  int capId (digi[i].capid());
65  fC[i] -= calib.pedestal (capId);
66  }
67  }
68 
69  template <class DIGI>
70  void convertAdc2fC (const DIGI& digi, const HcalDbService& conditions, bool keepPedestals, CaloSamples& fC) {
71  HcalDetId id (digi.id());
72  const HcalQIECoder* channelCoder = conditions.getHcalCoder (id);
73  const HcalQIEShape* shape = conditions.getHcalShape (channelCoder);
74  HcalCoderDb coder (*channelCoder, *shape);
75  coder.adc2fC(digi, fC);
76  if (!keepPedestals) { // subtract pedestals
77  convertAdc2fChelper(digi,conditions,fC,id);
78  }
79  }
80 
81  template <class DIGIS>
82  void convertHcalDigis (const DIGIS& digis, const HcalDbService& conditions, bool keepPedestals, HcalDigiMap& map) {
83  for (auto digi = digis.begin(); digi != digis.end(); ++digi) {
84  CaloSamples fC;
85  convertAdc2fC (*digi, conditions, keepPedestals, fC);
86  if (!keepPedestals && map.find(digi->id()) == map.end()) {
87  edm::LogWarning("DataMixingHcalDigiWorker")<<"No signal hits found for HCAL cell "<<digi->id()<<" Pedestals may be lost for mixed hit";
88  }
89  map.insert(HcalDigiMap::value_type (digi->id(), fC));
90  }
91  }
92 
93  template <>
94  void convertHcalDigis<QIE10DigiCollection> (const QIE10DigiCollection& digis, const HcalDbService& conditions, bool keepPedestals, HcalDigiMap& map) {
95  for (auto digiItr = digis.begin(); digiItr != digis.end(); ++digiItr) {
96  QIE10DataFrame digi(*digiItr);
97  CaloSamples fC;
98  convertAdc2fC (digi, conditions, keepPedestals, fC);
99  if (!keepPedestals && map.find(digi.id()) == map.end()) {
100  edm::LogWarning("DataMixingHcalDigiWorker")<<"No signal hits found for HCAL cell "<<digi.id()<<" Pedestals may be lost for mixed hit";
101  }
102  map.insert(HcalDigiMap::value_type (digi.id(), fC));
103  }
104  }
105 
106  template <>
107  void convertHcalDigis<QIE11DigiCollection> (const QIE11DigiCollection& digis, const HcalDbService& conditions, bool keepPedestals, HcalDigiMap& map) {
108  for (auto digiItr = digis.begin(); digiItr != digis.end(); ++digiItr) {
109  QIE11DataFrame digi(*digiItr);
110  CaloSamples fC;
111  convertAdc2fC (digi, conditions, keepPedestals, fC);
112  if (!keepPedestals && map.find(digi.id()) == map.end()) {
113  edm::LogWarning("DataMixingHcalDigiWorker")<<"No signal hits found for HCAL cell "<<digi.id()<<" Pedestals may be lost for mixed hit";
114  }
115  map.insert(HcalDigiMap::value_type (digi.id(), fC));
116  }
117  }
118 
119  template <class DIGIS>
120  bool convertSignalHcalDigis (const edm::Event &e, const edm::EDGetTokenT<DIGIS>& token,
121  const HcalDbService& conditions, HcalDigiMap& map) {
122  edm::Handle<DIGIS> digis;
123  if (!e.getByToken (token, digis)) return false;
124  convertHcalDigis (*digis, conditions, true, map); // keep pedestals
125  return true;
126  }
127 
128  template <class DIGIS>
129  bool convertPileupHcalDigis (const edm::EventPrincipal& ep,
130  const edm::InputTag& tag, const edm::ModuleCallingContext* mcc,
131  const HcalDbService& conditions, HcalDigiMap& map) {
132  auto digis = edm::getProductByTag<DIGIS>(ep, tag, mcc);
133  if (!digis) return false;
134  convertHcalDigis (*(digis->product()), conditions, false, map); // subtract pedestals
135  return true;
136  }
137 
138  template <class DIGIS>
139  void buildHcalDigisHelper (DIGIS& digis, const DetId& formerID, CaloSamples& resultSample, const HcalDbService& conditions){
140  // make new digi
141  digis.push_back(typename DIGIS::value_type(formerID));
142  convertFc2adc (resultSample, conditions, digis.back(), 0); // FR guess: simulation starts with 0
143  }
144 
145  template <>
146  void buildHcalDigisHelper<QIE10DigiCollection> (QIE10DigiCollection& digis, const DetId& formerID, CaloSamples& resultSample, const HcalDbService& conditions){
147  // make new digi
148  digis.push_back(formerID.rawId());
149  QIE10DataFrame digi( digis.back() );
150  convertFc2adc (resultSample, conditions, digi, 0); // FR guess: simulation starts with 0
151  }
152 
153  template <>
154  void buildHcalDigisHelper<QIE11DigiCollection> (QIE11DigiCollection& digis, const DetId& formerID, CaloSamples& resultSample, const HcalDbService& conditions){
155  // make new digi
156  digis.push_back(formerID.rawId());
157  QIE11DataFrame digi( digis.back() );
158  convertFc2adc (resultSample, conditions, digi, 0); // FR guess: simulation starts with 0
159  }
160 
161  template <class DIGIS>
162  std::unique_ptr<DIGIS> buildHcalDigis (const HcalDigiMap& map, const HcalDbService& conditions) {
163  std::unique_ptr<DIGIS> digis( new DIGIS );
164  // loop over the maps we have, re-making individual hits or digis if necessary.
165  DetId formerID = 0;
166  CaloSamples resultSample;
167 
168  for(auto hit = map.begin(); hit != map.end(); ++hit) {
169  DetId currentID = hit->first;
170  const CaloSamples& hitSample = hit->second;
171 
172  if (currentID == formerID) { // accumulating hits
173  //loop over digi samples in each CaloSample
174  unsigned int sizenew = (hitSample).size();
175  unsigned int sizeold = resultSample.size();
176  if (sizenew > sizeold) { // extend sample
177  resultSample.setSize (sizenew);
178  }
179  for(unsigned int isamp = 0; isamp<sizenew; isamp++) { // add new values
180  resultSample[isamp] += hitSample[isamp]; // for debugging below
181  }
182  }
183  auto hit1 = hit;
184  bool lastEntry = (++hit1 == map.end());
185  if (currentID != formerID || lastEntry) { // store current digi
186  if (formerID>0 || lastEntry) {
187  // make new digi
188  buildHcalDigisHelper(*digis,formerID,resultSample,conditions);
189  }
190  //reset pointers for next iteration
191  formerID = currentID;
192  resultSample = hitSample;
193  }
194  }
195  return digis;
196  }
197 
198 
199 
200 } // namespace {}
201 
202 namespace edm
203 {
204 
205  // Virtual constructor
206 
207  DataMixingHcalDigiWorker::DataMixingHcalDigiWorker() { }
208 
209  // Constructor
210  DataMixingHcalDigiWorker::DataMixingHcalDigiWorker(const edm::ParameterSet& ps, edm::ConsumesCollector && iC) :
211  label_(ps.getParameter<std::string>("Label"))
212  {
213 
214  // get the subdetector names
215  // this->getSubdetectorNames(); //something like this may be useful to check what we are supposed to do...
216 
217  // declare the products to produce
218 
219  // Hcal
220 
221  HBHEdigiCollectionSig_ = ps.getParameter<edm::InputTag>("HBHEdigiCollectionSig");
222  HOdigiCollectionSig_ = ps.getParameter<edm::InputTag>("HOdigiCollectionSig");
223  HFdigiCollectionSig_ = ps.getParameter<edm::InputTag>("HFdigiCollectionSig");
224  ZDCdigiCollectionSig_ = ps.getParameter<edm::InputTag>("ZDCdigiCollectionSig");
225  QIE10digiCollectionSig_ = ps.getParameter<edm::InputTag>("QIE10digiCollectionSig");
226  QIE11digiCollectionSig_ = ps.getParameter<edm::InputTag>("QIE11digiCollectionSig");
227 
228  HBHEPileInputTag_ = ps.getParameter<edm::InputTag>("HBHEPileInputTag");
229  HOPileInputTag_ = ps.getParameter<edm::InputTag>("HOPileInputTag");
230  HFPileInputTag_ = ps.getParameter<edm::InputTag>("HFPileInputTag");
231  ZDCPileInputTag_ = ps.getParameter<edm::InputTag>("ZDCPileInputTag");
232  QIE10PileInputTag_ = ps.getParameter<edm::InputTag>("QIE10PileInputTag");
233  QIE11PileInputTag_ = ps.getParameter<edm::InputTag>("QIE11PileInputTag");
234 
240 
246 
247  DoZDC_ = false;
248  if(ZDCPileInputTag_.label() != "") DoZDC_ = true;
249 
250  if(DoZDC_) {
253  }
254 
255 
256  HBHEDigiCollectionDM_ = ps.getParameter<std::string>("HBHEDigiCollectionDM");
257  HODigiCollectionDM_ = ps.getParameter<std::string>("HODigiCollectionDM");
258  HFDigiCollectionDM_ = ps.getParameter<std::string>("HFDigiCollectionDM");
259  ZDCDigiCollectionDM_ = ps.getParameter<std::string>("ZDCDigiCollectionDM");
260  QIE10DigiCollectionDM_ = ps.getParameter<std::string>("QIE10DigiCollectionDM");
261  QIE11DigiCollectionDM_ = ps.getParameter<std::string>("QIE11DigiCollectionDM");
262 
263 
264  }
265 
266  // Virtual destructor needed.
268  }
269 
271  // Calibration stuff will look like this:
272  // get conditions
273  edm::ESHandle<HcalDbService> conditions;
274  ES.get<HcalDbRecord>().get(conditions);
275 
276 
277  // fill in maps of hits
278 
279  LogInfo("DataMixingHcalDigiWorker")<<"===============> adding MC signals for "<<e.id();
280  convertSignalHcalDigis<HBHEDigiCollection> (e, HBHEDigiToken_, *conditions, HBHEDigiStorage_);
281  convertSignalHcalDigis<HODigiCollection> (e, HODigiToken_, *conditions, HODigiStorage_);
282  convertSignalHcalDigis<HFDigiCollection> (e, HFDigiToken_, *conditions, HFDigiStorage_);
283  convertSignalHcalDigis<QIE10DigiCollection> (e, QIE10DigiToken_, *conditions, QIE10DigiStorage_);
284  convertSignalHcalDigis<QIE11DigiCollection> (e, QIE11DigiToken_, *conditions, QIE11DigiStorage_);
285 
286 
287 
288  // ZDC next
289 
290  if(DoZDC_){
291 
292  Handle< ZDCDigiCollection > pZDCDigis;
293 
294  const ZDCDigiCollection* ZDCDigis = nullptr;
295 
296  if( e.getByToken( ZDCDigiToken_, pZDCDigis) ) {
297  ZDCDigis = pZDCDigis.product(); // get a ptr to the product
298 #ifdef DEBUG
299  LogDebug("DataMixingHcalDigiWorker") << "total # ZDC digis: " << ZDCDigis->size();
300 #endif
301  }
302 
303 
304  if (ZDCDigis)
305  {
306  // loop over digis, storing them in a map so we can add pileup later
307  for(ZDCDigiCollection::const_iterator it = ZDCDigis->begin(); it != ZDCDigis->end(); ++it) {
308 
309  // calibration, for future reference: (same block for all Hcal types) ZDC is different
310  HcalZDCDetId cell = it->id();
311  // const HcalCalibrations& calibrations=conditions->getHcalCalibrations(cell);
312  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
313  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder); // this one is generic
314  HcalCoderDb coder (*channelCoder, *shape);
315 
316  CaloSamples tool;
317  coder.adc2fC((*it),tool);
318 
319  ZDCDigiStorage_.insert(ZDCDigiMap::value_type( ( it->id() ), tool ));
320 
321 #ifdef DEBUG
322  // Commented out because this does not compile anymore
323  // LogDebug("DataMixingHcalDigiWorker") << "processed ZDCDigi with rawId: "
324  // << it->id() << "\n"
325  // << " digi energy: " << it->energy();
326 #endif
327 
328  }
329  }
330  }
331 
332  } // end of addHCalSignals
333 
334  void DataMixingHcalDigiWorker::addHcalPileups(const int bcr, const EventPrincipal *ep, unsigned int eventNr,const edm::EventSetup& ES,
335  ModuleCallingContext const* mcc) {
336 
337  LogDebug("DataMixingHcalDigiWorker") <<"\n===============> adding pileups from event "<<ep->id()<<" for bunchcrossing "<<bcr;
338 
339  // get conditions
340  edm::ESHandle<HcalDbService> conditions;
341  ES.get<HcalDbRecord>().get(conditions);
342 
343  convertPileupHcalDigis<HBHEDigiCollection> (*ep, HBHEPileInputTag_, mcc, *conditions, HBHEDigiStorage_);
344  convertPileupHcalDigis<HODigiCollection> (*ep, HOPileInputTag_, mcc, *conditions, HODigiStorage_);
345  convertPileupHcalDigis<HFDigiCollection> (*ep, HFPileInputTag_, mcc, *conditions, HFDigiStorage_);
346  convertPileupHcalDigis<QIE10DigiCollection> (*ep, QIE10PileInputTag_, mcc, *conditions, QIE10DigiStorage_);
347  convertPileupHcalDigis<QIE11DigiCollection> (*ep, QIE11PileInputTag_, mcc, *conditions, QIE11DigiStorage_);
348 
349 
350  // ZDC Next
351 
352  if(DoZDC_) {
353 
354 
355  std::shared_ptr<Wrapper<ZDCDigiCollection> const> ZDCDigisPTR = getProductByTag<ZDCDigiCollection>(*ep, ZDCPileInputTag_, mcc);
356 
357  if(ZDCDigisPTR ) {
358 
359  const ZDCDigiCollection* ZDCDigis = const_cast< ZDCDigiCollection * >(ZDCDigisPTR->product());
360 
361  LogDebug("DataMixingHcalDigiWorker") << "total # ZDC digis: " << ZDCDigis->size();
362 
363  // loop over digis, adding these to the existing maps
364  for(ZDCDigiCollection::const_iterator it = ZDCDigis->begin(); it != ZDCDigis->end(); ++it) {
365 
366  // calibration, for future reference: (same block for all Hcal types) ZDC is different
367  HcalZDCDetId cell = it->id();
368  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
369  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder); // this one is generic
370  HcalCoderDb coder (*channelCoder, *shape);
371 
372  CaloSamples tool;
373  coder.adc2fC((*it),tool);
374 
375  ZDCDigiStorage_.insert(ZDCDigiMap::value_type( (it->id()), tool ));
376 
377 #ifdef DEBUG
378  // Commented out because this does not compile anymore
379  // LogDebug("DataMixingHcalDigiWorker") << "processed ZDCDigi with rawId: "
380  // << it->id() << "\n"
381  // << " digi energy: " << it->energy();
382 #endif
383  }
384  }
385  }
386 
387 
388  }
389 
391  edm::ESHandle<HcalDbService> conditions;
392  ES.get<HcalDbRecord>().get(conditions);
393 
394  // collection of digis to put in the event
395  std::unique_ptr< HBHEDigiCollection > HBHEdigis = buildHcalDigis<HBHEDigiCollection> (HBHEDigiStorage_, *conditions);
396  std::unique_ptr< HODigiCollection > HOdigis = buildHcalDigis<HODigiCollection> (HODigiStorage_, *conditions);
397  std::unique_ptr< HFDigiCollection > HFdigis = buildHcalDigis<HFDigiCollection> (HFDigiStorage_, *conditions);
398  std::unique_ptr< QIE10DigiCollection > QIE10digis = buildHcalDigis<QIE10DigiCollection> (QIE10DigiStorage_, *conditions);
399  std::unique_ptr< QIE11DigiCollection > QIE11digis = buildHcalDigis<QIE11DigiCollection> (QIE11DigiStorage_, *conditions);
400  std::unique_ptr< ZDCDigiCollection > ZDCdigis( new ZDCDigiCollection );
401 
402  // loop over the maps we have, re-making individual hits or digis if necessary.
403  DetId formerID = 0;
404  DetId currentID;
405 
406  double fC_new;
407  double fC_old;
408  double fC_sum;
409 
410 
411  // ZDC next...
412 
413  // loop over the maps we have, re-making individual hits or digis if necessary.
414  formerID = 0;
415  CaloSamples ZDC_old;
416 
417  ZDCDigiMap::const_iterator iZDCchk;
418 
419  for(ZDCDigiMap::const_iterator iZDC = ZDCDigiStorage_.begin(); iZDC != ZDCDigiStorage_.end(); ++iZDC) {
420 
421  currentID = iZDC->first;
422 
423  if (currentID == formerID) { // we have to add these digis together
424 
425  //loop over digi samples in each CaloSample
426  unsigned int sizenew = (iZDC->second).size();
427  unsigned int sizeold = ZDC_old.size();
428 
429  unsigned int max_samp = std::max(sizenew, sizeold);
430 
431  CaloSamples ZDC_bigger(currentID,max_samp);
432 
433  bool usenew = false;
434 
435  if(sizenew > sizeold) usenew = true;
436 
437  // samples from different events can be of different lengths - sum all
438  // that overlap.
439 
440  for(unsigned int isamp = 0; isamp<max_samp; isamp++) {
441  if(isamp < sizenew) {
442  fC_new = (iZDC->second)[isamp];
443  }
444  else { fC_new = 0;}
445 
446  if(isamp < sizeold) {
447  fC_old = ZDC_old[isamp];
448  }
449  else { fC_old = 0;}
450 
451  // add values
452  fC_sum = fC_new + fC_old;
453 
454  if(usenew) {ZDC_bigger[isamp] = fC_sum; }
455  else { ZDC_old[isamp] = fC_sum; } // overwrite old sample, adding new info
456 
457  }
458  if(usenew) ZDC_old = ZDC_bigger; // save new, larger sized sample in "old" slot
459 
460  }
461  else {
462  if(formerID>0) {
463  // make new digi
464  ZDCdigis->push_back(ZDCDataFrame(formerID));
465 
466  // set up information to convert back
467 
468  HcalZDCDetId cell = ZDC_old.id();
469  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
470  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder); // this one is generic
471  HcalCoderDb coder (*channelCoder, *shape);
472 
473  unsigned int sizeold = ZDC_old.size();
474  for(unsigned int isamp = 0; isamp<sizeold; isamp++) {
475  coder.fC2adc(ZDC_old,(ZDCdigis->back()), 1 ); // as per simulation, capid=1
476  }
477  }
478  //save pointers for next iteration
479  formerID = currentID;
480  ZDC_old = iZDC->second;
481  }
482 
483  iZDCchk = iZDC;
484  if((++iZDCchk) == ZDCDigiStorage_.end()) { //make sure not to lose the last one
485  // make new digi
486  ZDCdigis->push_back(ZDCDataFrame(currentID));
487 
488  // set up information to convert back
489 
490  HcalZDCDetId cell = (iZDC->second).id();
491  const HcalQIECoder* channelCoder = conditions->getHcalCoder (cell);
492  const HcalQIEShape* shape = conditions->getHcalShape (channelCoder); // this one is generic
493  HcalCoderDb coder (*channelCoder, *shape);
494 
495  unsigned int sizeold = (iZDC->second).size();
496  for(unsigned int isamp = 0; isamp<sizeold; isamp++) {
497  coder.fC2adc(ZDC_old,(ZDCdigis->back()), 1 ); // as per simulation, capid=1
498  }
499  }
500  }
501 
502 
503 
504  //done merging
505 
506  // put the collection of recunstructed hits in the event
507  LogInfo("DataMixingHcalDigiWorker") << "total # HBHE Merged digis: " << HBHEdigis->size() ;
508  LogInfo("DataMixingHcalDigiWorker") << "total # HO Merged digis: " << HOdigis->size() ;
509  LogInfo("DataMixingHcalDigiWorker") << "total # HF Merged digis: " << HFdigis->size() ;
510  LogInfo("DataMixingHcalDigiWorker") << "total # QIE10 Merged digis: " << QIE10digis->size() ;
511  LogInfo("DataMixingHcalDigiWorker") << "total # QIE11 Merged digis: " << QIE11digis->size() ;
512  LogInfo("DataMixingHcalDigiWorker") << "total # ZDC Merged digis: " << ZDCdigis->size() ;
513 
514 
515  e.put(std::move(HBHEdigis), HBHEDigiCollectionDM_);
516  e.put(std::move(HOdigis), HODigiCollectionDM_);
517  e.put(std::move(HFdigis), HFDigiCollectionDM_);
518  e.put(std::move(QIE10digis), QIE10DigiCollectionDM_);
519  e.put(std::move(QIE11digis), QIE11DigiCollectionDM_);
520  e.put(std::move(ZDCdigis), ZDCDigiCollectionDM_);
521 
522  // clear local storage after this event
523  HBHEDigiStorage_.clear();
524  HODigiStorage_.clear();
525  HFDigiStorage_.clear();
526  QIE10DigiStorage_.clear();
527  QIE11DigiStorage_.clear();
528  ZDCDigiStorage_.clear();
529 
530  }
531 
532 } //edm
#define LogDebug(id)
size
Write out results.
T getParameter(std::string const &) const
OrphanHandle< PROD > put(std::unique_ptr< PROD > product)
Put a new product.
Definition: Event.h:136
edm::EDGetTokenT< HBHEDigiCollection > HBHEDigiPToken_
edm::EDGetTokenT< HODigiCollection > HODigiToken_
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:519
edm::EDGetTokenT< ZDCDigiCollection > ZDCDigiToken_
void setSize(unsigned int size)
Definition: CaloSamples.h:55
edm::EDGetTokenT< HODigiCollection > HODigiPToken_
EventID const & id() const
std::vector< ZDCDataFrame >::const_iterator const_iterator
void fC2adc(const CaloSamples &clf, HBHEDataFrame &df, int fCapIdOffset) const override
Definition: HcalCoderDb.cc:76
double pedestal(int fCapId) const
get pedestal for capid=0..3
void addHcalPileups(const int bcr, const edm::EventPrincipal *, unsigned int EventId, const edm::EventSetup &ES, ModuleCallingContext const *)
edm::EDGetTokenT< ZDCDigiCollection > ZDCDigiPToken_
void adc2fC(const HBHEDataFrame &df, CaloSamples &lf) const override
Definition: HcalCoderDb.cc:68
edm::EDGetTokenT< HFDigiCollection > HFDigiPToken_
void putHcal(edm::Event &e, const edm::EventSetup &ES)
const_iterator end() const
Definition: DetId.h:18
T const * product() const
Definition: Handle.h:81
int size() const
get the size
Definition: CaloSamples.h:24
const T & get() const
Definition: EventSetup.h:59
const HcalQIECoder * getHcalCoder(const HcalGenericDetId &fId) const
edm::EDGetTokenT< HFDigiCollection > HFDigiToken_
const HcalQIEShape * getHcalShape(const HcalGenericDetId &fId) const
std::string const & label() const
Definition: InputTag.h:36
edm::EDGetTokenT< QIE11DigiCollection > QIE11DigiToken_
edm::EventID id() const
Definition: EventBase.h:60
HLT enums.
size_type size() const
DetId id() const
get the (generic) id
Definition: CaloSamples.h:21
edm::EDGetTokenT< QIE11DigiCollection > QIE11DigiPToken_
const HcalCalibrations & getHcalCalibrations(const HcalGenericDetId &fId) const
void addHcalSignals(const edm::Event &e, const edm::EventSetup &ES)
edm::EDGetTokenT< QIE10DigiCollection > QIE10DigiToken_
edm::EDGetTokenT< QIE10DigiCollection > QIE10DigiPToken_
def move(src, dest)
Definition: eostools.py:510
const_iterator begin() const
edm::EDGetTokenT< HBHEDigiCollection > HBHEDigiToken_