ATLAS Offline Software
CalibHitToCaloCell.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //*****************************************************************************
6 // Filename : CalibHitToCaloCell.cxx
7 //
8 // Author : Gia gia.khoriauli@cern.ch
9 // Created : March, 2005
10 //
11 // DESCRIPTION:
12 // Algorithm to make CaloCell from CaloCalibrationHit
13 //
14 // This algorithm creates two kinds of CaloCell from CalibHits by default.
15 // One is CaloCells with CalibHit TOTAL energy
16 // Second is CaloCels with CalibHit VISIBLE energy
17 //
18 // However, if one declares the names of the appropriate
19 // CaloCellContainers the CaloCells with either EM or NONEM energy
20 // can be created and stored also.
21 //
22 //*****************************************************************************
23 
24 // Calo include
25 #include "CaloIdentifier/CaloDM_ID.h"
26 #include "CaloIdentifier/CaloCell_ID.h"
27 #include "CaloIdentifier/CaloGain.h"
28 #include "CaloEvent/CaloCell.h"
29 #include "CaloSimEvent/CaloCalibrationHitContainer.h"
30 #include "CaloEvent/CaloCellContainer.h"
31 #include "CaloDetDescr/CaloDetDescrManager.h"
32 #include "CaloDetDescr/CaloDetDescrElement.h"
33 #include "CaloCalibHitRec/CalibHitToCaloCell.h"
34 
35 // Tile includes
36 #include "TileEvent/TileCell.h"
37 
38 // LAr includes
39 #include "LArRecEvent/LArCell.h"
40 
41 
42 CalibHitToCaloCell::CalibHitToCaloCell(const std::string& name, ISvcLocator* pSvcLocator)
43  : AthAlgorithm(name, pSvcLocator),
44  m_tileActiveHitCnt ("TileCalibHitActiveCell"),
45  m_tileInactiveHitCnt ("TileCalibHitInactiveCell"),
46  m_tileDMHitCnt ("TileCalibHitDeadMaterial"),
47  m_larInactHitCnt ("LArCalibrationHitInactive"),
48  m_larActHitCnt ("LArCalibrationHitActive"),
49  m_larDMHitCnt ("LArCalibrationHitDeadMaterial"),
50  m_store_Tot(false),
51  m_store_Vis(false),
52  m_store_Em(false),
53  m_store_NonEm(false),
54  m_storeUnknown(false),
55  m_caloCell_Tot("TotalCalibCell"), m_caloCell_Vis("VisCalibCell"),
56  m_caloCell_Em(""), m_caloCell_NonEm(""),
57  m_nchan(0)
58 
59 // The names suggestion if one needs to have them
60 //
61 // m_caloCell_Em("EmCalibCell"), m_caloCell_NonEm("NonEmCalibCell")
62 
63 {
64  declareProperty("StoreUnknownCells", m_storeUnknown);
65 
66  declareProperty("CellTotEne", m_caloCell_Tot);
67  declareProperty("CellVisEne", m_caloCell_Vis);
68  declareProperty("CellEmEne", m_caloCell_Em);
69  declareProperty("CellNonEmEne", m_caloCell_NonEm);
70 }
71 
72 
73 CalibHitToCaloCell::~CalibHitToCaloCell()
74 = default;
75 
76 
78 StatusCode CalibHitToCaloCell::initialize()
79 {
80  // retrieve ID helpers from det store
81  ATH_MSG_INFO("initialisation ID helpers" );
82 
83  ATH_CHECK( detStore()->retrieve(m_caloCell_ID) );
84  ATH_CHECK( detStore()->retrieve(m_caloDM_ID) );
85  ATH_CHECK( m_caloMgrKey.initialize() );
86 
87  m_store_Tot = !m_caloCell_Tot.empty();
88  m_store_Vis = !m_caloCell_Vis.empty();
89  m_store_Em = !m_caloCell_Em.empty();
90  m_store_NonEm = !m_caloCell_NonEm.empty();
91 
92  ATH_MSG_INFO("initialisation completed" );
93  return StatusCode::SUCCESS;
94 }
95 
96 
98 StatusCode CalibHitToCaloCell::execute()
99 {
100  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
101  ATH_CHECK(caloMgrHandle.isValid());
102  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
103 
104  // OUTPUT CONTAINERS
105  CaloCellContainer* cnt = nullptr;
106  CaloCellContainer* cnt_1 = nullptr;
107  CaloCellContainer* cnt_2 = nullptr;
108  CaloCellContainer* cnt_3 = nullptr;
109  if(m_store_Tot) cnt = new CaloCellContainer();
110  if(m_store_Vis) cnt_1 = new CaloCellContainer();
111  if(m_store_Em) cnt_2 = new CaloCellContainer();
112  if(m_store_NonEm) cnt_3 = new CaloCellContainer();
113 
114  // INPUT CONTAINERS
115  const CaloCalibrationHitContainer* tile_actHitCnt;
116  const CaloCalibrationHitContainer* tile_inactHitCnt;
117  const CaloCalibrationHitContainer* tile_dmHitCnt;
118  const CaloCalibrationHitContainer* lar_actHitCnt;
119  const CaloCalibrationHitContainer* lar_inactHitCnt;
120  const CaloCalibrationHitContainer* lar_dmHitCnt;
121 
122  //retrieving input Calibhit containers
123  ATH_CHECK( evtStore()->retrieve(tile_actHitCnt, m_tileActiveHitCnt) );
124  ATH_CHECK( evtStore()->retrieve(tile_inactHitCnt, m_tileInactiveHitCnt) );
125  ATH_CHECK( evtStore()->retrieve(tile_dmHitCnt, m_tileDMHitCnt) );
126  ATH_CHECK( evtStore()->retrieve(lar_actHitCnt, m_larActHitCnt) );
127  ATH_CHECK( evtStore()->retrieve(lar_inactHitCnt, m_larInactHitCnt) );
128  ATH_CHECK( evtStore()->retrieve(lar_dmHitCnt, m_larDMHitCnt) );
129 
130  ATH_MSG_DEBUG("CaloCalibrationHitContainers retrieved successfuly" );
131 
132  //count
133  m_nchan=0;
134  int em_nchan=0;
135  int hec_nchan=0;
136  int fcal_nchan=0;
137  int lar_unknown_nchan=0;
138  int tile_nchan=0;
139  int tile_unknown_nchan = 0 ;
140 
141  bool new_id = false;
142 
143  std::vector<Identifier> ID;
144 
145  //clean up CaloCell vectors
146  //for 'this' event
147  m_Cells_Tot.clear();
148  m_Cells_Vis.clear();
149  m_Cells_Em.clear();
150  m_Cells_NonEm.clear();
151 
152 
153  if(lar_inactHitCnt)
154  {
155  if( lar_inactHitCnt->Size() != 0 )
156  {
157  for (const CaloCalibrationHit* hit : *lar_inactHitCnt)
158  {
159  double Etot = hit->energyTotal();
160  double Eem = hit->energy(0);
161  double Enonem = hit->energy(1);
162  double Evis = Eem + Enonem;
163 
164  Identifier id=hit->cellID();
165 
166  //check if this ID is LAr one
167  if(m_caloCell_ID->is_lar(id))
168  {
169  const CaloDetDescrElement* caloDDE = caloDDMgr->get_element(id);
170 
171  if(m_store_Tot) {
172  LArCell* calibCell = new LArCell(caloDDE, id, Etot, 0., 0, 0, CaloGain::UNKNOWNGAIN );
173  m_Cells_Tot.push_back(calibCell) ;
174  }
175 
176  if(m_store_Vis) {
177  LArCell* calibCell_1 = new LArCell(caloDDE, id, Evis, 0., 0, 0, CaloGain::UNKNOWNGAIN );
178  m_Cells_Vis.push_back(calibCell_1) ;
179  }
180 
181  if(m_store_Em) {
182  LArCell* calibCell_2 = new LArCell(caloDDE, id, Eem, 0., 0, 0, CaloGain::UNKNOWNGAIN );
183  m_Cells_Em.push_back(calibCell_2) ;
184  }
185 
186  if(m_store_NonEm) {
187  LArCell* calibCell_3 = new LArCell(caloDDE, id, Enonem, 0., 0, 0, CaloGain::UNKNOWNGAIN );
188  m_Cells_NonEm.push_back(calibCell_3) ;
189  }
190 
191  ID.push_back(id);
192  ++m_nchan;
193  }
194  //another story...
195  else
196  {
197  ATH_MSG_DEBUG( "non-LAr ID in LArInactive "
198  << id.getString() << " sub_calo " << m_caloCell_ID->sub_calo(id) );
199  if(m_storeUnknown)
200  {
201  ATH_MSG_DEBUG("Ianctive CalibHit doesn't respect to any LArCell - "
202  <<"create dummy LArCell to store energy " );
203 
204  if(m_store_Tot) {
205  LArCell* calibCell = new LArCell();
206  calibCell->setEnergy(Etot);
207  m_Cells_Tot.push_back(calibCell) ;
208  }
209 
210  if(m_store_Vis) {
211  LArCell* calibCell_1 = new LArCell();
212  calibCell_1->setEnergy(Evis);
213  m_Cells_Vis.push_back(calibCell_1) ;
214  }
215 
216  if(m_store_Em) {
217  LArCell* calibCell_2 = new LArCell();
218  calibCell_2->setEnergy(Eem);
219  m_Cells_Em.push_back(calibCell_2) ;
220  }
221 
222  if(m_store_NonEm) {
223  LArCell* calibCell_3 = new LArCell();
224  calibCell_3->setEnergy(Enonem);
225  m_Cells_NonEm.push_back(calibCell_3) ;
226  }
227 
228  ID.push_back(id);
229  ++m_nchan;
230  }
231  }
232  }
233  }
234  }
235 
236 
237  if(lar_actHitCnt)
238  {
239  if( lar_actHitCnt->Size() != 0 )
240  {
241  //fix the current size of hits vector. for looping a bit later
242  int hits_vec_size = (int)ID.size() ;
243 
244  for (const CaloCalibrationHit* hit : *lar_actHitCnt)
245  {
246  Identifier id=hit->cellID();
247 
248  //merge inactive and active hits
249  //from the same cell together
250  for (int n=0; n!=hits_vec_size; n++)
251  {
252  if( id == ID[n] )
253  {
254  if(m_store_Tot) m_Cells_Tot[n]->add_energy(hit->energyTotal()) ;
255  if(m_store_Vis) m_Cells_Vis[n]->add_energy(hit->energy(0) + hit->energy(1)) ;
256  if(m_store_Em) m_Cells_Em[n]->add_energy(hit->energy(0)) ;
257  if(m_store_NonEm) m_Cells_NonEm[n]->add_energy(hit->energy(1)) ;
258 
259  new_id = false;
260  break;
261  }
262  else
263  {
264  new_id = true;
265  }
266  }
267  if(new_id)
268  {
269  double Etot = hit->energyTotal();
270  double Eem = hit->energy(0);
271  double Enonem = hit->energy(1);
272  double Evis = Eem + Enonem;
273 
274  if(m_caloCell_ID->is_lar(id))
275  {
276  const CaloDetDescrElement* caloDDE = caloDDMgr->get_element(id);
277 
278  if(m_store_Tot) {
279  LArCell* calibCell = new LArCell(caloDDE, id, Etot, 0., 0, 0, CaloGain::UNKNOWNGAIN );
280  m_Cells_Tot.push_back(calibCell) ;
281  }
282 
283  if(m_store_Vis) {
284  LArCell* calibCell_1 = new LArCell(caloDDE, id, Evis, 0., 0, 0, CaloGain::UNKNOWNGAIN );
285  m_Cells_Vis.push_back(calibCell_1) ;
286  }
287 
288  if(m_store_Em) {
289  LArCell* calibCell_2 = new LArCell(caloDDE, id, Eem, 0., 0, 0, CaloGain::UNKNOWNGAIN );
290  m_Cells_Em.push_back(calibCell_2) ;
291  }
292 
293  if(m_store_NonEm) {
294  LArCell* calibCell_3 = new LArCell(caloDDE, id, Enonem, 0., 0, 0, CaloGain::UNKNOWNGAIN );
295  m_Cells_NonEm.push_back(calibCell_3) ;
296  }
297 
298  ID.push_back(id);
299  ++m_nchan;
300  }
301  //another story...
302  else
303  {
304  ATH_MSG_DEBUG( "non-LAr ID in LArActive "
305  << id.getString() << " sub_calo " << m_caloCell_ID->sub_calo(id) );
306  if(m_storeUnknown)
307  {
308  ATH_MSG_DEBUG("Active CalibHit doesn't respect to any LArCell - "
309  <<"create dummy LArCell to store energy " );
310 
311 
312  if(m_store_Tot) {
313  LArCell* calibCell = new LArCell();
314  calibCell->setEnergy(Etot);
315  m_Cells_Tot.push_back(calibCell) ;
316  }
317 
318  if(m_store_Vis) {
319  LArCell* calibCell_1 = new LArCell();
320  calibCell_1->setEnergy(Evis);
321  m_Cells_Vis.push_back(calibCell_1) ;
322  }
323 
324  if(m_store_Em) {
325  LArCell* calibCell_2 = new LArCell();
326  calibCell_2->setEnergy(Eem);
327  m_Cells_Em.push_back(calibCell_2) ;
328  }
329 
330  if(m_store_NonEm) {
331  LArCell* calibCell_3 = new LArCell();
332  calibCell_3->setEnergy(Enonem);
333  m_Cells_NonEm.push_back(calibCell_3) ;
334  }
335 
336  ID.push_back(id);
337  ++m_nchan;
338  }
339  }
340  }
341  }
342  }
343  }
344 
345  //Now, put LArCells in the containers keeping
346  //the order. First goes EM, then HEC and so on
347  if(!m_Cells_Tot.empty())
348  {
349  for(int itr=0; itr!=m_nchan; itr++)
350  {
351  if(m_caloCell_ID->is_em(m_Cells_Tot[itr]->ID()))
352  {
353  if(m_store_Tot) cnt->push_back(m_Cells_Tot[itr]);
354  if(m_store_Vis) cnt_1->push_back(m_Cells_Vis[itr]);
355  if(m_store_Em) cnt_2->push_back(m_Cells_Em[itr]);
356  if(m_store_NonEm) cnt_3->push_back(m_Cells_NonEm[itr]);
357 
358  ++em_nchan;
359  }
360  }
361  if(em_nchan!=0)
362  {
363  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::LAREM);
364  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::LAREM);
365  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::LAREM);
366  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::LAREM);
367  }
368 
369  for(int itr=0; itr!=m_nchan; itr++)
370  {
371  if(m_caloCell_ID->is_hec(m_Cells_Tot[itr]->ID()))
372  {
373  if(m_store_Tot) cnt->push_back(m_Cells_Tot[itr]);
374  if(m_store_Vis) cnt_1->push_back(m_Cells_Vis[itr]);
375  if(m_store_Em) cnt_2->push_back(m_Cells_Em[itr]);
376  if(m_store_NonEm) cnt_3->push_back(m_Cells_NonEm[itr]);
377 
378  ++hec_nchan;
379  }
380  }
381  if(hec_nchan!=0)
382  {
383  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::LARHEC);
384  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::LARHEC);
385  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::LARHEC);
386  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::LARHEC);
387  }
388 
389  for(int itr=0; itr!=m_nchan; itr++)
390  {
391  if(m_caloCell_ID->is_fcal(m_Cells_Tot[itr]->ID()))
392  {
393  if(m_store_Tot) cnt->push_back(m_Cells_Tot[itr]);
394  if(m_store_Vis) cnt_1->push_back(m_Cells_Vis[itr]);
395  if(m_store_Em) cnt_2->push_back(m_Cells_Em[itr]);
396  if(m_store_NonEm) cnt_3->push_back(m_Cells_NonEm[itr]);
397 
398  ++fcal_nchan;
399  }
400  }
401  if(fcal_nchan!=0)
402  {
403  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::LARFCAL);
404  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::LARFCAL);
405  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::LARFCAL);
406  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::LARFCAL);
407  }
408 
409 
410  if(m_storeUnknown)
411  {
412  for(int itr=0; itr!=m_nchan; itr++)
413  {
414  if(!(m_caloCell_ID->is_lar(m_Cells_Tot[itr]->ID())))
415  {
416  if(m_store_Tot) cnt->push_back(m_Cells_Tot[itr]);
417  if(m_store_Vis) cnt_1->push_back(m_Cells_Vis[itr]);
418  if(m_store_Em) cnt_2->push_back(m_Cells_Em[itr]);
419  if(m_store_NonEm) cnt_3->push_back(m_Cells_NonEm[itr]);
420 
421  ++lar_unknown_nchan;
422  }
423  }
424 
425  if(lar_unknown_nchan!=0)
426  {
427  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::NOT_VALID);
428  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::NOT_VALID);
429  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::NOT_VALID);
430  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::NOT_VALID);
431  }
432  }
433  }
434 
435  ATH_MSG_VERBOSE("--- LAr INFO --- "<<m_nchan );
436  ATH_MSG_VERBOSE("LArCells = "<<m_nchan );
437  ATH_MSG_VERBOSE("EMCells = "<<em_nchan );
438  ATH_MSG_VERBOSE("HECCells = "<<hec_nchan );
439  ATH_MSG_VERBOSE("FCALCells = "<<fcal_nchan );
440  ATH_MSG_VERBOSE("NOT_VALID (LAr) = "<<lar_unknown_nchan );
441 
442 
443  if(tile_actHitCnt)
444  {
445  if( (tile_actHitCnt->Size()) != 0 )
446  {
447  for (const CaloCalibrationHit* hit : *tile_actHitCnt)
448  {
449  Identifier id=hit->cellID();
450 
451  double Etot = hit->energyTotal();
452  double Eem = hit->energy(0);
453  double Enonem = hit->energy(1);
454  double Evis = Eem + Enonem;
455 
456  if(m_caloCell_ID->is_tile(id))
457  {
458  const CaloDetDescrElement* caloDDE = caloDDMgr->get_element(id);
459 
460  if(m_store_Tot) {
461  TileCell* calibCell = new TileCell(caloDDE, id, Etot, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
462  cnt->push_back(calibCell);
463  }
464 
465  if(m_store_Vis) {
466  TileCell* calibCell_1 = new TileCell(caloDDE, id, Evis, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
467  cnt_1->push_back(calibCell_1);
468  }
469 
470  if(m_store_Em) {
471  TileCell* calibCell_2 = new TileCell(caloDDE, id, Eem, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
472  cnt_2->push_back(calibCell_2);
473  }
474 
475  if(m_store_NonEm) {
476  TileCell* calibCell_3 = new TileCell(caloDDE, id, Enonem, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
477  cnt_3->push_back(calibCell_3);
478  }
479 
480  ID.push_back(id);
481  ++tile_nchan;
482  ++m_nchan;
483  }
484  else
485  {
486  ATH_MSG_DEBUG( "non-Tile ID in Tile "
487  << id.getString() << " sub_calo " << m_caloCell_ID->sub_calo(id) );
488  if(m_storeUnknown)
489  {
490  ATH_MSG_DEBUG("Active CalibHit doesn't respect to any TileCell - "
491  <<"create dummy TileCell to store energy " );
492 
493  if(m_store_Tot) {
494  TileCell* calibCell = new TileCell();
495  calibCell->setEnergy(Etot);
496  cnt->push_back(calibCell);
497  }
498 
499  if(m_store_Vis) {
500  TileCell* calibCell_1 = new TileCell();
501  calibCell_1->setEnergy(Evis);
502  cnt_1->push_back(calibCell_1);
503  }
504 
505  if(m_store_Em) {
506  TileCell* calibCell_2 = new TileCell();
507  calibCell_2->setEnergy(Eem);
508  cnt_2->push_back(calibCell_2);
509  }
510 
511  if(m_store_NonEm) {
512  TileCell* calibCell_3 = new TileCell();
513  calibCell_3->setEnergy(Enonem);
514  cnt_3->push_back(calibCell_3);
515  }
516 
517  ID.push_back(id);
518  ++tile_unknown_nchan;
519  ++m_nchan;
520  }
521  }
522  }
523 
524  if(tile_nchan!=0)
525  {
526  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::TILE);
527  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::TILE);
528  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::TILE);
529  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::TILE);
530  }
531 
532  if(tile_unknown_nchan!=0)
533  {
534  if( !(cnt->hasCalo(CaloCell_ID::NOT_VALID)) )
535  {
536  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::NOT_VALID);
537  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::NOT_VALID);
538  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::NOT_VALID);
539  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::NOT_VALID);
540  }
541  }
542  }
543  }
544 
545 
546  if(tile_inactHitCnt)
547  {
548  if( (tile_inactHitCnt->Size()) != 0 )
549  {
550 
551  for (const CaloCalibrationHit* hit : *tile_actHitCnt)
552  {
553  Identifier id=hit->cellID();
554 
555  double Etot = hit->energyTotal();
556  double Eem = hit->energy(0);
557  double Enonem = hit->energy(1);
558  double Evis = Eem + Enonem;
559 
560  if(m_caloCell_ID->is_tile(id))
561  {
562  const CaloDetDescrElement* caloDDE = caloDDMgr->get_element(id);
563 
564  if(m_store_Tot) {
565  TileCell* calibCell = new TileCell(caloDDE, id, Etot, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
566  cnt->push_back(calibCell);
567  }
568 
569  if(m_store_Vis) {
570  TileCell* calibCell_1 = new TileCell(caloDDE, id, Evis, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
571  cnt_1->push_back(calibCell_1);
572  }
573 
574  if(m_store_Em) {
575  TileCell* calibCell_2 = new TileCell(caloDDE, id, Eem, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
576  cnt_2->push_back(calibCell_2);
577  }
578 
579  if(m_store_NonEm) {
580  TileCell* calibCell_3 = new TileCell(caloDDE, id, Enonem, 0., 0, 0, CaloGain::UNKNOWNGAIN, 0.0, 0.0 );
581  cnt_3->push_back(calibCell_3);
582  }
583 
584  ID.push_back(id);
585  ++tile_nchan;
586  ++m_nchan;
587  }
588  else
589  {
590  ATH_MSG_DEBUG( "non-Tile ID in Tile "
591  << id.getString() << " sub_calo " << m_caloCell_ID->sub_calo(id) );
592  if(m_storeUnknown)
593  {
594  ATH_MSG_DEBUG("Inactive CalibHit doesn't respect to any TileCell - "
595  <<"create dummy TileCell to store energy " );
596 
597  if(m_store_Tot) {
598  TileCell* calibCell = new TileCell();
599  calibCell->setEnergy(Etot);
600  cnt->push_back(calibCell);
601  }
602 
603  if(m_store_Vis) {
604  TileCell* calibCell_1 = new TileCell();
605  calibCell_1->setEnergy(Evis);
606  cnt_1->push_back(calibCell_1);
607  }
608 
609  if(m_store_Em) {
610  TileCell* calibCell_2 = new TileCell();
611  calibCell_2->setEnergy(Eem);
612  cnt_2->push_back(calibCell_2);
613  }
614 
615  if(m_store_NonEm) {
616  TileCell* calibCell_3 = new TileCell();
617  calibCell_3->setEnergy(Enonem);
618  cnt_3->push_back(calibCell_3);
619  }
620 
621  ID.push_back(id);
622  ++tile_unknown_nchan;
623  ++m_nchan;
624  }
625  }
626  }
627 
628  if(tile_nchan!=0)
629  {
630  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::TILE);
631  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::TILE);
632  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::TILE);
633  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::TILE);
634  }
635 
636  if(tile_unknown_nchan!=0)
637  {
638  if( !(cnt->hasCalo(CaloCell_ID::NOT_VALID)) )
639  {
640  if(m_store_Tot) cnt->setHasCalo(CaloCell_ID::NOT_VALID);
641  if(m_store_Vis) cnt_1->setHasCalo(CaloCell_ID::NOT_VALID);
642  if(m_store_Em) cnt_2->setHasCalo(CaloCell_ID::NOT_VALID);
643  if(m_store_NonEm) cnt_3->setHasCalo(CaloCell_ID::NOT_VALID);
644  }
645  }
646  }
647  }
648 
649  ATH_MSG_VERBOSE("--- TILE INFO --- "<<m_nchan );
650  ATH_MSG_VERBOSE("TileCells = "<<tile_nchan );
651  ATH_MSG_VERBOSE("NOT_VALID (Tile) = "<<tile_unknown_nchan );
652  ATH_MSG_VERBOSE("ALL CELLS = "<<m_nchan );
653 
654 
655 /* UNDER DEVELOPING... UNDER DEVELOPING... UNDER DEVELOPING...
656 
657  if( (dmHitCnt->Size()) != 0 )
658  {
659  CaloCalibrationHitContainer::const_iterator it = dmHitCnt->begin();
660  CaloCalibrationHitContainer::const_iterator end = dmHitCnt->end();
661 
662  for(; it != end; it++)
663  {
664  Identifier id=(*it)->cellID();
665  ++m_dm_nchan;
666  }
667  }
668 */
669 
670 
671 
673 // cnt->updateCaloIterators();
674 // cnt->order();
675 
676 
677  //Record CaloCellContainer-s in the StoreGate.
678  //Check the containers name, if it was declared
679  //then record it.
680  if(m_store_Tot) ATH_CHECK( evtStore()->record(cnt, m_caloCell_Tot, false) );
681  if(m_store_Vis) ATH_CHECK( evtStore()->record(cnt_1, m_caloCell_Vis, false) );
682  if(m_store_Em) ATH_CHECK( evtStore()->record(cnt_2, m_caloCell_Em, false) );
683  if(m_store_NonEm) ATH_CHECK( evtStore()->record(cnt_3, m_caloCell_NonEm, false) );
684 
685  ID.clear();
686 
687  ATH_MSG_DEBUG("execute() completed successfully" );
688  return StatusCode::SUCCESS;
689 }
690 
691 
693 StatusCode CalibHitToCaloCell::finalize()
694 {
695  ATH_MSG_INFO("finalize() successfully" );
696  return StatusCode::SUCCESS;
697 }
698 
699 
700 //needed only when developing
701 void CalibHitToCaloCell::test_energy(Energy* energy)
702 {
703  ATH_MSG_INFO( "Total = "<<(*energy)[0] <<" | "
704  << "Visible = "<<(*energy)[1] <<" | "
705  << "Em = "<<(*energy)[2] <<" | "
706  << "NonEm = "<<(*energy)[3] );
707 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCell
Definition: TileCell.h:57
CaloCalibrationHitContainer
Definition: CaloCalibrationHitContainer.h:25
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition: CaloCell_Base_ID.h:46
CalibHitToCaloCell::~CalibHitToCaloCell
virtual ~CalibHitToCaloCell()
CalibHitToCaloCell.h
CalibHitToCaloCell::m_store_NonEm
bool m_store_NonEm
Definition: CalibHitToCaloCell.h:55
CalibHitToCaloCell::m_Cells_Vis
std::vector< LArCell * > m_Cells_Vis
Definition: CalibHitToCaloCell.h:67
CalibHitToCaloCell::initialize
StatusCode initialize() override
Definition: CalibHitToCaloCell.cxx:78
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AtlasDetectorID::is_lar
bool is_lar(Identifier id) const
Definition: AtlasDetectorID.h:689
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CalibHitToCaloCell::m_tileActiveHitCnt
std::string m_tileActiveHitCnt
Definition: CalibHitToCaloCell.h:45
Energy
std::vector< double > Energy
Definition: CalibHitToCaloCell.h:23
CaloGain::UNKNOWNGAIN
@ UNKNOWNGAIN
Definition: CaloGain.h:20
CaloCellContainer::setHasCalo
void setHasCalo(const CaloCell_ID::SUBCALO caloNum)
set which calo has been filled.
Definition: CaloCellContainer.cxx:213
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
CaloCell.h
CalibHitToCaloCell::m_Cells_Tot
std::vector< LArCell * > m_Cells_Tot
Definition: CalibHitToCaloCell.h:66
CalibHitToCaloCell::m_Cells_Em
std::vector< LArCell * > m_Cells_Em
Definition: CalibHitToCaloCell.h:68
CaloCell_Base_ID::LARHEC
@ LARHEC
Definition: CaloCell_Base_ID.h:46
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
CaloCell_Base_ID::is_tile
bool is_tile(const Identifier id) const
test if the id belongs to the Tiles
CaloCell::setEnergy
virtual void setEnergy(float energy)
set energy
Definition: CaloCell.cxx:136
CaloCell_Base_ID::is_hec
bool is_hec(const Identifier id) const
test if the id belongs to the HEC
CaloCalibrationHitContainer.h
CalibHitToCaloCell::m_Cells_NonEm
std::vector< LArCell * > m_Cells_NonEm
Definition: CalibHitToCaloCell.h:69
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
CaloCell_ID.h
CalibHitToCaloCell::m_nchan
int m_nchan
Definition: CalibHitToCaloCell.h:71
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
RunTileCalibRec.CaloCellContainer
CaloCellContainer
Definition: RunTileCalibRec.py:403
CalibHitToCaloCell::finalize
StatusCode finalize() override
Definition: CalibHitToCaloCell.cxx:693
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
CaloCell_Base_ID::is_em
bool is_em(const Identifier id) const
test if the id belongs to LArEM
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
CalibHitToCaloCell::test_energy
void test_energy(Energy *)
Definition: CalibHitToCaloCell.cxx:701
CaloCell_Base_ID::is_fcal
bool is_fcal(const Identifier id) const
test if the id belongs to the FCAL - true also for MiniFCAL
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
beamspotman.n
n
Definition: beamspotman.py:731
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileCell.h
CaloCell_Base_ID::sub_calo
int sub_calo(const Identifier id) const
returns an int taken from SUBCALO enum and describing the subCalo to which the Id belongs.
CalibHitToCaloCell::m_caloCell_Em
std::string m_caloCell_Em
Definition: CalibHitToCaloCell.h:60
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:46
CalibHitToCaloCell::m_storeUnknown
bool m_storeUnknown
Definition: CalibHitToCaloCell.h:56
CaloDM_ID.h
AthAlgorithm
Definition: AthAlgorithm.h:47
CalibHitToCaloCell::m_caloCell_ID
const CaloCell_ID * m_caloCell_ID
Definition: CalibHitToCaloCell.h:63
CalibHitToCaloCell::m_caloCell_Vis
std::string m_caloCell_Vis
Definition: CalibHitToCaloCell.h:59
CalibHitToCaloCell::m_store_Tot
bool m_store_Tot
Definition: CalibHitToCaloCell.h:52
CaloCalibrationHit
Class to store calorimeter calibration hit.
Definition: CaloCalibrationHit.h:21
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
LArCell.h
CalibHitToCaloCell::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: CalibHitToCaloCell.h:73
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArCell
Data object for LAr calorimeter readout cell.
Definition: LArCell.h:53
CalibHitToCaloCell::m_caloDM_ID
const CaloDM_ID * m_caloDM_ID
Definition: CalibHitToCaloCell.h:64
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
CalibHitToCaloCell::m_caloCell_NonEm
std::string m_caloCell_NonEm
Definition: CalibHitToCaloCell.h:61
TileCell::setEnergy
virtual void setEnergy(float ene) override final
set total energy, reset eneDiff to zero
Definition: TileCell.cxx:123
CalibHitToCaloCell::execute
StatusCode execute() override
Definition: CalibHitToCaloCell.cxx:98
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
CalibHitToCaloCell::CalibHitToCaloCell
CalibHitToCaloCell(const std::string &name, ISvcLocator *pSvcLocator)
Definition: CalibHitToCaloCell.cxx:42
AthenaHitsVector::Size
int Size() const
Definition: AthenaHitsVector.h:96
trigbs_pickEvents.cnt
cnt
Definition: trigbs_pickEvents.py:71
CaloCellContainer::push_back
void push_back(CaloCell *)
reimplementation of const push_back
Definition: CaloCellContainer.cxx:74
CalibHitToCaloCell::m_tileDMHitCnt
std::string m_tileDMHitCnt
Definition: CalibHitToCaloCell.h:47
CalibHitToCaloCell::m_store_Vis
bool m_store_Vis
Definition: CalibHitToCaloCell.h:53
CalibHitToCaloCell::m_larInactHitCnt
std::string m_larInactHitCnt
Definition: CalibHitToCaloCell.h:48
CalibHitToCaloCell::m_store_Em
bool m_store_Em
Definition: CalibHitToCaloCell.h:54
CalibHitToCaloCell::m_larDMHitCnt
std::string m_larDMHitCnt
Definition: CalibHitToCaloCell.h:50
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:46
CaloCell_Base_ID::NOT_VALID
@ NOT_VALID
Definition: CaloCell_Base_ID.h:46
CaloGain.h
CalibHitToCaloCell::m_larActHitCnt
std::string m_larActHitCnt
Definition: CalibHitToCaloCell.h:49
CalibHitToCaloCell::m_caloCell_Tot
std::string m_caloCell_Tot
Definition: CalibHitToCaloCell.h:58
CalibHitToCaloCell::m_tileInactiveHitCnt
std::string m_tileInactiveHitCnt
Definition: CalibHitToCaloCell.h:46
Generated on Tue Jul 2 2024 21:11:20 for ATLAS Offline Software by   doxygen 1.8.18