ATLAS Offline Software
CaloCell_Base_ID.icc
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // $Id$
6 /**
7  * @file CaloIdentifier/CaloCell_Base_ID.icc
8  * @author scott snyder <snyder@bnl.gov>
9  * @date Jul, 2012
10  * @brief Helper base class for offline cell identifiers
11  */
12 
13 
14 //--------------------
15 // Inline definitions
16 //--------------------
17 
18 //----------------------------------------------------------------------------
19 inline Identifier
20 CaloCell_Base_ID::region_id (const int subCalo,
21  const int barec_or_posneg,
22  const int sampling_or_fcalmodule,
23  const int region_or_dummy,
24  bool checks) const
25 {
26  Identifier result(0); // this returns a pixel identifier [2.1.-2.0.0]
27  if( subCalo == LAREM ) {
28  return m_emHelper->region_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, checks);
29  }
30  else if( subCalo == LARHEC ) {
31  return m_hecHelper->region_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, checks);
32  }
33  else if( subCalo == LARFCAL ) {
34  return m_fcalHelper->module_id(barec_or_posneg, sampling_or_fcalmodule, checks);
35  }
36  else if( subCalo == LARMINIFCAL ) {
37  return m_minifcalHelper->module_id(barec_or_posneg, sampling_or_fcalmodule, checks);
38  }
39  else if( subCalo == TILE ) {
40  return m_tileHelper->region_id(barec_or_posneg, sampling_or_fcalmodule, checks);
41  }
42  else {
43  return(result);
44  }
45 }
46 
47 inline Identifier
48 CaloCell_Base_ID::region_id (const int subCalo,
49  const int barec_or_posneg,
50  const int sampling_or_fcalmodule,
51  const int region_or_dummy ) const
52 {
53  return region_id (subCalo, barec_or_posneg, sampling_or_fcalmodule,
54  region_or_dummy, do_checks());
55 }
56 
57 //----------------------------------------------------------------------------
58 inline Identifier
59 CaloCell_Base_ID::cell_id (const int subCalo,
60  const int barec_or_posneg,
61  const int sampling_or_fcalmodule,
62  const int region_or_dummy,
63  const int eta,
64  const int phi,
65  bool checks) const
66 {
67  Identifier result(0);
68  if( subCalo == LAREM ) {
69  return m_emHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
70  }
71  else if( subCalo == LARHEC ) {
72  return m_hecHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
73  }
74  else if( subCalo == LARFCAL ) {
75  return m_fcalHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, eta, phi, checks);
76  }
77  else if( subCalo == LARMINIFCAL ) {
78  return m_minifcalHelper->channel_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
79  }
80  else if( subCalo == TILE ) {
81  return m_tileHelper->cell_id(barec_or_posneg, sampling_or_fcalmodule, region_or_dummy, eta, phi, checks);
82  }
83  else {
84  return(result);
85  }
86 }
87 
88 inline Identifier
89 CaloCell_Base_ID::cell_id (const int subCalo,
90  const int barec_or_posneg,
91  const int sampling_or_fcalmodule,
92  const int region_or_dummy,
93  const int eta,
94  const int phi) const
95 {
96  return cell_id (subCalo, barec_or_posneg, sampling_or_fcalmodule,
97  region_or_dummy, eta, phi, do_checks());
98 }
99 
100 //----------------------------------------------------------------------------
101 inline Identifier
102 CaloCell_Base_ID::region_id ( const Identifier cellId ) const
103 {
104  Identifier result(0);
105  if(m_emHelper->is_lar_em(cellId)) {
106  return m_emHelper->region_id(cellId);
107  }
108  else if(m_emHelper->is_lar_hec(cellId)) {
109  return m_hecHelper->region_id(cellId);
110  }
111  else if(m_emHelper->is_lar_minifcal(cellId)) {
112  // must do minifcal before fcal because miniFCAL IS FCAL
113  return m_minifcalHelper->module_id(cellId);
114  }
115  else if(m_emHelper->is_lar_fcal(cellId)) {
116  return m_fcalHelper->module_id(cellId);
117  }
118  else if(m_emHelper->is_tile(cellId)) {
119  return m_tileHelper->region_id(cellId);
120  }
121  else {
122  return(result);
123  }
124 }
125 
126 //----------------------------------------------------------------------------
127 inline Identifier
128 CaloCell_Base_ID::cell_id (const Identifier regionId,
129  const int eta,
130  const int phi,
131  int depth,
132  bool checks) const
133 {
134  Identifier result(0);
135  if(m_emHelper->is_lar_em(regionId)) {
136  return m_emHelper->channel_id(regionId,eta,phi,checks);
137  }
138  else if(m_emHelper->is_lar_hec(regionId)) {
139  return m_hecHelper->channel_id(regionId,eta,phi,checks);
140  }
141  else if(m_emHelper->is_lar_minifcal(regionId)) {
142  // must do minifcal before fcal because miniFCAL IS FCAL
143  return m_minifcalHelper->channel_id(regionId, depth,eta,phi,checks);
144  }
145  else if(m_emHelper->is_lar_fcal(regionId)) {
146  return m_fcalHelper->channel_id(regionId,eta,phi,checks);
147  }
148  else {
149  return(result);
150  }
151 }
152 
153 inline Identifier
154 CaloCell_Base_ID::cell_id (const Identifier regionId,
155  const int eta,
156  const int phi,
157  int depth) const
158 {
159  return cell_id (regionId, eta, phi, depth, do_checks());
160 }
161 
162 //----------------------------------------------------------------------------
163 inline Identifier
164 CaloCell_Base_ID::region_id (const IdentifierHash caloRegionHash) const
165 {
166  return(m_region_vec[caloRegionHash]);
167 }
168 
169 //----------------------------------------------------------------------------
170 inline Identifier
171 CaloCell_Base_ID::region_id (const int subCalo,
172  const IdentifierHash subCaloRegionHash) const
173 {
174  return(m_region_vec[subCaloRegionHash + m_reg_min[subCalo]]);
175 }
176 
177 //----------------------------------------------------------------------------
178 inline Identifier
179 CaloCell_Base_ID::cell_id (const IdentifierHash caloCellHash) const
180 {
181  return(m_cell_vec[caloCellHash]);
182 }
183 
184 //----------------------------------------------------------------------------
185 inline Identifier
186 CaloCell_Base_ID::cell_id (const int subCalo, const IdentifierHash subCaloCellHash) const
187 {
188  return(m_cell_vec[subCaloCellHash + m_cell_min[subCalo]]);
189 }
190 
191 //----------------------------------------------------------------------------
192 inline IdentifierHash
193 CaloCell_Base_ID::calo_region_hash (const Identifier regionId) const
194 {
195  std::vector<Identifier>::const_iterator it = std::lower_bound(m_region_vec.begin(),m_region_vec.end(),regionId);
196  if ( it != m_region_vec.end() ){
197  return (it - m_region_vec.begin());
198  }
199  return (NOT_VALID);
200 }
201 
202 //----------------------------------------------------------------------------
203 inline IdentifierHash
204 CaloCell_Base_ID::subcalo_region_hash (const Identifier regionId, int& subCalo) const
205 {
206  subCalo = LAREM ;
207  if(is_hec(regionId)) {
208  subCalo = LARHEC ;
209  }
210  else if (is_minifcal(regionId)) {
211  // must do minifcal before fcal because miniFCAL IS FCAL
212  subCalo = LARMINIFCAL ;
213  }
214  else if (is_fcal(regionId)) {
215  subCalo = LARFCAL ;
216  }
217  else if (is_tile(regionId)) {
218  subCalo = TILE ;
219  }
220  std::vector<Identifier>::const_iterator it = std::lower_bound(m_region_vec.begin(),m_region_vec.end(),regionId);
221  if ( it != m_region_vec.end() ){
222  return (it - m_region_vec.begin() - m_reg_min[subCalo]);
223  }
224  return (NOT_VALID);
225 }
226 
227 //----------------------------------------------------------------------------
228 inline IdentifierHash
229 CaloCell_Base_ID::subcalo_cell_hash (const Identifier cellId, int& subCalo) const
230 {
231  subCalo = get_subcalo (cellId);
232  switch (subCalo) {
233 
234  // LArEM / HEC have subdetector-specific optimized methods.
235  case LAREM:
236  return m_emHelper->channel_hash (cellId);
237  case LARHEC:
238  return m_hecHelper->channel_hash (cellId);
239  case LARFCAL:
240  case TILE:
241  case LARMINIFCAL:
242  return m_helpers[subCalo]->channel_hash (cellId);
243  default:
244  return NOT_VALID;
245  }
246 }
247 
248 //----------------------------------------------------------------------------
249 inline IdentifierHash
250 CaloCell_Base_ID::calo_cell_hash (const Identifier cellId) const
251 {
252  int subcalo;
253  IdentifierHash hash = subcalo_cell_hash (cellId, subcalo);
254  if (hash != NOT_VALID)
255  return m_cell_min[subcalo] + hash;
256  return NOT_VALID;
257 }
258 
259 //----------------------------------------------------------------------------
260 inline CaloCell_Base_ID::size_type CaloCell_Base_ID::calo_cell_hash_max (void) const
261 {
262  return m_cell_hash_max;
263 }
264 
265 //----------------------------------------------------------------------------
266 inline CaloCell_Base_ID::size_type CaloCell_Base_ID::calo_region_hash_max (void) const
267 {
268  return m_region_hash_max;
269 }
270 
271 //----------------------------------------------------------------------------
272 inline void CaloCell_Base_ID::calo_cell_hash_range (const Identifier id, IdentifierHash& caloCellMin, IdentifierHash& caloCellMax) const
273 {
274  if(m_emHelper->is_lar_em(id)) {
275  caloCellMin = m_cell_min[LAREM];
276  caloCellMax = m_cell_max[LAREM];
277  }
278  else if(m_emHelper->is_lar_hec(id)) {
279  caloCellMin = m_cell_min[LARHEC];
280  caloCellMax = m_cell_max[LARHEC];
281  }
282  else if(m_emHelper->is_lar_minifcal(id)) {
283  // must do minifcal before fcal because miniFCAL IS FCAL
284  caloCellMin = m_cell_min[LARMINIFCAL];
285  caloCellMax = m_cell_max[LARMINIFCAL];
286  }
287  else if(m_emHelper->is_lar_fcal(id)) {
288  caloCellMin = m_cell_min[LARFCAL];
289  caloCellMax = m_cell_max[LARFCAL];
290  }
291  else if(m_emHelper->is_tile(id)) {
292  caloCellMin = m_cell_min[TILE];
293  caloCellMax = m_cell_max[TILE];
294  }
295  else {
296  caloCellMin = NOT_VALID;
297  caloCellMax = NOT_VALID;
298  }
299 }
300 
301 //----------------------------------------------------------------------------
302 inline void CaloCell_Base_ID::calo_reg_hash_range (const Identifier id, IdentifierHash& caloRegMin, IdentifierHash& caloRegMax) const
303 {
304  if(m_emHelper->is_lar_em(id)) {
305  caloRegMin = m_reg_min[LAREM];
306  caloRegMax = m_reg_max[LAREM];
307  }
308  else if(m_emHelper->is_lar_hec(id)) {
309  caloRegMin = m_reg_min[LARHEC];
310  caloRegMax = m_reg_max[LARHEC];
311  }
312  else if(m_emHelper->is_lar_minifcal(id)) {
313  // must do minifcal before fcal because miniFCAL IS FCAL
314  caloRegMin = m_reg_min[LARMINIFCAL];
315  caloRegMax = m_reg_max[LARMINIFCAL];
316  }
317  else if(m_emHelper->is_lar_fcal(id)) {
318  caloRegMin = m_reg_min[LARFCAL];
319  caloRegMax = m_reg_max[LARFCAL];
320  }
321  else if(m_emHelper->is_tile(id)) {
322  caloRegMin = m_reg_min[TILE];
323  caloRegMax = m_reg_max[TILE];
324  }
325  else {
326  caloRegMin = NOT_VALID;
327  caloRegMax = NOT_VALID;
328  }
329 }
330 
331 //----------------------------------------------------------------------------
332 inline void CaloCell_Base_ID::calo_cell_hash_range (const int subCalo, IdentifierHash& caloCellMin, IdentifierHash& caloCellMax) const
333 {
334  caloCellMin = m_cell_min[subCalo];
335  caloCellMax = m_cell_max[subCalo];
336 }
337 
338 //----------------------------------------------------------------------------
339 inline void CaloCell_Base_ID::calo_reg_hash_range (const int subCalo, IdentifierHash& caloRegMin, IdentifierHash& caloRegMax) const
340 {
341  caloRegMin = m_reg_min[subCalo];
342  caloRegMax = m_reg_max[subCalo];
343 }
344 
345 //----------------------------------------------------------------------------
346 inline IdentifierHash CaloCell_Base_ID::subcalo_cell_hash ( const IdentifierHash caloHash, int& subCalo) const
347 {
348  if(caloHash < m_cell_max[LAREM]) {
349  subCalo = LAREM;
350  }
351  else if(caloHash < m_cell_max[LARHEC] ) {
352  subCalo = LARHEC;
353  }
354  else if(caloHash < m_cell_max[LARFCAL] ) {
355  subCalo = LARFCAL;
356  }
357  else if(caloHash < m_cell_max[TILE] ) {
358  subCalo = TILE;
359  }
360  else if(caloHash < m_cell_max[LARMINIFCAL] ) {
361  subCalo = LARMINIFCAL;
362  }
363  else {
364  subCalo = NOT_VALID;
365  return(NOT_VALID);
366  }
367  return( caloHash - m_cell_min[subCalo]) ;
368 }
369 
370 //----------------------------------------------------------------------------
371 inline IdentifierHash CaloCell_Base_ID::subcalo_region_hash ( const IdentifierHash caloHash, int& subCalo) const
372 {
373  if(caloHash < m_reg_max[LAREM]) {
374  subCalo = LAREM;
375  }
376  else if(caloHash < m_reg_max[LARHEC] ) {
377  subCalo = LARHEC;
378  }
379  else if(caloHash < m_reg_max[LARFCAL] ) {
380  subCalo = LARFCAL;
381  }
382  else if(caloHash < m_reg_max[TILE] ) {
383  subCalo = TILE;
384  }
385  else if(caloHash < m_reg_max[LARMINIFCAL] ) {
386  subCalo = LARMINIFCAL;
387  }
388  else {
389  subCalo = NOT_VALID;
390  return(NOT_VALID);
391  }
392  return( caloHash - m_reg_min[subCalo]) ;
393 }
394 
395 //----------------------------------------------------------------------------
396 inline IdentifierHash CaloCell_Base_ID::calo_cell_hash (const int subCalo, const IdentifierHash subCaloHash) const
397 {
398  return( subCaloHash + m_cell_min[subCalo]) ;
399 }
400 
401 
402 //----------------------------------------------------------------------------
403 inline IdentifierHash CaloCell_Base_ID::calo_region_hash (const int subCalo, const IdentifierHash subCaloHash) const
404 {
405  return( subCaloHash + m_reg_min[subCalo]) ;
406 }
407 
408 //----------------------------------------------------------------------------
409 inline CaloCell_Base_ID::id_iterator CaloCell_Base_ID::cell_begin (void) const
410 {
411  return(m_cell_vec.begin());
412 }
413 
414 //----------------------------------------------------------------------------
415 inline CaloCell_Base_ID::id_iterator CaloCell_Base_ID::cell_end (void) const
416 {
417  return(m_cell_vec.end());
418 }
419 
420 //----------------------------------------------------------------------------
421 inline CaloCell_Base_ID::id_range CaloCell_Base_ID::cell_range (void) const
422 {
423  return id_range (cell_begin(), cell_end());
424 }
425 
426 //----------------------------------------------------------------------------
427 inline
428 CaloCell_Base_ID::id_iterator
429 CaloCell_Base_ID::cell_begin (const int subCalo) const
430 {
431  return m_helpers[subCalo]->channels().begin();
432 }
433 
434 //----------------------------------------------------------------------------
435 inline
436 CaloCell_Base_ID::id_iterator
437 CaloCell_Base_ID::cell_end (const int subCalo) const
438 {
439  return m_helpers[subCalo]->channels().end();
440 }
441 
442 //----------------------------------------------------------------------------
443 inline
444 CaloCell_Base_ID::id_range
445 CaloCell_Base_ID::cell_range (const int subCalo) const
446 {
447  return m_helpers[subCalo]->channels().range();
448 }
449 
450 //----------------------------------------------------------------------------
451 inline
452 CaloCell_Base_ID::id_iterator
453 CaloCell_Base_ID::reg_begin (void) const
454 {
455  return(m_region_vec.begin());
456 }
457 
458 //----------------------------------------------------------------------------
459 inline
460 CaloCell_Base_ID::id_iterator
461 CaloCell_Base_ID::reg_end (void) const
462 {
463  return(m_region_vec.end());
464 }
465 
466 //----------------------------------------------------------------------------
467 inline
468 CaloCell_Base_ID::id_range
469 CaloCell_Base_ID::reg_range (void) const
470 {
471  return id_range (reg_begin(), reg_end());
472 }
473 
474 //----------------------------------------------------------------------------
475 inline
476 CaloCell_Base_ID::id_iterator
477 CaloCell_Base_ID::reg_begin (const int subCalo) const
478 {
479  return m_helpers[subCalo]->regions().begin();
480 }
481 
482 //----------------------------------------------------------------------------
483 inline
484 CaloCell_Base_ID::id_iterator
485 CaloCell_Base_ID::reg_end (const int subCalo) const
486 {
487  return m_helpers[subCalo]->regions().end();
488 }
489 
490 //----------------------------------------------------------------------------
491 inline
492 CaloCell_Base_ID::id_range
493 CaloCell_Base_ID::reg_range (const int subCalo) const
494 {
495  return m_helpers[subCalo]->regions().range();
496 }
497 
498 //----------------------------------------------------------------------------
499 inline bool CaloCell_Base_ID::is_em(const Identifier id) const
500 {
501  return m_emHelper->is_lar_em(id);
502 }
503 
504 //----------------------------------------------------------------------------
505 inline bool CaloCell_Base_ID::is_em(const IdentifierHash caloHash) const
506 {
507  bool result=false;
508  if(caloHash < m_cell_max[LAREM]) result=true;
509  return result;
510 }
511 
512 //----------------------------------------------------------------------------
513 inline bool CaloCell_Base_ID::is_em_barrel(const Identifier id) const
514 {
515  return m_emHelper->is_em_barrel(id);
516 }
517 
518 //----------------------------------------------------------------------------
519 inline bool CaloCell_Base_ID::is_em_endcap(const Identifier id) const
520 {
521  return m_emHelper->is_em_endcap(id);
522 }
523 
524 //----------------------------------------------------------------------------
525 inline bool CaloCell_Base_ID::is_em_endcap_inner(const Identifier id) const
526 {
527  return m_emHelper->is_em_endcap_inner(id);
528 }
529 
530 //----------------------------------------------------------------------------
531 inline bool CaloCell_Base_ID::is_em_endcap_outer(const Identifier id) const
532 {
533  return m_emHelper->is_em_endcap_outer(id);
534 }
535 
536 //----------------------------------------------------------------------------
537 inline bool CaloCell_Base_ID::is_hec(const Identifier id) const
538 {
539  return m_emHelper->is_lar_hec(id);
540 }
541 
542 //----------------------------------------------------------------------------
543 inline bool CaloCell_Base_ID::is_hec(const IdentifierHash caloHash) const
544 {
545  bool result=false;
546  if(caloHash >= m_cell_min[LARHEC] &&
547  caloHash < m_cell_max[LARHEC] ) result=true;
548  return result;
549 }
550 
551 //----------------------------------------------------------------------------
552 inline bool CaloCell_Base_ID::is_fcal(const Identifier id) const
553 {
554  return m_emHelper->is_lar_fcal(id);
555 }
556 
557 //----------------------------------------------------------------------------
558 inline bool CaloCell_Base_ID::is_fcal(const IdentifierHash caloHash) const
559 {
560  bool result=false;
561  if(caloHash >= m_cell_min[LARFCAL] && caloHash < m_cell_max[LARFCAL] ) result=true;
562  return result;
563 }
564 
565 //----------------------------------------------------------------------------
566 inline bool CaloCell_Base_ID::is_minifcal(const Identifier id) const
567 {
568  return m_emHelper->is_lar_minifcal(id);
569 }
570 
571 //----------------------------------------------------------------------------
572 inline bool CaloCell_Base_ID::is_minifcal(const IdentifierHash caloHash) const
573 {
574  bool result=false;
575  if(caloHash >= m_cell_min[LARMINIFCAL] && caloHash < m_cell_max[LARMINIFCAL] ) result=true;
576  return result;
577 }
578 
579 //----------------------------------------------------------------------------
580 inline bool CaloCell_Base_ID::is_tile(const ExpandedIdentifier& id) const
581 {
582  return m_emHelper->is_tile(id);
583 }
584 
585 //----------------------------------------------------------------------------
586 inline bool CaloCell_Base_ID::is_tile(const Identifier id) const
587 {
588  return m_emHelper->is_tile(id);
589 }
590 
591 //----------------------------------------------------------------------------
592 inline bool CaloCell_Base_ID::is_tile(const IdentifierHash caloHash) const
593 {
594  bool result=false;
595  if(caloHash >= m_cell_min[TILE] && caloHash < m_cell_max[TILE] ) result=true;
596  return result;
597 }
598 
599 //----------------------------------------------------------------------------
600 inline bool CaloCell_Base_ID::is_tile_barrel(const Identifier id) const
601 {
602  return m_tileHelper->is_tile_barrel(id);
603 }
604 
605 //----------------------------------------------------------------------------
606 inline bool CaloCell_Base_ID::is_tile_extbarrel(const Identifier id) const
607 {
608  return m_tileHelper->is_tile_extbarrel(id);
609 }
610 
611 //----------------------------------------------------------------------------
612 inline bool CaloCell_Base_ID::is_tile_gap(const Identifier id) const
613 {
614  return m_tileHelper->is_tile_gap(id);
615 }
616 
617 //----------------------------------------------------------------------------
618 inline bool CaloCell_Base_ID::is_tile_gapscin(const Identifier id) const
619 {
620  return m_tileHelper->is_tile_gapscin(id);
621 }
622 
623 //----------------------------------------------------------------------------
624 inline bool CaloCell_Base_ID::is_tile_positive(const Identifier id) const
625 {
626  return m_tileHelper->is_positive(id);
627 }
628 
629 //----------------------------------------------------------------------------
630 inline bool CaloCell_Base_ID::is_tile_negative(const Identifier id) const
631 {
632  return m_tileHelper->is_negative(id);
633 }
634 
635 //----------------------------------------------------------------------------
636 inline int CaloCell_Base_ID::sub_calo (const Identifier id)const
637 {
638  if(m_emHelper->is_lar_em(id)) {
639  return LAREM;
640  }
641  else if(m_emHelper->is_lar_hec(id)) {
642  return LARHEC;
643  }
644  else if(m_emHelper->is_lar_minifcal(id)) {
645  // must do minifcal before fcal because miniFCAL IS FCAL
646  return LARMINIFCAL;
647  }
648  else if(m_emHelper->is_lar_fcal(id)) {
649  return LARFCAL;
650  }
651  else if(m_emHelper->is_tile(id)) {
652  return TILE;
653  }
654  else {
655  return(NOT_VALID);
656  }
657 }
658 
659 //----------------------------------------------------------------------------
660 inline int CaloCell_Base_ID::sub_calo (const IdentifierHash caloHash)const
661 {
662  int result = NOT_VALID;
663  if(caloHash < m_cell_max[LAREM]) {
664  result = LAREM;
665  }
666  else if(caloHash < m_cell_max[LARHEC] ) {
667  result = LARHEC;
668  }
669  else if(caloHash < m_cell_max[LARFCAL] ) {
670  result = LARFCAL;
671  }
672  else if(caloHash < m_cell_max[TILE] ) {
673  result = TILE;
674  }
675  else if(caloHash < m_cell_max[LARMINIFCAL] ) {
676  result = LARMINIFCAL;
677  }
678  return result;
679 }
680 
681 //----------------------------------------------------------------------------
682 inline int CaloCell_Base_ID::pos_neg (const Identifier id)const
683 {
684  if(m_emHelper->is_lar_em(id)) {
685  return m_emHelper->barrel_ec(id);
686  }
687  else if(m_emHelper->is_lar_hec(id)) {
688  return m_hecHelper->pos_neg(id);
689  }
690  else if(m_emHelper->is_lar_minifcal(id)) {
691  // must do minifcal before fcal because miniFCAL IS FCAL
692  return m_minifcalHelper->pos_neg(id);
693  }
694  else if(m_emHelper->is_lar_fcal(id)) {
695  return m_fcalHelper->pos_neg(id);
696  }
697  else {
698  return(NOT_VALID);
699  }
700 }
701 
702 //----------------------------------------------------------------------------
703 inline int CaloCell_Base_ID::section (const Identifier id)const
704 {
705  if(m_emHelper->is_tile(id)) {
706  return m_tileHelper->section(id);
707  }
708  else {
709  return(NOT_VALID);
710  }
711 }
712 
713 //----------------------------------------------------------------------------
714 inline int CaloCell_Base_ID::sampling (const Identifier id)const
715 {
716  if(m_emHelper->is_lar_em(id)) {
717  return m_emHelper->sampling(id);
718  }
719  else if(m_emHelper->is_lar_hec(id)) {
720  return m_hecHelper->sampling(id);
721  }
722  else if(m_emHelper->is_lar_minifcal(id)) {
723  // must do minifcal before fcal because miniFCAL IS FCAL
724  return m_minifcalHelper->depth(id);
725  }
726  else if(m_emHelper->is_lar_fcal(id)) {
727  return m_fcalHelper->module(id);
728  }
729  else {
730  return(NOT_VALID);
731  }
732 }
733 
734 //----------------------------------------------------------------------------
735 inline int CaloCell_Base_ID::side (const Identifier id)const
736 {
737  if(m_emHelper->is_tile(id)) {
738  return m_tileHelper->side(id);
739  }
740  else {
741  return(NOT_VALID);
742  }
743 }
744 
745 //----------------------------------------------------------------------------
746 inline int CaloCell_Base_ID::region (const Identifier id)const
747 {
748  if(m_emHelper->is_lar_em(id)) {
749  return m_emHelper->region(id);
750  }
751  else if(m_emHelper->is_lar_hec(id)) {
752  return m_hecHelper->region(id);
753  }
754  else {
755  return(NOT_VALID);
756  }
757 }
758 
759 //----------------------------------------------------------------------------
760 inline int CaloCell_Base_ID::module (const Identifier id)const
761 {
762  if(m_emHelper->is_tile(id)) {
763  return m_tileHelper->module(id);
764  }
765  else {
766  return(NOT_VALID);
767  }
768 }
769 
770 //----------------------------------------------------------------------------
771 inline int CaloCell_Base_ID::eta(const Identifier id)const
772 {
773  if(m_emHelper->is_lar_em(id)) {
774  return m_emHelper->eta(id);
775  }
776  else if(m_emHelper->is_lar_hec(id)) {
777  return m_hecHelper->eta(id);
778  }
779  else if(m_emHelper->is_lar_minifcal(id)) {
780  // must do minifcal before fcal because miniFCAL IS FCAL
781  return m_minifcalHelper->eta(id);
782  }
783  else if(m_emHelper->is_lar_fcal(id)) {
784  return m_fcalHelper->eta(id);
785  }
786  else {
787  return(NOT_VALID);
788  }
789 }
790 
791 //----------------------------------------------------------------------------
792 inline int CaloCell_Base_ID::tower(const Identifier id)const
793 {
794  if(m_emHelper->is_tile(id)) {
795  return m_tileHelper->tower(id);
796  }
797  else {
798  return(NOT_VALID);
799  }
800 }
801 
802 //----------------------------------------------------------------------------
803 inline int CaloCell_Base_ID::phi(const Identifier id)const
804 {
805  if(m_emHelper->is_lar_em(id)) {
806  return m_emHelper->phi(id);
807  }
808  else if(m_emHelper->is_lar_hec(id)) {
809  return m_hecHelper->phi(id);
810  }
811  else if(m_emHelper->is_lar_minifcal(id)) {
812  // must do minifcal before fcal because miniFCAL IS FCAL
813  return m_minifcalHelper->phi(id);
814  }
815  else if(m_emHelper->is_lar_fcal(id)) {
816  return m_fcalHelper->phi(id);
817  }
818  else {
819  return(NOT_VALID);
820  }
821 }
822 
823 //----------------------------------------------------------------------------
824 inline int CaloCell_Base_ID::sample(const Identifier id)const
825 {
826  if(m_emHelper->is_tile(id)) {
827  return m_tileHelper->sample(id);
828  }
829  else {
830  return(NOT_VALID);
831  }
832 }
833 
834 //----------------------------------------------------------------------------
835 inline bool CaloCell_Base_ID::is_supercell(const Identifier id)const
836 {
837  if(m_emHelper->is_lar_em(id)) {
838  return m_emHelper->is_supercell(id);
839  }
840  else if(is_hec(id)) {
841  return m_hecHelper->is_supercell(id);
842  }
843  else if(m_emHelper->is_lar_fcal(id)) {
844  return m_fcalHelper->is_supercell(id);
845  }
846  else if(is_tile(id)) {
847  return m_tileHelper->is_supercell(id);
848  }
849 
850  return false;
851 }
852 
853 //----------------------------------------------------------------------------
854 inline int CaloCell_Base_ID::eta_min(const Identifier regId) const
855 {
856  if(m_emHelper->is_lar_em(regId)) {
857  return m_emHelper->eta_min(regId);
858  }
859  else if(m_emHelper->is_lar_hec(regId)) {
860  return m_hecHelper->eta_min(regId);
861  }
862  else if(m_emHelper->is_lar_minifcal(regId)) {
863  // must do minifcal before fcal because miniFCAL IS FCAL
864  return m_minifcalHelper->eta_min(regId);
865  }
866  else if(m_emHelper->is_lar_fcal(regId)) {
867  return m_fcalHelper->eta_min(regId);
868  }
869  else if(m_emHelper->is_tile(regId)) {
870  return m_tileHelper->eta_min(regId);
871  }
872  else {
873  return(NOT_VALID);
874  }
875 }
876 
877 //----------------------------------------------------------------------------
878 inline int CaloCell_Base_ID::eta_max(const Identifier regId) const
879 {
880  if(m_emHelper->is_lar_em(regId)) {
881  return m_emHelper->eta_max(regId);
882  }
883  else if(m_emHelper->is_lar_hec(regId)) {
884  return m_hecHelper->eta_max(regId);
885  }
886  else if(m_emHelper->is_lar_minifcal(regId)) {
887  // must do minifcal before fcal because miniFCAL IS FCAL
888  return m_minifcalHelper->eta_max(regId);
889  }
890  else if(m_emHelper->is_lar_fcal(regId)) {
891  return m_fcalHelper->eta_max(regId);
892  }
893  else if(m_emHelper->is_tile(regId)) {
894  return m_tileHelper->eta_max(regId);
895  }
896  else {
897  return(NOT_VALID);
898  }
899 }
900 
901 //----------------------------------------------------------------------------
902 inline int CaloCell_Base_ID::phi_min(const Identifier regId) const
903 {
904  if(m_emHelper->is_lar_em(regId)) {
905  return m_emHelper->phi_min(regId);
906  }
907  else if(m_emHelper->is_lar_hec(regId)) {
908  return m_hecHelper->phi_min(regId);
909  }
910  else if(m_emHelper->is_lar_minifcal(regId)) {
911  // must do minifcal before fcal because miniFCAL IS FCAL
912  return m_minifcalHelper->phi_min(regId);
913  }
914  else if(m_emHelper->is_lar_fcal(regId)) {
915  return m_fcalHelper->phi_min(regId);
916  }
917  else {
918  return(NOT_VALID);
919  }
920 }
921 
922 //----------------------------------------------------------------------------
923 inline int CaloCell_Base_ID::phi_max(const Identifier regId) const
924 {
925  if(m_emHelper->is_lar_em(regId)) {
926  return m_emHelper->phi_max(regId);
927  }
928  else if(m_emHelper->is_lar_hec(regId)) {
929  return m_hecHelper->phi_max(regId);
930  }
931  else if(m_emHelper->is_lar_minifcal(regId)) {
932  // must do minifcal before fcal because miniFCAL IS FCAL
933  return m_minifcalHelper->phi_max(regId);
934  }
935  else if(m_emHelper->is_lar_fcal(regId)) {
936  return m_fcalHelper->phi_max(regId);
937  }
938  else if(m_emHelper->is_tile(regId)) {
939  return m_tileHelper->phi_max(regId);
940  }
941  else {
942  return(NOT_VALID);
943  }
944 }
945 
946 //----------------------------------------------------------------------------
947 inline float CaloCell_Base_ID::etaGranularity(const Identifier regId) const
948 {
949  int subcalo = 0;
950  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
951  if (regHash == NOT_VALID) return NOT_VALID;
952  return m_helpers[subcalo]->etaGranularity (regHash);
953 }
954 
955 //----------------------------------------------------------------------------
956 inline float CaloCell_Base_ID::phiGranularity(const Identifier regId) const
957 {
958  int subcalo = 0;
959  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
960  if (regHash == NOT_VALID) return NOT_VALID;
961  return m_helpers[subcalo]->phiGranularity (regHash);
962 }
963 
964 //----------------------------------------------------------------------------
965 inline float CaloCell_Base_ID::eta0(const Identifier regId) const
966 {
967  int subcalo = 0;
968  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
969  if (regHash == NOT_VALID) return NOT_VALID;
970  return m_helpers[subcalo]->eta0 (regHash);
971 }
972 
973 //----------------------------------------------------------------------------
974 inline float CaloCell_Base_ID::phi0(const Identifier regId) const
975 {
976  int subcalo = 0;
977  IdentifierHash regHash = subcalo_region_hash (regId, subcalo);
978  if (regHash == NOT_VALID) return NOT_VALID;
979  return m_helpers[subcalo]->phi0 (regHash);
980 }
981 
982 //---------------------------------------------------------------------------
983 inline int CaloCell_Base_ID::GetSubCaloName(const std::string& SubCaloName )const
984 {
985  if(SubCaloName=="LAREM"){
986  return(LAREM);
987  }
988  else if(SubCaloName=="LARHEC"){
989  return(LARHEC);
990  }
991  else if(SubCaloName=="LARMINIFCAL"){
992  return(LARMINIFCAL);
993  }
994  else if(SubCaloName=="LARFCAL"){
995  return(LARFCAL);
996  }
997  else if(SubCaloName=="TILE"){
998  return(TILE);
999  }
1000  else{
1001  return(NOT_VALID);
1002  }
1003 }
1004 
1005 
1006 //---------------------------------------------------------------------------
1007 inline
1008 CaloCell_Base_ID::SUBCALO
1009 CaloCell_Base_ID::get_subcalo (Identifier id) const
1010 {
1011  if (m_emHelper->is_lar_em(id))
1012  return LAREM;
1013  else if (m_emHelper->is_lar_hec(id))
1014  return LARHEC;
1015  else if (m_emHelper->is_lar_minifcal (id)) {
1016  // must do minifcal before fcal because miniFCAL IS FCAL
1017  return LARMINIFCAL;
1018  }
1019  else if (m_emHelper->is_lar_fcal (id))
1020  return LARFCAL;
1021  else if (m_emHelper->is_tile (id))
1022  return TILE;
1023  return NOT_VALID;
1024 }
Generated on Thu Nov 7 2024 21:11:11 for ATLAS Offline Software by   doxygen 1.8.18