ATLAS Offline Software
Loading...
Searching...
No Matches
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
42CalibHitToCaloCell::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
73CalibHitToCaloCell::~CalibHitToCaloCell()
74= default;
75
76
78StatusCode 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
98StatusCode 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
693StatusCode CalibHitToCaloCell::finalize()
694{
695 ATH_MSG_INFO("finalize() successfully" );
696 return StatusCode::SUCCESS;
697}
698
699
700//needed only when developing
701void 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}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
ID
std::vector< Identifier > ID
Definition CalibHitIDCheck.h:26
Energy
std::vector< double > Energy
Definition CalibHitToCaloCell.h:23
CaloCell_ID.h
CaloDM_ID.h
CaloDetDescrManager.h
Definition of CaloDetDescrManager.
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor with parameters:
Definition AthAlgorithm.cxx:24
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
CalibHitToCaloCell::execute
StatusCode execute() override
Definition CalibHitToCaloCell.cxx:98
CalibHitToCaloCell::~CalibHitToCaloCell
virtual ~CalibHitToCaloCell()
CalibHitToCaloCell::initialize
StatusCode initialize() override
Definition CalibHitToCaloCell.cxx:78
CalibHitToCaloCell::m_caloCell_ID
const CaloCell_ID * m_caloCell_ID
Definition CalibHitToCaloCell.h:63
CalibHitToCaloCell::m_Cells_Vis
std::vector< LArCell * > m_Cells_Vis
Definition CalibHitToCaloCell.h:67
CalibHitToCaloCell::m_Cells_Tot
std::vector< LArCell * > m_Cells_Tot
Definition CalibHitToCaloCell.h:66
CalibHitToCaloCell::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition CalibHitToCaloCell.h:73
CalibHitToCaloCell::m_tileActiveHitCnt
std::string m_tileActiveHitCnt
Definition CalibHitToCaloCell.h:45
CalibHitToCaloCell::m_caloDM_ID
const CaloDM_ID * m_caloDM_ID
Definition CalibHitToCaloCell.h:64
CalibHitToCaloCell::m_tileInactiveHitCnt
std::string m_tileInactiveHitCnt
Definition CalibHitToCaloCell.h:46
CalibHitToCaloCell::CalibHitToCaloCell
CalibHitToCaloCell(const std::string &name, ISvcLocator *pSvcLocator)
Definition CalibHitToCaloCell.cxx:42
CalibHitToCaloCell::m_Cells_NonEm
std::vector< LArCell * > m_Cells_NonEm
Definition CalibHitToCaloCell.h:69
CalibHitToCaloCell::m_Cells_Em
std::vector< LArCell * > m_Cells_Em
Definition CalibHitToCaloCell.h:68
CalibHitToCaloCell::finalize
StatusCode finalize() override
Definition CalibHitToCaloCell.cxx:693
CaloCalibrationHit
Class to store calorimeter calibration hit.
Definition CaloCalibrationHit.h:23
CaloCellContainer
Container class for CaloCell.
Definition CaloCellContainer.h:55
CaloCellContainer::push_back
void push_back(CaloCell *)
reimplementation of const push_back
Definition CaloCellContainer.cxx:74
CaloCellContainer::setHasCalo
void setHasCalo(const CaloCell_ID::SUBCALO caloNum)
set which calo has been filled.
Definition CaloCellContainer.cxx:213
CaloCell_Base_ID::LAREM
@ LAREM
Definition CaloCell_Base_ID.h:45
CaloCell_Base_ID::TILE
@ TILE
Definition CaloCell_Base_ID.h:45
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition CaloCell_Base_ID.h:45
CaloCell_Base_ID::NOT_VALID
@ NOT_VALID
Definition CaloCell_Base_ID.h:45
CaloCell_Base_ID::LARHEC
@ LARHEC
Definition CaloCell_Base_ID.h:45
CaloCell::setEnergy
virtual void setEnergy(float energy)
set energy
Definition CaloCell.h:472
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell.
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
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition CaloDetDescrManager.h:469
LArCell
Data object for LAr calorimeter readout cell.
Definition LArCell.h:53
TileCell::setEnergy
virtual void setEnergy(float ene) override final
set total energy, reset eneDiff to zero (final override of CaloCell method)
Definition TileCell.cxx:123
CaloGain::UNKNOWNGAIN
@ UNKNOWNGAIN
Definition CaloGain.h:21
Generated on for ATLAS Offline Software by doxygen 1.14.0