ATLAS Offline Software
LArEM_Base_ID.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
11 #include <cmath>
12 
14 #include "LArEM_region.h"
15 #include "IdDict/IdDictDefs.h"
16 #include "CxxUtils/StrFormat.h"
17 #include "CxxUtils/trapping_fp.h"
18 
20 
21 
22 LArEM_Base_ID::LArEM_Base_ID (const std::string& name,
23  const std::string& group,
24  bool supercell)
25  : CaloIDHelper (name, group),
26  m_slar (supercell ? 1 : 0)
27 {
28 }
29 
30 
32 {
35  for (; first != last; ++first) delete (*first);
36 }
37 
39 {
40  return(m_slar_impl.unpack(id)) != 0;
41 }
42 
43 
44 int LArEM_Base_ID::eta_min(const Identifier regId) const
45 {
46  ExpandedIdentifier expId;
47  IdContext context = region_context();
48  if(!get_expanded_id(regId, expId, &context)) {
49  int result = -999;
50  for (unsigned int i = 0; i < m_full_em_range.size(); ++i) {
51  const Range& range = m_full_em_range[i];
52  if (range.match(expId)) {
53  const Range::field& eta_field = range[m_ETA_INDEX];
54  if (not eta_field.empty()) {
55  int etamin = eta_field.get_minimum();
56  if (-999 == result) {
57  result = etamin;
58  }
59  else {
60  if (etamin < result) result = etamin;
61  }
62  }
63  }
64  }
65  return (result);
66  }
67  return (-999);
68 }
69 
70 int LArEM_Base_ID::eta_max(const Identifier regId) const
71 {
72  ExpandedIdentifier expId;
73  IdContext context = region_context();
74  if(!get_expanded_id(regId, expId, &context)) {
75  int result = -999;
76  for (unsigned int i = 0; i < m_full_em_range.size(); ++i) {
77  const Range& range = m_full_em_range[i];
78  if (range.match(expId)) {
79  const Range::field& eta_field = range[m_ETA_INDEX];
80  if (not eta_field.empty()) {
81  int etamax = eta_field.get_maximum();
82  if (result < etamax) result = etamax;
83  }
84  }
85  }
86  return (result);
87  }
88  return (-999); // default
89 }
90 
92 {
93  ExpandedIdentifier expId;
94  IdContext region_cntxt = region_context();
95  if(!get_expanded_id(regId, expId, &region_cntxt)) {
96  int result = -999;
97  for (unsigned int i = 0; i < m_full_em_range.size(); ++i) {
98  const Range& range = m_full_em_range[i];
99  if (range.match(expId)) {
100  const Range::field& phi_field = range[m_PHI_INDEX];
101  if (not phi_field.empty()) {
102  int phimin = phi_field.get_minimum();
103  if (-999 == result) {
104  result = phimin;
105  }
106  else {
107  if (phimin < result) result = phimin;
108  }
109  }
110  }
111  }
112  return (result);
113  }
114  return (-999); // default
115 }
116 
117 int LArEM_Base_ID::phi_max(const Identifier regId) const
118 {
119  ExpandedIdentifier expId;
120  IdContext context = region_context();
121  if(!get_expanded_id(regId, expId, &context)) {
122  int result = -999;
123  for (unsigned int i = 0; i < m_full_em_range.size(); ++i) {
124  const Range& range = m_full_em_range[i];
125  if (range.match(expId)) {
126  const Range::field& phi_field = range[m_PHI_INDEX];
127  if (not phi_field.empty()) {
128  int phimax = phi_field.get_maximum();
129  if (result < phimax) result = phimax;
130  }
131  }
132  }
133  return (result);
134  }
135  return (-999); // default
136 }
137 
138 void LArEM_Base_ID::region_id_checks ( int barrel_ec, int sampling, int region ) const
139 {
140  // Check that id is within allowed range
141 
142  // Fill expanded id
144  expId << barrel_ec << sampling << region ;
145 
146  if (!m_full_region_range.match(expId)) {
147  std::string errorMessage = "LArEM_Base_ID::region_id_checks() result is not OK: ID, range = "
148  + std::string(expId) + " , " + (std::string)m_full_region_range;
149  throw LArID_Exception(errorMessage , 5);
150  }
151 }
152 
153 
154 void LArEM_Base_ID::channel_id_checks ( int barrel_ec, int sampling, int region,
155  int eta, int phi ) const
156 {
157  // Check that id is within allowed range
158 
159  // Fill expanded id
161  expId << barrel_ec << sampling << region << eta << phi << m_slar ;
162 
163  if (!m_full_em_range.match(expId)) {
164  std::string errorMessage = "LArEM_Base_ID::channel_id_checks() result is not OK: ID, range = "
165  + std::string(expId) + " , " + (std::string)m_full_em_range;
166  throw LArID_Exception(errorMessage , 6);
167  }
168 }
169 
171  int eta, int phi ) const
172 {
173  // Check that id is within allowed range
174 
175  // Fill expanded id
176  ExpandedIdentifier expId;
177 
178  IdContext context = region_context();
179  if (get_expanded_id(regionId, expId, &context)) {
180  std::string errorMessage = "LArEM_Base_ID::channel_id_checks(regId) result is not OK: ID = "
181  + show_to_string(regionId) ;
182  throw LArID_Exception(errorMessage , 6);
183  }
184 
185  expId << eta << phi << m_slar;
186 
187  if (!m_full_em_range.match(expId)) {
188  std::string errorMessage = "LArEM_Base_ID::channel_id_checks(regId) result is not OK: ID, range = "
189  + std::string(expId) + " , " + (std::string)m_full_em_range;
190  throw LArID_Exception(errorMessage , 6);
191  }
192 }
193 
194 
195 
196 
197 int LArEM_Base_ID::get_expanded_id (const Identifier& id, ExpandedIdentifier& exp_id, const IdContext* context) const
198 {
199  // We assume that the context is >= region
200  exp_id.clear();
201  exp_id << lar_field_value()
202  << lar_em_field_value()
203  << barrel_ec(id)
204  << sampling(id)
205  << region(id);
206  if(context && context->end_index() >= m_ETA_INDEX) {
207  exp_id << eta(id);
208  if(context->end_index() >= m_PHI_INDEX) {
209  exp_id << phi(id);
210  if ( context->end_index() >= m_SLAR_INDEX) {
211  exp_id << (unsigned)is_supercell(id);
212  }
213  }
214  }
215  return (0);
216 }
217 
219 {
220  MsgStream log(m_msgSvc, "LArEM_Base_ID" );
221  if(!dict()) {
222  if(m_msgSvc) {
223  log << MSG::ERROR << "initLevelsFromDict - dictionary NOT initialized "
224  << endmsg;
225  }
226  else {
227  std::cout << "LArEM_Base_ID::initLevelsFromDict - dictionary NOT initialized "
228  << std::endl ;
229  }
230  return (1);
231  }
232 
233  // Find out which identifier field corresponds to each level.
234 
235  m_LAR_INDEX = 999 ;
236  m_EM_INDEX = 999 ;
237  m_BEC_INDEX = 999 ;
238  m_SAMPLING_INDEX = 999 ;
239  m_REGION_INDEX = 999 ;
240  m_ETA_INDEX = 999 ;
241  m_PHI_INDEX = 999 ;
242  m_SLAR_INDEX = 999 ;
243 
244  // Find a EM region
245  IdDictField* field = dict()->find_field("subdet") ;
246  if (field) {
247  m_LAR_INDEX = field->m_index ;
248  }
249  else {
250  if(m_msgSvc) {
251  log << MSG::ERROR << "initLevelsFromDict - unable to find 'subdet' field "
252  << endmsg;
253  }
254  else {
255  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'subdet' field "
256  << std::endl ;
257  }
258  return (1);
259  }
260 
261  field = dict()->find_field("part") ;
262  if (field) {
263  m_EM_INDEX = field->m_index ;
264  }
265  else {
266  if(m_msgSvc) {
267  log << MSG::ERROR << "initLevelsFromDict - unable to find 'part' field "
268  << endmsg;
269  }
270  else {
271  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'part' field "
272  << std::endl ;
273  }
274  return (1);
275  }
276 
277  field = dict()->find_field("barrel-endcap") ;
278  if (field) {
279  m_BEC_INDEX = field->m_index ;
280  }
281  else {
282  if(m_msgSvc) {
283  log << MSG::ERROR << "initLevelsFromDict - unable to find 'barrel-endcap' field "
284  << endmsg;
285  }
286  else {
287  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'barrel-endcap' field "
288  << std::endl ;
289  }
290  return (1);
291  }
292 
293  field = dict()->find_field("sampling") ;
294  if (field) {
295  m_SAMPLING_INDEX = field->m_index ;
296  }
297  else {
298  if(m_msgSvc) {
299  log << MSG::ERROR << "initLevelsFromDict - unable to find 'sampling' field "
300  << endmsg;
301  }
302  else {
303  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'sampling' field "
304  << std::endl ;
305  }
306  return (1);
307  }
308 
309  field = dict()->find_field("region") ;
310  if (field) {
311  m_REGION_INDEX = field->m_index ;
312  }
313  else {
314  if(m_msgSvc) {
315  log << MSG::ERROR << "initLevelsFromDict - unable to find 'region' field "
316  << endmsg;
317  }
318  else {
319  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'region' field "
320  << std::endl ;
321  }
322  return (1);
323  }
324 
325  field = dict()->find_field("eta") ;
326  if (field) {
327  m_ETA_INDEX = field->m_index ;
328  }
329  else {
330  if(m_msgSvc) {
331  log << MSG::ERROR << "initLevelsFromDict - unable to find 'eta' field "
332  << endmsg;
333  }
334  else {
335  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'eta' field "
336  << std::endl ;
337  }
338  return (1);
339  }
340 
341  field = dict()->find_field("phi") ;
342  if (field) {
343  m_PHI_INDEX = field->m_index ;
344  }
345  else {
346  if(m_msgSvc) {
347  log << MSG::ERROR << "initLevelsFromDict - unable to find 'phi' field "
348  << endmsg;
349  }
350  else {
351  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'phi' field "
352  << std::endl ;
353  }
354  return (1);
355  }
356 
357  field = dict()->find_field("is-slar") ;
358  if (field) {
359  m_SLAR_INDEX = field->m_index ;
360  }
361  else {
362  if(m_msgSvc) {
363  log << MSG::ERROR << "initLevelsFromDict - unable to find 'is-slar' field "
364  << endmsg;
365  }
366  else {
367  std::cout << "LArEM_Base_ID::initLevelsFromDict - unable to find 'is-slar' field "
368  << std::endl ;
369  }
370  return (1);
371  }
372 
373  // Set the field implementations
374 
376  if ( !group ){
377  log << MSG::ERROR << "initLevelsFromDict - cannot find " << group_name
378  << " group' field " << endmsg;
379  }
380  else {
381  m_em_region_index = group->regions()[0]->m_index;
382  }
384 
385  m_lar_impl = region.m_implementation[m_LAR_INDEX];
386  m_em_impl = region.m_implementation[m_EM_INDEX];
387  m_bec_impl = region.m_implementation[m_BEC_INDEX];
388  m_sampling_impl = region.m_implementation[m_SAMPLING_INDEX];
389  m_region_impl = region.m_implementation[m_REGION_INDEX];
390  m_eta_impl = region.m_implementation[m_ETA_INDEX];
391  m_phi_impl = region.m_implementation[m_PHI_INDEX];
392  m_slar_impl = region.m_implementation[m_SLAR_INDEX];
393 
394  if (!m_quiet) {
395  if(m_msgSvc) {
396  log << MSG::DEBUG << "decode index and bit fields for each level: " << endmsg;
397  log << MSG::DEBUG << "lar " << m_lar_impl.show_to_string() << endmsg;
398  log << MSG::DEBUG << "em " << m_em_impl.show_to_string() << endmsg;
399  log << MSG::DEBUG << "bec " << m_bec_impl.show_to_string() << endmsg;
400  log << MSG::DEBUG << "samp " << m_sampling_impl.show_to_string() << endmsg;
401  log << MSG::DEBUG << "reg " << m_region_impl.show_to_string() << endmsg;
402  log << MSG::DEBUG << "eta " << m_eta_impl.show_to_string() << endmsg;
403  log << MSG::DEBUG << "phi " << m_phi_impl.show_to_string() << endmsg;
404  log << MSG::DEBUG << "is-slar " << m_slar_impl.show_to_string() << endmsg;
405  }
406  else {
407  std::cout << "decode index and bit fields for each level: " << std::endl;
408  std::cout << "lar " << m_lar_impl.show_to_string() << std::endl;
409  std::cout << "em " << m_em_impl.show_to_string() << std::endl;
410  std::cout << "bec " << m_bec_impl.show_to_string() << std::endl;
411  std::cout << "samp " << m_sampling_impl.show_to_string() << std::endl;
412  std::cout << "reg " << m_region_impl.show_to_string() << std::endl;
413  std::cout << "eta " << m_eta_impl.show_to_string() << std::endl;
414  std::cout << "phi " << m_phi_impl.show_to_string() << std::endl;
415  std::cout << "is-slar " << m_slar_impl.show_to_string() << std::endl;
416  }
417  }
418 
419 
420  return(0) ;
421 }
422 
423 
425 {
426  if (channels().init (*this, "channels",
428  m_SLAR_INDEX))
429  return 1;
430  if (regions().init (*this, "regions",
433  return 1;
434 
435  return (0);
436 }
437 
438 
439 int
441  const std::string& group_name)
442 /*=================================================================*/
443 {
444  MsgStream log(m_msgSvc, "LArEM_Base_ID" );
445 
446  log << MSG::DEBUG << "initialize_base_from_dictionary" << endmsg;
447 
448  // Check whether this helper should be reinitialized
449  if (!reinitialize(dict_mgr)) {
450  log << MSG::DEBUG << "Request to reinitialize not satisfied - tags have not changed" << endmsg;
451  return (0);
452  }
453  else {
454  if(m_msgSvc)log << MSG::DEBUG << "(Re)initialize" << endmsg;
455  }
456 
457  // init base object
459  "LArCalorimeter"))
460  return (1);
461 
462  // initialize dictionary version
463  AtlasDetectorID::setDictVersion(dict_mgr, "LArCalorimeter");
464 
465  // Initialize the field indices
466  if (initLevelsFromDict(group_name)) return (1);
467 
468  // Find value for the field LAr Calorimeter
469  const IdDictDictionary* atlasDict = dict_mgr.find_dictionary ("ATLAS");
470  int larField = -1;
471  if (atlasDict->get_label_value("subdet", "LArCalorimeter", larField)) {
472  if(m_msgSvc) {
473  log << MSG::ERROR << "Could not get value for label 'LArCalorimeter' of field 'subdet' in dictionary "
474  << atlasDict->m_name
475  << endmsg;
476  }
477  else {
478  std::cout << "Could not get value for label 'LArCalorimeter' of field 'subdet' in dictionary "
479  << atlasDict->m_name
480  << std::endl;
481  }
482  return (1);
483  }
484 
485  // Find value for the field LArEM
486  int larEmField = -1;
487  if (dict()->get_label_value("part", "LArEM", larEmField)) {
488  if(m_msgSvc) {
489  log << MSG::ERROR << "Could not get value for label 'LArEM' of field 'part' in dictionary "
490  << dict()->m_name
491  << endmsg;
492  }
493  else {
494  std::cout << "Could not get value for label 'LArEM' of field 'part' in dictionary "
495  << dict()->m_name
496  << std::endl;
497  }
498  return (1);
499  }
500 
501  // Set up id for region and range prefix
502  ExpandedIdentifier reg_id;
503  reg_id.add(larField);
504  reg_id.add(larEmField);
505  Range prefix;
506 
508  m_full_region_range = dict()->build_multirange(reg_id, group_name, prefix, "region");
509 
510  if (!m_quiet) {
511  if(m_msgSvc) {
512  log << MSG::DEBUG << " initialize_from_dict : "
513  << endmsg;
514  log << MSG::DEBUG << " region range -> " << (std::string)m_full_region_range
515  << endmsg;
516  log << MSG::DEBUG << " channel range -> " << (std::string)m_full_em_range
517  << endmsg;
518  }
519  else {
520  std::cout << " LArEM_Base_ID::initialize_from_dict : "
521  << std::endl;
522  std::cout << " region range -> " << (std::string)m_full_region_range
523  << std::endl;
524  std::cout << " channel range -> " << (std::string)m_full_em_range
525  << std::endl;
526  }
527  }
528 
529  // initialize m_two_sym_sides
530  m_two_sym_sides = ( dictionaryVersion() == "fullAtlas" );
531 
532 
533  // Setup the hash tables
534  if(init_hashes()) return (1);
535 
536  // initialize dictionary regions
537  if (fill_vec_of_dict_regions (group_name)) return 1;
538 
539  m_vecOfPhiMin.resize(regions().hash_max());
540  for (unsigned int i = 0; i < regions().hash_max(); ++i) {
541  Identifier regId = region_id(i);
542  m_vecOfPhiMin[i] = phi_min_init(regId);
543  }
544 
545 
546  // Setup for hash calculation
547 
548  // We use the structure of the region definitions in the
549  // dictionary to optimize. Specifically, each dict region
550  // corresponds to two regions of uniform eta/phi granularity (+/-
551  // in barrel/endcap). The lookup table only needs to contain the
552  // hash offset for each region and the number of phi cells.
553 
554  // The implementation requires:
555 
556  // 1) a lookup table for each region containing hash offset and
557  // nphi
558  // 2) a decoder to access the "index" corresponding to the
559  // bec/samp/reg fields. These fields use 8 bits, so the
560  // vector has a length of 256 for only 36 regions.
561 
562 
563  // Create decoder for fields bec to region
565  m_bec_impl.bits() +
569  m_bec_reg_impl.set_bits(bits, bits_offset);
570 
571  // std::cout << "bec_reg " << m_bec_reg_impl.decode_index() << " "
572  // << (std::string)m_bec_reg_impl.ored_field() << " "
573  // << std::hex << m_bec_reg_impl.mask() << " "
574  // << m_bec_reg_impl.zeroing_mask() << " "
575  // << std::dec << m_bec_reg_impl.shift()
576  // << " " << m_bec_reg_impl.bits() << " " <<m_bec_reg_impl.bits_offset()
577  // << std::endl;
578 
579 
580  // Set up vector as lookup table for hash calculation.
581  m_hash_calcs.resize(256);
582  for (unsigned int i = 0; i < m_full_em_range.size(); ++i) {
583  const Range* range = &m_full_em_range[i];
584  ExpandedIdentifier exp_id = range->minimum ();
585  HashCalc hc;
586 
588  exp_id[m_SAMPLING_INDEX],
589  exp_id[m_REGION_INDEX],
590  exp_id[m_ETA_INDEX],
591  exp_id[m_PHI_INDEX]);
593  hc.m_hash = min_neg;
594  Identifier minReg = region_id(min) ;
595  hc.m_etamin = eta_min(minReg);
596  hc.m_phimin = phi_min(minReg);
597  hc.m_nphi = (*range)[m_PHI_INDEX].get_indices();
599 
600  // Flip sign for bec if 2 symmetric sides (ATLAS case, not TB)
601  if(m_two_sym_sides) {
602  Identifier min1 = channel_id (-exp_id[m_BEC_INDEX],
603  exp_id[m_SAMPLING_INDEX],
604  exp_id[m_REGION_INDEX],
605  exp_id[m_ETA_INDEX],
606  exp_id[m_PHI_INDEX]);
608  hc.m_hash = min_pos;
609  m_hash_calcs[m_bec_reg_impl.unpack(min1)] = hc;
610  }
611 
612 
613  if (m_bec_reg_impl.unpack(min) > 255) {
614  if(m_msgSvc) {
615  log << MSG::WARNING << "min > 255 "
616  << i << " "
617  << show_to_string(min) << " "
618  << m_bec_reg_impl.unpack(min) << " "
619  << endmsg;
620  }
621  else {
622  std::cout << "min > 255 "
623  << i << " "
624  << show_to_string(min) << " "
625  << m_bec_reg_impl.unpack(min) << " "
626  << std::endl;
627  }
628  }
629  }
630 
631 // Some detailed printout
632 // ExpandedIdentifier exp_id = range->maximum ();
633 // Identifier max = channel_id (exp_id[m_BEC_INDEX],
634 // exp_id[m_SAMPLING_INDEX],
635 // exp_id[m_REGION_INDEX],
636 // exp_id[m_ETA_INDEX],
637 // exp_id[m_PHI_INDEX]);
638 // Identifier max0 = channel_id (-exp_id[m_BEC_INDEX],
639 // exp_id[m_SAMPLING_INDEX],
640 // exp_id[m_REGION_INDEX],
641 // exp_id[m_ETA_INDEX],
642 // exp_id[m_PHI_INDEX]);
643 // std::cout << "channel ranges, id, hash "
644 // << i << " "
645 // << show_to_string(min) << " "
646 // << show_to_string(max0) << " "
647 // << show_to_string(min1) << " "
648 // << show_to_string(max) << " "
649 // << channel_hash_binary_search(min) << " "
650 // << channel_hash_binary_search(min1) << " "
651 // << min_pos << " "
652 // << range->cardinality() << " "
653 // << std::endl;
654 // }
655 
656  // Check hash calculation
657  for (unsigned int i = 0; i < channels().hash_max(); ++i) {
658  Identifier id = channel_id(i);
659  if (channel_hash(id) != i) {
660  if(m_msgSvc) {
661  log << MSG::ERROR << "channel ranges, id, hash "
662  << show_to_string(id) << " "
663  << channel_hash(id) << " "
664  << i
665  << endmsg;
666  }
667  else {
668  std::cout << " ***** Error ";
669  std::cout << "channel ranges, id, hash "
670  << show_to_string(id) << " "
671  << channel_hash(id) << " "
672  << i
673  << std::endl;
674  }
675  }
676  }
677 
678  // Setup hash tables for finding neighbors (at the end of initialisation,
679  // to benefit from optimization
680  if(m_do_neighbours) {
681  if(init_neighbors()) return (1);
682  }
683 
684  return 0;
685 }
686 
687 
689  std::vector<IdentifierHash>& neighbourList) const
690 {
691  int result = 1;
692 
693  neighbourList.clear();
694 
695  if(!m_do_neighbours) {
696  if(m_msgSvc) {
697  MsgStream log(m_msgSvc, "LArEM_Base_ID" );
698  log << MSG::WARNING << "neighbours not initialized !!! returning empty list" << endmsg;
699  }
700  else {
701  std::cout << " WARNING: neighbours not initialized !!! returning empty list " << std::endl;
702  }
703  return result;
704  }
705 
706  if(id >= channel_hash_max()) {
707  if(m_msgSvc) {
708  MsgStream log(m_msgSvc, "LArEM_Base_ID" );
709  log << MSG::WARNING << "neighbours requested for non-existing channel -- id/max " << id << "/"
710  << channel_hash_max() << endmsg;
711  }
712  else {
713  std::cout << " neighbours requested for non-existing channel -- id/max " << id << "/"
714  << channel_hash_max() << std::endl;
715  }
716  return result;
717  }
718 
719  const short int maxNeighb=22;
720  IdentifierHash neighbList[maxNeighb];
721  int neighbourIndex = 0;
722 
723  // cell index
724  unsigned int index=id;
725 
726  //
727  // .... find in which region is the cell
728  //
729  auto itr = std::upper_bound(m_cells.begin(), m_cells.end(), index);
730  unsigned short int regionN = (itr - m_cells.begin()) - 1;
731  assert (regionN < m_vecOfRegions.size());
732  // get pointer to this region
733  LArEM_region* emRegion = m_vecOfRegions[regionN];
734  // retrieve characteristic numbers for this region
735  short int nPhi = emRegion->phiN();
736  float gPhi = emRegion->phiGranularity();
737  unsigned int minHash = emRegion->hashMin();
738  unsigned int maxHash = emRegion->hashMax();
739 
740  bool corners2DOnly = ( (option & LArNeighbours::all2D)
742  //
743  // .... previous neighbour in phi
744  //
745  IdentifierHash prevNeighbInPhi=NOT_VALID_HASH;
746  if( (option & LArNeighbours::prevInPhi)
747  || corners2DOnly ){
748  if(!get_prevInPhi(emRegion, index, nPhi, minHash, neighbourIndex, neighbList)){
749  // always 1 and only 1 neighbour in phi in ATLAS, but 0 or 1 neighbour in phi in TB
750  prevNeighbInPhi=neighbList[neighbourIndex-1];
751  if( corners2DOnly ){
752  neighbourIndex--;
753  }
754  }
755  }
756 
757  //
758  // ....next neighbour in phi
759  //
760  IdentifierHash nextNeighbInPhi=NOT_VALID_HASH;
761  if( (option & LArNeighbours::nextInPhi)
762  || corners2DOnly ){
763  if(!get_nextInPhi(emRegion, index, nPhi, minHash, neighbourIndex, neighbList)){
764  // always 1 and only 1 neighbour in phi in ATLAS, but 0 or 1 neighbour in phi in TB
765  nextNeighbInPhi=neighbList[neighbourIndex-1];
766  if( corners2DOnly ){
767  neighbourIndex--;
768  }
769  }
770  }
771 
772  //
773  // ....previous neighbours in eta
774  //
775  unsigned int nPrevBiggerCell=NOT_VALID_HASH;
776  if( (option & LArNeighbours::prevInEta) ){
777  get_prevInEta(emRegion, index, nPhi, gPhi, minHash, neighbourIndex, neighbList, nPrevBiggerCell);
778  }
779 
780  //
781  // ....next neighbours in eta
782  //
783  unsigned int nNextBiggerCell=NOT_VALID_HASH;
784  if( (option & LArNeighbours::nextInEta) ){
785  get_nextInEta(emRegion, index, nPhi, gPhi, maxHash, neighbourIndex, neighbList, nNextBiggerCell);
786  }
787 
788  //
789  // ....corners in the same sampling
790  //
791  if( (option & LArNeighbours::corners2D) ){
792  if(prevNeighbInPhi != NOT_VALID_HASH){
793  unsigned int index1=prevNeighbInPhi;
794  int oldNeighbourIndex = neighbourIndex;
795  // allow only 1 corner cell in order to avoid the problem of
796  // non-mutual neighbourness
797  // since the cells come ordered in phi it should be the last cell for
798  // prevNeighbInPhi as starting points
799  get_prevInEta(emRegion, index1, nPhi, gPhi, minHash, neighbourIndex, neighbList, nPrevBiggerCell);
800  if ( neighbourIndex > oldNeighbourIndex+1 ) {
801  neighbList[oldNeighbourIndex] = neighbList[neighbourIndex-1];
802  neighbourIndex = oldNeighbourIndex+1;
803  }
804  oldNeighbourIndex = neighbourIndex;
805  get_nextInEta(emRegion, index1, nPhi, gPhi, maxHash, neighbourIndex, neighbList, nNextBiggerCell);
806  if ( neighbourIndex > oldNeighbourIndex+1 ) {
807  neighbList[oldNeighbourIndex] = neighbList[neighbourIndex-1];
808  neighbourIndex = oldNeighbourIndex+1;
809  }
810  }
811 
812  if(nextNeighbInPhi != NOT_VALID_HASH){
813  unsigned int index2=nextNeighbInPhi;
814  int oldNeighbourIndex = neighbourIndex;
815  // allow only 1 corner cell in order to avoid the problem of
816  // non-mutual neighbourness
817  // since the cells come ordered in phi it should be the 1st cell for
818  // nextNeighbInPhi
819  get_prevInEta(emRegion, index2, nPhi, gPhi, minHash, neighbourIndex, neighbList, nPrevBiggerCell);
820  if ( neighbourIndex > oldNeighbourIndex+1 ) {
821  neighbourIndex = oldNeighbourIndex+1;
822  }
823  oldNeighbourIndex = neighbourIndex;
824  get_nextInEta(emRegion, index2, nPhi, gPhi, maxHash, neighbourIndex, neighbList, nNextBiggerCell);
825  if ( neighbourIndex > oldNeighbourIndex+1 ) {
826  neighbourIndex = oldNeighbourIndex+1;
827  }
828  }
829  }
830 
831  //
832  // .... neighbours in sampling (common code)
833  // EM caracteristics = granularity changes in both eta and phi + partial overlap of samplings
834  //
835  if( (option & LArNeighbours::upAndDown) ) {
836  // granularity of the initial region
837  double gEta = (double)(emRegion->etaGranularity());
838  // initial eta
839  int nEta = int( (index-minHash) / nPhi);
840  double absEta = (double)(emRegion->etaMin()) + (double)(nEta * gEta);
841 
842  // previous neighbours in sampling
843  if( (option & LArNeighbours::prevInSamp) ){
844  get_prevInSamp(emRegion, index, nPhi, minHash, gEta, gPhi, absEta, neighbourIndex, neighbList);
845  }
846 
847  // next neighbours in sampling
848  if( (option & LArNeighbours::nextInSamp) ){
849  get_nextInSamp(emRegion, index, nPhi, minHash, gEta, gPhi, absEta, neighbourIndex, neighbList);
850  }
851  }
852 
853  //
854  // .... neighbours across subdet
855  //
857  // granularity of the initial region
858  double gEta = (double)(emRegion->etaGranularity());
859  // initial eta
860  int nEta = int( (index-minHash) / nPhi);
861  double absEta = (double)(emRegion->etaMin()) + (double)(nEta * gEta);
862 
863  // prev neighbours in subdet
864  if( (option & LArNeighbours::prevSubDet) ){
865  get_prevInSubdet(emRegion, index, nPhi, minHash, gEta, gPhi, absEta, neighbourIndex, neighbList);
866  }
867  // next neighbours in subdet
868  if( (option & LArNeighbours::nextSubDet) ){
869  get_nextInSubdet(emRegion, index, nPhi, minHash, gEta, gPhi, absEta, neighbourIndex, neighbList);
870  }
871  }
872 
873 
874  neighbourList.resize(neighbourIndex);
875  if (neighbourIndex > 0) {
876  if (neighbourIndex <= maxNeighb) {
877  std::copy (&neighbList[0], &neighbList[neighbourIndex], neighbourList.begin());
878  result = 0 ;
879  } else {
880  if(m_msgSvc) {
881  MsgStream log(m_msgSvc, "LArEM_Base_ID" );
882  log << MSG::WARNING << " more than 22 neighbours for this cell, NONE will be retained" << endmsg;
883  }
884  else {
885  std::cout << "WARNING: more than 22 neighbours for this cell, NONE will be retained " << neighbourIndex << std::endl;
886  }
887  }
888  }
889 
890  return result;
891 }
892 
893 
894 int LArEM_Base_ID::get_prevInPhi(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const unsigned int& minHash,
895  int& neighbourIndex, IdentifierHash* neighbList)
896 {
897  int result = 1;
898  unsigned int nIndex = index-1;
899  if(!emRegion->isPhiMin(index)) {
900  if( ((index-minHash)%(nPhi)) == 0 ) nIndex=index+nPhi-1;
901  IdentifierHash nHash = nIndex;
902  neighbList[neighbourIndex] = nHash;
903  neighbourIndex++;
904  result = 0;
905  }
906  return result;
907 }
908 
909 int LArEM_Base_ID::get_nextInPhi(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const unsigned int& minHash,
910  int& neighbourIndex, IdentifierHash* neighbList)
911 {
912  int result = 1;
913  if(!emRegion->isPhiMax(index)) {
914  unsigned int nIndex = index+1;
915  if( ((index-minHash+1)%(nPhi)) == 0 ) nIndex=index-nPhi+1;
916  IdentifierHash nHash = nIndex;
917  neighbList[neighbourIndex] = nHash;
918  neighbourIndex++;
919  result = 0;
920  }
921  return result;
922 }
923 
924 int LArEM_Base_ID::get_prevInEta(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const float& gPhi,
925  const unsigned int& minHash,
926  int& neighbourIndex, IdentifierHash* neighbList, unsigned int& nBiggerCell) const
927 {
928  int result = 1;
929 
930  unsigned int nIndex = 0;
931  IdentifierHash nHash = 0;
932 
933  if( emRegion->isEtaMin(index)){
934  // eta == etaMin -> go to previous region in eta
935  short int nPrevEtaRegion = emRegion->prevEtaRegion();
936  // no neighbour if no previous region in eta
937  if( nPrevEtaRegion != NOT_VALID_REGION ) {
938  LArEM_region* prevEmRegion = m_vecOfRegions[nPrevEtaRegion];
939  if(emRegion->isFirstBarrelRegion()) {
940  // special case: barrel middle
941  unsigned int minHashMinus = prevEmRegion->hashMin();
942  nIndex = minHashMinus + index-minHash ;
943  nHash = nIndex;
944  neighbList[neighbourIndex] = nHash;
945  neighbourIndex++;
946  result = 0;
947  }
948  else {
949  // Tell clang to optimize assuming that FP exceptions can trap.
950  // Otherwise, it can vectorize the division, which can lead to
951  // spurious division-by-zero traps from unused vector lanes.
953  short int nPhiMinus = prevEmRegion->phiN();
954  float gPhiMinus= prevEmRegion->phiGranularity();
955  unsigned int maxHashMinus = prevEmRegion->hashMax();
956  float phiMargin = 0.25*std::min(gPhi,gPhiMinus);
957  float rPhi = (index-minHash)*gPhi+emRegion->phiMin();
958  int nPhiMinusFirst = int(std::floor((rPhi -prevEmRegion->phiMin())
959  /gPhiMinus+phiMargin))
960  +maxHashMinus-nPhiMinus;
961  int nPhiMinusNext = int(std::floor((rPhi+gPhi-prevEmRegion->phiMin())
962  /gPhiMinus+phiMargin))
963  +maxHashMinus-nPhiMinus;
964  if ( nPhiMinusNext == nPhiMinusFirst ) nPhiMinusNext++;
965 
966  for(int i=nPhiMinusFirst; i<nPhiMinusNext; i++){
967  nIndex = i ;
968  if(nIndex != nBiggerCell) {
969  nHash = nIndex;
970  neighbList[neighbourIndex] = nHash;
971  neighbourIndex++;
972  result = 0;
973  }
974  // to avoid duplicated cells in corners
975  if(gPhi < gPhiMinus && nBiggerCell == NOT_VALID_HASH) nBiggerCell=nIndex;
976  }
977  }
978  }
979  }
980  else {
981  // stay in same region (1 neighbour)
982  nIndex = index - nPhi;
983  nHash = nIndex;
984  neighbList[neighbourIndex] = nHash;
985  neighbourIndex++;
986  result = 0;
987  }
988  return result;
989 }
990 
991 int LArEM_Base_ID::get_nextInEta(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const float& gPhi,
992  const unsigned int& maxHash,
993  int& neighbourIndex, IdentifierHash* neighbList, unsigned int& nBiggerCell) const
994 {
995  int result = 1;
996 
997  unsigned int nIndex = 0;
998  IdentifierHash nHash = 0;
999 
1000  if( emRegion->isEtaMax(index)){
1001  // eta == etaMax -> go to next region in eta
1002  short int nNextEtaRegion = emRegion->nextEtaRegion();
1003  // no neighbour if no next region in eta
1004  if( nNextEtaRegion != NOT_VALID_REGION ) {
1005  // Tell clang to optimize assuming that FP exceptions can trap.
1006  // Otherwise, it can vectorize the division, which can lead to
1007  // spurious division-by-zero traps from unused vector lanes.
1009  LArEM_region* nextEmRegion = m_vecOfRegions[nNextEtaRegion];
1010  float gPhiPlus= nextEmRegion->phiGranularity();
1011  unsigned int minHashPlus = nextEmRegion->hashMin();
1012  float phiMargin = 0.25*std::min(gPhi,gPhiPlus);
1013  float rPhi = (index+nPhi-maxHash)*gPhi+emRegion->phiMin();
1014  int nPhiPlusFirst = int(std::floor((rPhi -nextEmRegion->phiMin())
1015  /gPhiPlus+phiMargin))+minHashPlus;
1016  int nPhiPlusNext = int(std::floor((rPhi+gPhi-nextEmRegion->phiMin())
1017  /gPhiPlus+phiMargin))+minHashPlus;
1018  if ( nPhiPlusNext == nPhiPlusFirst ) nPhiPlusNext++;
1019 
1020  for(int i=nPhiPlusFirst; i<nPhiPlusNext; i++){
1021  nIndex = i ;
1022  if(nIndex != nBiggerCell) {
1023  nHash = nIndex;
1024  neighbList[neighbourIndex] = nHash;
1025  neighbourIndex++;
1026  result = 0;
1027  }
1028  // to avoid duplicated cells in corners
1029  if(gPhi < gPhiPlus && nBiggerCell == NOT_VALID_HASH) nBiggerCell=nIndex;
1030  }
1031  }
1032  }
1033  else {
1034  // stay in same region (1 neighbour)
1035  nIndex = index + nPhi;
1036  nHash = nIndex;
1037  neighbList[neighbourIndex] = nHash;
1038  neighbourIndex++;
1039  result = 0;
1040  }
1041  return result;
1042 }
1043 
1044 int LArEM_Base_ID::get_prevInSamp(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const unsigned int& minHash,
1045  const double& gEta, const float& gPhi, const double& absEta,
1046  int& neighbourIndex, IdentifierHash* neighbList) const
1047 {
1048  int result = 1;
1049 
1050  // neighbours' indices
1051  unsigned int nIndex=0;
1052  // neighbours' hash
1053  IdentifierHash nHash=0;
1054 
1055  // previous region in sampling
1056  const std::vector<short int>& prevSampRegion= emRegion->prevSamplingRegion();
1057  int nPrevSampReg = prevSampRegion.size();
1058  if(nPrevSampReg > 0) {
1059  for(int ireg=0; ireg<nPrevSampReg; ireg++) {
1060  LArEM_region* prevEmRegion = m_vecOfRegions[prevSampRegion[ireg]];
1061  // eta granularity of previous region in sampling
1062  double gEtaMinus= (double)(prevEmRegion->etaGranularity());
1063  // starting eta of prev region
1064  double minEtaMinus = (double)(prevEmRegion->etaMin());
1065  double maxEtaMinus = (double)(prevEmRegion->etaMax());
1066  double margin = 0.25*std::min(gEta,gEtaMinus);
1067  if((minEtaMinus < absEta+gEta-margin) && (absEta+margin < maxEtaMinus)) {
1068  // Tell clang to optimize assuming that FP exceptions can trap.
1069  // Otherwise, it can vectorize the division, which can lead to
1070  // spurious division-by-zero traps from unused vector lanes.
1072 
1073  // phi granularity of previous region in sampling
1074  float gPhiMinus= prevEmRegion->phiGranularity();
1075  // max phi of previous region in sampling
1076  short int nPhiMinus = prevEmRegion->phiN();
1077  // first hash of previous region in sampling
1078  unsigned int minHashMinus = prevEmRegion->hashMin();
1079  float phiMargin = 0.25*std::min(gPhi,gPhiMinus);
1080  // phi 'coordinate' in initial region
1081  float rPhi = ((index-minHash)%nPhi)*gPhi+emRegion->phiMin();
1082  int nPhiMinusFirst = int(std::floor((rPhi -prevEmRegion->phiMin())
1083  /gPhiMinus+phiMargin));
1084  int nPhiMinusNext = int(std::floor((rPhi+gPhi-prevEmRegion->phiMin())
1085  /gPhiMinus+phiMargin));
1086  if ( nPhiMinusNext == nPhiMinusFirst ) nPhiMinusNext++;
1087 
1088  // eta 'coordinate' in initial region
1089  double fEtaMinus = (absEta-minEtaMinus) / gEtaMinus + margin ;
1090  // eta 'coordinate' in initial region + 1
1091  double fEtaMaxMinus = (absEta+gEta-minEtaMinus) / gEtaMinus + margin ;
1092  int nEtaMinus = int(fEtaMinus);
1093  int nEtaMaxMinus = int(fEtaMaxMinus);
1094  if ( nEtaMaxMinus == nEtaMinus ) nEtaMaxMinus++;
1095  for(int i=nEtaMinus; i<nEtaMaxMinus; i++) {
1096  for (int j=nPhiMinusFirst; j<nPhiMinusNext;j++) {
1097  nIndex = minHashMinus + i * nPhiMinus + j;
1098  if( (nIndex >= prevEmRegion->hashMin()) && (nIndex < prevEmRegion->hashMax()) ) {
1099  nHash = nIndex;
1100  neighbList[neighbourIndex] = nHash;
1101  neighbourIndex++;
1102  result = 0;
1103  }
1104  }
1105  }
1106  } // end eta condition
1107  } // loop on ireg
1108  }
1109  return result;
1110 }
1111 
1112 int LArEM_Base_ID::get_nextInSamp(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const unsigned int& minHash,
1113  const double& gEta, const float& gPhi, const double& absEta,
1114  int& neighbourIndex, IdentifierHash* neighbList) const
1115 {
1116  int result = 1;
1117 
1118  // neighbours' indices
1119  unsigned int nIndex=0;
1120  // neighbours' hash
1121  IdentifierHash nHash=0;
1122 
1123  const std::vector<short int>& nextSampRegion= emRegion->nextSamplingRegion();
1124  int nNextSampReg = nextSampRegion.size();
1125  if(nNextSampReg > 0) {
1126  for(int ireg=0; ireg<nNextSampReg; ireg++) {
1127  LArEM_region* nextEmRegion = m_vecOfRegions[nextSampRegion[ireg]];
1128  double gEtaPlus = (double)(nextEmRegion->etaGranularity());
1129  float gPhiPlus= nextEmRegion->phiGranularity();
1130  double minEtaPlus = (double)(nextEmRegion->etaMin());
1131  double maxEtaPlus = (double)(nextEmRegion->etaMax());
1132  double margin = 0.25*std::min(gEta,gEtaPlus);
1133  if((minEtaPlus < absEta+gEta-margin) && (absEta+margin < maxEtaPlus)) {
1134  // Tell clang to optimize assuming that FP exceptions can trap.
1135  // Otherwise, it can vectorize the division, which can lead to
1136  // spurious division-by-zero traps from unused vector lanes.
1138 
1139  short int nPhiPlus = nextEmRegion->phiN();
1140  unsigned int minHashPlus = nextEmRegion->hashMin();
1141  float phiMargin = 0.25*std::min(gPhi,gPhiPlus);
1142  // phi 'coordinate' in initial region
1143  float rPhi = ((index-minHash)%nPhi)*gPhi+emRegion->phiMin();
1144  int nPhiPlusFirst = int(std::floor((rPhi -nextEmRegion->phiMin())
1145  /gPhiPlus+phiMargin));
1146  int nPhiPlusNext = int(std::floor((rPhi+gPhi-nextEmRegion->phiMin())
1147  /gPhiPlus+phiMargin));
1148  if ( nPhiPlusNext == nPhiPlusFirst ) nPhiPlusNext++;
1149 
1150  double fEtaPlus = (absEta-minEtaPlus) / gEtaPlus + margin ;
1151  // eta 'coordinate' in initial region + 1
1152  double fEtaMaxPlus = (absEta+gEta-minEtaPlus) / gEtaPlus + margin ;
1153  int nEtaPlus = int(fEtaPlus) ;
1154  int nEtaMaxPlus = int(fEtaMaxPlus) ;
1155  if (nEtaMaxPlus == nEtaPlus) nEtaMaxPlus++;
1156 
1157  for(int i=nEtaPlus; i<nEtaMaxPlus; i++){
1158  for(int j=nPhiPlusFirst; j<nPhiPlusNext; j++){
1159  nIndex = minHashPlus + i * nPhiPlus + j;
1160  if( (nIndex >= nextEmRegion->hashMin()) && (nIndex < nextEmRegion->hashMax()) ) {
1161  nHash = nIndex;
1162  neighbList[neighbourIndex] = nHash;
1163  neighbourIndex++;
1164  result = 0;
1165  }
1166  }
1167  }
1168  } // end eta condition
1169  } // end loop on regions
1170  }
1171  return result;
1172 }
1173 
1174 
1175 int LArEM_Base_ID::get_prevInSubdet(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const unsigned int& minHash,
1176  const double& gEta, const float& gPhi, const double& absEta,
1177  int& neighbourIndex, IdentifierHash* neighbList) const
1178 {
1179  int result = 1;
1180 
1181  // neighbours' indices
1182  unsigned int nIndex=0;
1183  // neighbours' hash
1184  IdentifierHash nHash=0;
1185 
1186  // previous region in sampling
1187  const std::vector<short int>& prevSubdetRegion= emRegion->prevSubdetRegion();
1188  int nPrevSubdetReg = prevSubdetRegion.size();
1189  if(nPrevSubdetReg > 0) {
1190  for(int ireg=0; ireg<nPrevSubdetReg; ireg++) {
1191  LArEM_region* prevEmRegion = m_vecOfRegions[prevSubdetRegion[ireg]];
1192  // eta granularity of previous region in sampling
1193  double gEtaMinus= (double)(prevEmRegion->etaGranularity());
1194  // starting eta of prev region
1195  double minEtaMinus = (double)(prevEmRegion->etaMin());
1196  double maxEtaMinus = (double)(prevEmRegion->etaMax());
1197  double margin = 0.25*std::min(gEta,gEtaMinus);
1198  if((minEtaMinus < absEta+gEta-margin) && (absEta+margin < maxEtaMinus)) {
1199  // Tell clang to optimize assuming that FP exceptions can trap.
1200  // Otherwise, it can vectorize the division, which can lead to
1201  // spurious division-by-zero traps from unused vector lanes.
1203 
1204  // phi granularity of previous region in sampling
1205  float gPhiMinus= prevEmRegion->phiGranularity();
1206  // max phi of previous region in sampling
1207  short int nPhiMinus = prevEmRegion->phiN();
1208  // first hash of previous region in sampling
1209  unsigned int minHashMinus = prevEmRegion->hashMin();
1210  float phiMargin = 0.25*std::min(gPhi,gPhiMinus);
1211  // phi 'coordinate' in initial region
1212  float rPhi = ((index-minHash)%nPhi)*gPhi+emRegion->phiMin();
1213  int nPhiMinusFirst = int(std::floor((rPhi -prevEmRegion->phiMin())
1214  /gPhiMinus+phiMargin));
1215  int nPhiMinusNext = int(std::floor((rPhi+gPhi-prevEmRegion->phiMin())
1216  /gPhiMinus+phiMargin));
1217  if ( nPhiMinusNext == nPhiMinusFirst ) nPhiMinusNext++;
1218  // eta 'coordinate' in initial region
1219  double fEtaMinus = (absEta-minEtaMinus) / gEtaMinus + margin ;
1220  // eta 'coordinate' in initial region + 1
1221  double fEtaMaxMinus = (absEta+gEta-minEtaMinus) / gEtaMinus + margin ;
1222  int nEtaMinus = int(fEtaMinus);
1223  int nEtaMaxMinus = int(fEtaMaxMinus);
1224  if ( nEtaMaxMinus == nEtaMinus ) nEtaMaxMinus++;
1225 
1226  for(int i=nEtaMinus; i<nEtaMaxMinus; i++) {
1227  for (int j=nPhiMinusFirst; j<nPhiMinusNext;j++) {
1228  nIndex = minHashMinus + i * nPhiMinus + j;
1229  if( (nIndex >= prevEmRegion->hashMin()) && (nIndex < prevEmRegion->hashMax()) ) {
1230  nHash = nIndex;
1231  neighbList[neighbourIndex] = nHash;
1232  neighbourIndex++;
1233  result = 0;
1234  }
1235  }
1236  }
1237  } // end eta condition
1238  } // loop on ireg
1239  }
1240  return result;
1241 }
1242 
1243 int LArEM_Base_ID::get_nextInSubdet(const LArEM_region* emRegion, const unsigned int& index, const short int& nPhi, const unsigned int& minHash,
1244  const double& gEta, const float& gPhi, const double& absEta,
1245  int& neighbourIndex, IdentifierHash* neighbList) const
1246 {
1247  int result = 1;
1248 
1249  // neighbours' indices
1250  unsigned int nIndex=0;
1251  // neighbours' hash
1252  IdentifierHash nHash=0;
1253 
1254  const std::vector<short int>& nextSubdetRegion= emRegion->nextSubdetRegion();
1255  int nNextSubdetReg = nextSubdetRegion.size();
1256  if(nNextSubdetReg > 0) {
1257  for(int ireg=0; ireg<nNextSubdetReg; ireg++) {
1258  LArEM_region* nextEmRegion = m_vecOfRegions[nextSubdetRegion[ireg]];
1259  double gEtaPlus = (double)(nextEmRegion->etaGranularity());
1260  float gPhiPlus= nextEmRegion->phiGranularity();
1261  double minEtaPlus = (double)(nextEmRegion->etaMin());
1262  double maxEtaPlus = (double)(nextEmRegion->etaMax());
1263  double margin = 0.25*std::min(gEta,gEtaPlus);
1264  if((minEtaPlus < absEta+gEta-margin) && (absEta+margin < maxEtaPlus)) {
1265  // Tell clang to optimize assuming that FP exceptions can trap.
1266  // Otherwise, it can vectorize the division, which can lead to
1267  // spurious division-by-zero traps from unused vector lanes.
1269 
1270  short int nPhiPlus = nextEmRegion->phiN();
1271  unsigned int minHashPlus = nextEmRegion->hashMin();
1272  float phiMargin = 0.25*std::min(gPhi,gPhiPlus);
1273  // phi 'coordinate' in initial region
1274  float rPhi = ((index-minHash)%nPhi)*gPhi+emRegion->phiMin();
1275  int nPhiPlusFirst = int(std::floor((rPhi -nextEmRegion->phiMin())
1276  /gPhiPlus+phiMargin));
1277  int nPhiPlusNext = int(std::floor((rPhi+gPhi-nextEmRegion->phiMin())
1278  /gPhiPlus+phiMargin));
1279  if ( nPhiPlusNext == nPhiPlusFirst ) nPhiPlusNext++;
1280 
1281  double fEtaPlus = (absEta-minEtaPlus) / gEtaPlus + margin ;
1282  // eta 'coordinate' in initial region + 1
1283  double fEtaMaxPlus = (absEta+gEta-minEtaPlus) / gEtaPlus + margin ;
1284  int nEtaPlus = int(fEtaPlus) ;
1285  int nEtaMaxPlus = int(fEtaMaxPlus) ;
1286  if (nEtaMaxPlus == nEtaPlus) nEtaMaxPlus++;
1287 
1288  for(int i=nEtaPlus; i<nEtaMaxPlus; i++) {
1289  for(int j=nPhiPlusFirst; j<nPhiPlusNext; j++) {
1290  nIndex = minHashPlus + i * nPhiPlus + j;
1291  if( (nIndex >= nextEmRegion->hashMin()) && (nIndex < nextEmRegion->hashMax()) ) {
1292  nHash = nIndex;
1293  neighbList[neighbourIndex] = nHash;
1294  neighbourIndex++;
1295  result = 0;
1296  }
1297  }
1298  }
1299  } // end eta condition
1300  } // end loop on regions
1301  }
1302  return result;
1303 }
1304 
1305 
1307 {
1308  MsgStream log(m_msgSvc, "LArEM_Base_ID" );
1309  if(m_msgSvc) {
1310  log << MSG::DEBUG << "init_neighbors" << endmsg;
1311  }
1312  else {
1313  std::cout << " LArEM_Base_ID::init_neighbors " << std::endl;
1314  }
1315 
1316  const std::vector<const IdDictRegion*>& vecOfDictRegions = dictRegions();
1317 
1318  //
1319  // ..... loop on regions -> store vector of LArEM_region*
1320  //
1321  m_vecOfRegions.resize(region_hash_max());
1322  short int reg=0;
1323  std::vector<Identifier>::const_iterator debut=reg_begin() ;
1324  std::vector<Identifier>::const_iterator fin =reg_end() ;
1325  for (; debut != fin; ++debut) {
1326  const Identifier& regId = (*debut);
1327 
1328  bool phiWrapAround = (dictionaryVersion() == "fullAtlas" );
1329  bool isBarrelMiddle = false;
1330 
1331  //
1332  // ..... translate regId to chanId and get hash
1333  //
1334 
1335  Identifier id ;
1336  unsigned int index0 = NOT_VALID_HASH;
1337  int etaMin = eta_min(regId);
1338  int phiMin = phi_min(regId);
1339  if(etaMin >= 0 && phiMin >= 0) {
1340  try{
1341  id = channel_id (regId, eta_min(regId), phi_min(regId) );
1342  }
1343  catch(LArID_Exception & except){
1344  if(m_msgSvc) {
1345  log << MSG::ERROR << " LArId exception "
1346  << (std::string)except
1347  << endmsg;
1348  }
1349  else {
1350  std::cout
1351  << " LArId exception "
1352  << (std::string)except
1353  << std::endl;
1354  }
1355  }
1356  IdentifierHash hashId = channel_hash (id) ;
1357  index0=hashId;
1358  }
1359  else {
1360  if(m_msgSvc) {
1361  log << MSG::WARNING << " could not find non negative etaMin and phiMin for region "
1362  << show_to_string(regId)
1363  << endmsg;
1364  }
1365  else {
1366  std::cout << "WARNING !! could not find non negative etaMin and phiMin for region "
1367  << show_to_string(regId)
1368  << std::endl;
1369  }
1370  index0 = 0;
1371  }
1372 
1373  short int deltaEta = eta_max(regId) - eta_min(regId) + 1 ;
1374  short int nPhi = phi_max(regId) - phi_min(regId) + 1 ;
1375  // starting eta
1376  float eta0 = this->eta0(reg);
1377  // eta granularity
1378  float deta = etaGranularity(reg);
1379  // starting phi
1380  float phi0 = this->phi0(reg);
1381  // phi granularity
1382  float dphi = phiGranularity(reg);
1383 
1384  // full range of regions
1385  unsigned int ireg0=0;
1386  unsigned int ireg1=region_hash_max();
1387  // if 2 symetric sides, in which side is the current reg.
1388  if(twoSymSides()) {
1389  if(reg < (short int)region_hash_max()/2) {
1390  ireg0=0;
1391  ireg1=region_hash_max()/2;
1392  } else {
1393  ireg0=region_hash_max()/2;
1394  ireg1=region_hash_max();
1395  }
1396  }
1397 
1398  //
1399  // .... compute prev/next regions in eta
1400  //
1401  short int regForPrevEta=NOT_VALID_REGION;
1402  IdDictRegion* prevEtaDicReg = vecOfDictRegions[reg]->m_prev_abs_eta;
1403  short int regForNextEta=NOT_VALID_REGION;
1404  IdDictRegion* nextEtaDicReg = vecOfDictRegions[reg]->m_next_abs_eta;
1405  for(unsigned int ireg=ireg0;ireg<ireg1;ireg++){
1406  if(vecOfDictRegions[ireg] == prevEtaDicReg) regForPrevEta = ireg;
1407  if(vecOfDictRegions[ireg] == nextEtaDicReg) regForNextEta = ireg;
1408  }
1409  // .... special case of barrel middle
1410  if(twoSymSides()) {
1411  if(eta0 < 0.1 ) {
1412  isBarrelMiddle = true;
1413  if(barrel_ec(regId) < 0) {
1414  regForPrevEta = reg+6;
1415  } else {
1416  regForPrevEta = reg-6;
1417  }
1418  }
1419  }
1420 
1421  //
1422  // .... compute prev/next regions in sampling
1423  //
1424  std::vector<short int> regForPrevSamp;
1425  std::vector<IdDictRegion*> prevSampDicReg = vecOfDictRegions[reg]->m_prev_samp;
1426  for(unsigned int isam=0;isam<prevSampDicReg.size();isam++){
1427  for(unsigned int ireg=ireg0;ireg<ireg1;ireg++){
1428  if(vecOfDictRegions[ireg] == prevSampDicReg[isam]) regForPrevSamp.push_back(ireg);
1429  }
1430  }
1431 
1432  std::vector<short int> regForNextSamp;
1433  std::vector<IdDictRegion*> nextSampDicReg = vecOfDictRegions[reg]->m_next_samp;
1434  for(unsigned int isam=0;isam<nextSampDicReg.size();isam++){
1435  for(unsigned int ireg=ireg0;ireg<ireg1;ireg++){
1436  if(vecOfDictRegions[ireg] == nextSampDicReg[isam]) regForNextSamp.push_back(ireg);
1437  }
1438  }
1439 
1440  //
1441  // .... compute prev/next regions in subdet
1442  //
1443  std::vector<short int> regForPrevSubdet;
1444  std::vector<IdDictRegion*> prevSubdetDicReg = vecOfDictRegions[reg]->m_prev_subdet;
1445  for(unsigned int isubdet=0;isubdet<prevSubdetDicReg.size();isubdet++){
1446  for(unsigned int ireg=ireg0;ireg<ireg1;ireg++){
1447  if(vecOfDictRegions[ireg] == prevSubdetDicReg[isubdet]) regForPrevSubdet.push_back(ireg);
1448  }
1449  }
1450 
1451  std::vector<short int> regForNextSubdet;
1452  std::vector<IdDictRegion*> nextSubdetDicReg = vecOfDictRegions[reg]->m_next_subdet;
1453  for(unsigned int isubdet=0;isubdet<nextSubdetDicReg.size();isubdet++){
1454  for(unsigned int ireg=ireg0;ireg<ireg1;ireg++){
1455  if(vecOfDictRegions[ireg] == nextSubdetDicReg[isubdet]) regForNextSubdet.push_back(ireg);
1456  }
1457  }
1458 
1459  //
1460  // ....now ready to build region object
1461  //
1462 
1463  LArEM_region * emRegion = new LArEM_region(index0,deltaEta,nPhi,eta0,deta,phi0,dphi,phiWrapAround,isBarrelMiddle,
1464  regForPrevEta,regForNextEta,
1465  regForPrevSamp,regForNextSamp,
1466  regForPrevSubdet,regForNextSubdet);
1467  // save in a vector for further use in get_neighbours method
1468  // optimized nov 2005
1469  // m_vecOfRegions.push_back(emRegion);
1470  m_vecOfRegions[reg]=emRegion;
1471  reg++;
1472  } // end of loop on regions
1473 
1474  //
1475  // ..... loop on channels
1476  //
1477  // optimized nov 2005
1478  m_cells.reserve(64);
1479  unsigned int i=0;
1480  reg=0;
1481  Identifier lastRegId;
1482  for (Identifier chanId : em_range()) {
1483  const Identifier& regId = region_id(chanId);
1484  if(regId != lastRegId) {
1485  m_cells.push_back(i);
1486  reg++;
1487  }
1488  ++i;
1489 
1490  if(m_do_checks) {
1491  // for cross check only
1492  IdentifierHash hashReg = region_hash (regId) ;
1493  if ((short int)hashReg != reg) {
1494  if(m_msgSvc) {
1495  log << MSG::ERROR << " init_neighbors: problem reg, hashReg = " << reg << " " << hashReg
1496  << endmsg;
1497  }
1498  else {
1499  std::cout << " init_neighbors: problem reg, hashReg = " << reg << " " << hashReg
1500  << std::endl;
1501  }
1502  }
1503  }
1504 
1505  lastRegId=regId;
1506  }
1507 
1508  return (0);
1509 }
1510 
1511 
1512 
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
AtlasDetectorID::lar_em_field_value
int lar_em_field_value() const
Definition: AtlasDetectorID.h:651
LArEM_Base_ID::LArEM_Base_ID
LArEM_Base_ID(const std::string &name, const std::string &group, bool supercell)
Constructor.
Definition: LArEM_Base_ID.cxx:22
LArNeighbours::neighbourOption
neighbourOption
Definition: LArNeighbours.h:12
LArEM_Base_ID.h
Factor out code common between LArEM_ID and LArEM_SuperCell_ID.
CXXUTILS_TRAPPING_FP
#define CXXUTILS_TRAPPING_FP
Definition: trapping_fp.h:24
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
LArEM_region::prevSubdetRegion
const std::vector< short int > & prevSubdetRegion() const
region number of the prev region in subdet
Definition: LArEM_region.h:102
IdDictDictionary::build_multirange
MultiRange build_multirange() const
Get MultiRange for full dictionary.
Definition: IdDictDictionary.cxx:290
LArNeighbours::upAndDown
@ upAndDown
Definition: LArNeighbours.h:21
LArEM_Base_ID::m_eta_impl
IdDictFieldImplementation m_eta_impl
Definition: LArEM_Base_ID.h:423
LArEM_Base_ID::phi_max
int phi_max(const Identifier regId) const
max value of phi index (-999 == failure)
Definition: LArEM_Base_ID.cxx:117
LArEM_Base_ID::m_ETA_INDEX
size_type m_ETA_INDEX
Definition: LArEM_Base_ID.h:414
get_generator_info.result
result
Definition: get_generator_info.py:21
IdDictGroup
Definition: IdDictGroup.h:19
LArEM_region::isEtaMin
bool isEtaMin(unsigned int index) const
is the considered cell in the first eta bin of the region ?
Definition: LArEM_region.h:76
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
LArEM_Base_ID::init_neighbors
int init_neighbors()
Definition: LArEM_Base_ID.cxx:1306
LArEM_Base_ID::phi_min_init
int phi_min_init(const Identifier regId) const
Definition: LArEM_Base_ID.cxx:91
LArEM_region::phiMin
float phiMin() const
starting phi
Definition: LArEM_region.h:58
LArEM_region::nextSubdetRegion
const std::vector< short int > & nextSubdetRegion() const
region number of the next region in subdet
Definition: LArEM_region.h:105
IdDictFieldImplementation::show_to_string
std::string show_to_string(void) const
Definition: IdDictFieldImplementation.cxx:38
CaloIDHelper::channel_hash_max
size_type channel_hash_max() const
One more than the largest channel (cell) hash code.
LArEM_Base_ID::m_slar_impl
IdDictFieldImplementation m_slar_impl
Definition: LArEM_Base_ID.h:426
LArEM_Base_ID::HashCalc::m_nphi
size_type m_nphi
Definition: LArEM_Base_ID.h:446
LArNeighbours::corners2D
@ corners2D
Definition: LArNeighbours.h:17
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
index
Definition: index.py:1
CaloIDHelper::fill_vec_of_dict_regions
int fill_vec_of_dict_regions(const std::string &group_name="")
Initialize the list of detector regions.
Definition: CaloIDHelper.cxx:259
IdentifierField::get_minimum
element_type get_minimum() const
Query the values.
Definition: IdentifierField.h:121
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
LArEM_region::isPhiMin
bool isPhiMin(unsigned int index) const
is the considered cell in the first phi bin of the region ?
Definition: LArEM_region.h:86
LArEM_Base_ID::region_id
Identifier region_id(const ExpandedIdentifier &exp_id) const
Build a cell identifier from an expanded identifier.
IdContext::end_index
size_type end_index() const
Definition: IdContext.h:46
CaloIDHelper::region_context
IdContext region_context() const
Return the context for regions.
LArNeighbours::nextSubDet
@ nextSubDet
Definition: LArNeighbours.h:23
ExpandedIdentifier::add
void add(element_type value)
Append a value into a new field.
LArEM_Base_ID::m_vecOfRegions
std::vector< LArEM_region * > m_vecOfRegions
Definition: LArEM_Base_ID.h:452
ExpandedIdentifier
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:102
LArEM_Base_ID::region
int region(const Identifier id) const
return region according to :
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
LArEM_Base_ID::get_nextInSubdet
int get_nextInSubdet(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const unsigned int &minHash, const double &gEta, const float &gPhi, const double &absEta, int &neighbourIndex, IdentifierHash *neighbList) const
Definition: LArEM_Base_ID.cxx:1243
AtlasDetectorID::m_msgSvc
IMessageSvc * m_msgSvc
pointer to the message service
Definition: AtlasDetectorID.h:375
IdentifierField::get_maximum
element_type get_maximum() const
Definition: IdentifierField.h:130
AtlasDetectorID::m_do_checks
bool m_do_checks
Flag for subclasses to know whether or not to perform checks.
Definition: AtlasDetectorID.h:369
ReadOfcFromCool.field
field
Definition: ReadOfcFromCool.py:48
LArEM_region::etaMax
float etaMax() const
end eta
Definition: LArEM_region.h:55
AtlasDetectorID::lar_field_value
int lar_field_value() const
Definition: AtlasDetectorID.h:621
IdDictFieldImplementation::unpack
int unpack(Identifier id) const
Identifier manipulation methods.
Definition: IdDictFieldImplementation.h:147
LArNeighbours::prevInPhi
@ prevInPhi
Definition: LArNeighbours.h:12
LArEM_Base_ID::channel_id
Identifier channel_id(const ExpandedIdentifier &exp_id) const
Build a cell identifier from an expanded identifier.
LArEM_Base_ID::m_em_impl
IdDictFieldImplementation m_em_impl
Definition: LArEM_Base_ID.h:419
LArEM_Base_ID::get_expanded_id
virtual int get_expanded_id(const Identifier &id, ExpandedIdentifier &exp_id, const IdContext *context) const
create expanded Identifier from Identifier (return == 0 for OK)
Definition: LArEM_Base_ID.cxx:197
xAOD::unsigned
unsigned
Definition: RingSetConf_v1.cxx:662
TrigVSI::AlgConsts::nPhi
constexpr int nPhi
Default bin number of phi for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:27
IdDictDictionary::find_field
IdDictField * find_field(const std::string &name) const
Definition: IdDictDictionary.cxx:36
IdDictRegion
Definition: IdDictRegion.h:20
CaloIDHelper::regions
const HashGroup & regions() const
Return the HashGroup for regions.
AtlasDetectorID::dictionaryVersion
virtual std::string dictionaryVersion(void) const override
Definition: AtlasDetectorID.cxx:276
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
LArEM_Base_ID::get_nextInSamp
int get_nextInSamp(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const unsigned int &minHash, const double &gEta, const float &gPhi, const double &absEta, int &neighbourIndex, IdentifierHash *neighbList) const
Definition: LArEM_Base_ID.cxx:1112
LArEM_Base_ID::reg_end
id_iterator reg_end() const
end iterator over set of Region Identifiers
AtlasDetectorID::m_do_neighbours
bool m_do_neighbours
Flag for subclasses to know whether or not to perform neighbour initialization.
Definition: AtlasDetectorID.h:372
LArEM_Base_ID::initLevelsFromDict
int initLevelsFromDict(const std::string &group_name)
Definition: LArEM_Base_ID.cxx:218
LArEM_Base_ID::get_prevInSamp
int get_prevInSamp(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const unsigned int &minHash, const double &gEta, const float &gPhi, const double &absEta, int &neighbourIndex, IdentifierHash *neighbList) const
Definition: LArEM_Base_ID.cxx:1044
LArEM_Base_ID::m_sampling_impl
IdDictFieldImplementation m_sampling_impl
Definition: LArEM_Base_ID.h:421
IdDictDefs.h
LArEM_Base_ID::m_full_em_range
MultiRange m_full_em_range
Definition: LArEM_Base_ID.h:406
LArEM_Base_ID::m_phi_impl
IdDictFieldImplementation m_phi_impl
Definition: LArEM_Base_ID.h:424
LArNeighbours::nextInSamp
@ nextInSamp
Definition: LArNeighbours.h:20
LArEM_region
This class provides an interface to deal with regions in the neighbours finding
Definition: LArEM_region.h:20
LArEM_Base_ID::eta_max
int eta_max(const Identifier regId) const
max value of eta index (-999 == failure)
Definition: LArEM_Base_ID.cxx:70
LArNeighbours::nextInPhi
@ nextInPhi
Definition: LArNeighbours.h:13
IdDictMgr
Definition: IdDictMgr.h:14
LArEM_Base_ID::m_region_impl
IdDictFieldImplementation m_region_impl
Definition: LArEM_Base_ID.h:422
LArEM_Base_ID::channel_hash
IdentifierHash channel_hash(Identifier channelId) const
create hash id from channel id
IdDictDictionary::find_group
IdDictGroup * find_group(const std::string &group_name) const
Definition: IdDictDictionary.cxx:106
StrFormat.h
Provide helper functions to create formatted strings.
IdDictMgr::find_dictionary
IdDictDictionary * find_dictionary(const std::string &name) const
Access dictionary by name.
Definition: IdDictMgr.cxx:115
CaloIDHelper::region_hash_max
size_type region_hash_max() const
One more than the largest region hash code.
LArEM_Base_ID::HashCalc
small class holding the starting hash value, the min eta and the number of phi bins of each region
Definition: LArEM_Base_ID.h:436
Trk::index1
@ index1
Definition: BoundarySurfaceFace.h:48
P4Helpers::deltaEta
double deltaEta(const I4Momentum &p1, const I4Momentum &p2)
Computes efficiently .
Definition: P4Helpers.h:66
IdentifierField::empty
bool empty() const
If true, this field does not have any constraints, and may hold any value representable by element_ty...
Definition: IdentifierField.h:182
LArEM_region::phiGranularity
float phiGranularity() const
phi granularity
Definition: LArEM_region.h:43
CaloIDHelper::etaGranularity
float etaGranularity(const IdentifierHash regHash) const
Return the eta granularity of a region, or NOT_VALID.
Definition: CaloIDHelper.cxx:185
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArEM_Base_ID::phi_min
int phi_min(const Identifier regId) const
min value of phi index (-999 == failure)
IdDictFieldImplementation::set_bits
void set_bits(size_type bits, size_type bits_offset)
Definition: IdDictFieldImplementation.h:278
CaloIDHelper::dict
const IdDictDictionary * dict() const
Return the dictionary for this subdetector.
CaloIDHelper
Base class to factor out code common among Calo ID helpers.
Definition: CaloIDHelper.h:34
LArEM_Base_ID::m_bec_reg_impl
IdDictFieldImplementation m_bec_reg_impl
Definition: LArEM_Base_ID.h:450
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
LArEM_Base_ID::m_full_region_range
MultiRange m_full_region_range
Definition: LArEM_Base_ID.h:405
LArEM_region::isEtaMax
bool isEtaMax(unsigned int index) const
is the considered cell in the last eta bin of the region ?
Definition: LArEM_region.h:81
LArEM_Base_ID::m_SAMPLING_INDEX
size_type m_SAMPLING_INDEX
Definition: LArEM_Base_ID.h:412
LArEM_Base_ID::twoSymSides
bool twoSymSides() const
True if the + and - sides of the calorimeter are identical (true layout).
IdDictFieldImplementation::bits_offset
size_type bits_offset() const
Definition: IdDictFieldImplementation.h:208
IdDictDictionary::m_regions
std::vector< IdDictRegion * > m_regions
Definition: IdDictDictionary.h:235
LArEM_region::etaMin
float etaMin() const
starting eta
Definition: LArEM_region.h:52
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
mc.group_name
group_name
Definition: mc.PhPy8EG_A14NNPDF23_NNLOPS_example.py:33
LArEM_Base_ID::m_lar_impl
IdDictFieldImplementation m_lar_impl
Definition: LArEM_Base_ID.h:418
NOT_VALID_REGION
@ NOT_VALID_REGION
Definition: LArEM_region.h:11
LArNeighbours::prevSubDet
@ prevSubDet
Definition: LArNeighbours.h:22
LArEM_region::hashMax
unsigned int hashMax() const
hash Id of the last cell of the region +1
Definition: LArEM_region.h:67
AtlasDetectorID::group
const std::string & group() const
Group name for this helper.
Definition: AtlasDetectorID.cxx:27
LArEM_Base_ID::m_slar
unsigned m_slar
Definition: LArEM_Base_ID.h:401
LArEM_region::phiN
short int phiN() const
number of phi bins
Definition: LArEM_region.h:37
LArEM_Base_ID::m_bec_impl
IdDictFieldImplementation m_bec_impl
Definition: LArEM_Base_ID.h:420
LArEM_region.h
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
LArEM_region::prevSamplingRegion
const std::vector< short int > & prevSamplingRegion() const
region number of the prev region in sampling
Definition: LArEM_region.h:96
LArNeighbours::prevInSamp
@ prevInSamp
Definition: LArNeighbours.h:19
AtlasDetectorID::m_quiet
bool m_quiet
If true, suppress DEBUG/INFO messages.
Definition: AtlasDetectorID.h:378
LArEM_Base_ID::get_prevInPhi
static int get_prevInPhi(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const unsigned int &minHash, int &neighbourIndex, IdentifierHash *neighbList)
Definition: LArEM_Base_ID.cxx:894
Trk::index0
@ index0
Definition: BoundarySurfaceFace.h:47
LArEM_Base_ID::eta_min
int eta_min(const Identifier regId) const
min value of eta index (-999 == failure)
Definition: LArEM_Base_ID.cxx:44
LArEM_Base_ID::get_nextInPhi
static int get_nextInPhi(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const unsigned int &minHash, int &neighbourIndex, IdentifierHash *neighbList)
Definition: LArEM_Base_ID.cxx:909
CaloIDHelper::initialize_base_from_dictionary
int initialize_base_from_dictionary(const IdDictMgr &dict_mgr, const std::string &dict_name)
Do basic initialization of the helper.
Definition: CaloIDHelper.cxx:232
LArEM_Base_ID::region_id_checks
void region_id_checks(int barrel_ec, int sampling, int region) const
Definition: LArEM_Base_ID.cxx:138
trapping_fp.h
Tell the compiler to optimize assuming that FP may trap.
IdDictDictionary::get_label_value
int get_label_value(const std::string &field, const std::string &label, int &value) const
Definition: IdDictDictionary.cxx:64
LArEM_Base_ID::m_EM_INDEX
size_type m_EM_INDEX
Definition: LArEM_Base_ID.h:410
Trk::index2
@ index2
Definition: BoundarySurfaceFace.h:49
CxxUtils::strformat
std::string strformat(const char *fmt,...)
return a std::string according to a format fmt and varargs
Definition: StrFormat.cxx:49
CaloIDHelper::eta0
float eta0(const IdentifierHash regHash) const
Return the minimum eta of region, or NOT_VALID.
Definition: CaloIDHelper.cxx:207
LArEM_Base_ID::m_cells
std::vector< unsigned > m_cells
Definition: LArEM_Base_ID.h:453
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArEM_Base_ID::get_neighbours
int get_neighbours(const IdentifierHash id, const LArNeighbours::neighbourOption &option, std::vector< IdentifierHash > &neighbourList) const
access to hashes for neighbours return == 0 for neighbours found option = prevInPhi,...
Definition: LArEM_Base_ID.cxx:688
LArEM_Base_ID::barrel_ec
int barrel_ec(const Identifier id) const
return barrel_ec according to :
AtlasDetectorID::setDictVersion
virtual void setDictVersion(const IdDictMgr &dict_mgr, const std::string &name) override
Definition: AtlasDetectorID.cxx:490
Range
A Range describes the possible ranges for the field values of an ExpandedIdentifier.
Definition: DetectorDescription/Identifier/Identifier/Range.h:29
LArEM_Base_ID::get_prevInEta
int get_prevInEta(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const float &gPhi, const unsigned int &minHash, int &neighbourIndex, IdentifierHash *neighbList, unsigned int &nBiggerCell) const
Definition: LArEM_Base_ID.cxx:924
LArEM_Base_ID::m_SLAR_INDEX
size_type m_SLAR_INDEX
Definition: LArEM_Base_ID.h:416
LArEM_region::isFirstBarrelRegion
bool isFirstBarrelRegion() const
true if region close to barrel middle
Definition: LArEM_region.h:49
python.PyKernel.init
def init(v_theApp, v_rootStream=None)
Definition: PyKernel.py:45
LArEM_region::nextEtaRegion
short int nextEtaRegion() const
region number of the next region in eta
Definition: LArEM_region.h:73
LArEM_Base_ID::m_PHI_INDEX
size_type m_PHI_INDEX
Definition: LArEM_Base_ID.h:415
IdDictDictionary
Definition: IdDictDictionary.h:30
LArEM_Base_ID::HashCalc::m_phimin
size_type m_phimin
Definition: LArEM_Base_ID.h:445
CaloIDHelper::channels
const HashGroup & channels() const
Return the HashGroup for channels (cells).
LArEM_Base_ID::reg_begin
id_iterator reg_begin() const
begin iterator over set of Region Identifiers
MultiRange::match
int match(const ExpandedIdentifier &id) const
Match an identifier.
Definition: MultiRange.cxx:57
AtlasDetectorID::reinitialize
bool reinitialize(const IdDictMgr &dict_mgr)
Test whether an idhelper should be reinitialized based on the change of tags.
Definition: AtlasDetectorID.cxx:216
LArEM_region::etaGranularity
float etaGranularity() const
eta granularity
Definition: LArEM_region.h:40
LArCellBinning.etaMin
etaMin
Definition: LArCellBinning.py:84
LArEM_Base_ID::m_BEC_INDEX
size_type m_BEC_INDEX
Definition: LArEM_Base_ID.h:411
LArEM_Base_ID::~LArEM_Base_ID
~LArEM_Base_ID()
Definition: LArEM_Base_ID.cxx:31
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
IdDictDictionary::m_name
std::string m_name
Definition: IdDictDictionary.h:216
CaloIDHelper::phi0
float phi0(const IdentifierHash regHash) const
Return the minimum phi of region, or NOT_VALID.
Definition: CaloIDHelper.cxx:218
LArEM_Base_ID::m_two_sym_sides
bool m_two_sym_sides
Definition: LArEM_Base_ID.h:403
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:360
CaloIDHelper::dictRegions
const std::vector< const IdDictRegion * > & dictRegions() const
Return the vector of IdDictRegion, accessed via region hash.
LArEM_Base_ID::HashCalc::m_etamin
size_type m_etamin
Definition: LArEM_Base_ID.h:444
LArNeighbours::nextInEta
@ nextInEta
Definition: LArNeighbours.h:15
MultiRange::size
size_type size() const
Definition: MultiRange.cxx:70
DeMoScan.first
bool first
Definition: DeMoScan.py:534
DEBUG
#define DEBUG
Definition: page_access.h:11
LArEM_Base_ID::get_prevInSubdet
int get_prevInSubdet(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const unsigned int &minHash, const double &gEta, const float &gPhi, const double &absEta, int &neighbourIndex, IdentifierHash *neighbList) const
Definition: LArEM_Base_ID.cxx:1175
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
IdentifierField
This is the individual specification for the range of one ExpandedIdentifier IdentifierField.
Definition: IdentifierField.h:83
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:245
ExpandedIdentifier::clear
void clear()
Erase all fields.
LArEM_Base_ID::m_em_region_index
size_type m_em_region_index
Definition: LArEM_Base_ID.h:408
compute_lumi.fin
fin
Definition: compute_lumi.py:19
LArEM_Base_ID::get_nextInEta
int get_nextInEta(const LArEM_region *emRegion, const unsigned int &index, const short int &nPhi, const float &gPhi, const unsigned int &maxHash, int &neighbourIndex, IdentifierHash *neighbList, unsigned int &nBiggerCell) const
Definition: LArEM_Base_ID.cxx:991
LArEM_Base_ID::initialize_base_from_dictionary
int initialize_base_from_dictionary(const IdDictMgr &dict_mgr, const std::string &group_name)
initialization from the identifier dictionary
Definition: LArEM_Base_ID.cxx:440
LArNeighbours::prevInEta
@ prevInEta
Definition: LArNeighbours.h:14
LArEM_region::prevEtaRegion
short int prevEtaRegion() const
region number of the previous region in eta
Definition: LArEM_region.h:70
calibdata.copy
bool copy
Definition: calibdata.py:26
CaloIDHelper::phiGranularity
float phiGranularity(const IdentifierHash regHash) const
Return the phi granularity of a region, or NOT_VALID.
Definition: CaloIDHelper.cxx:196
IdDictField
Definition: IdDictField.h:15
LArEM_Base_ID::channel_id_checks
void channel_id_checks(int barrel_ec, int sampling, int region, int eta, int phi) const
Definition: LArEM_Base_ID.cxx:154
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
LArEM_Base_ID::em_range
id_range em_range() const
Range over full set of EM Identifiers.
TrigVSI::AlgConsts::nEta
constexpr int nEta
Default bin number of eta for vertex map.
Definition: Trigger/TrigTools/TrigVrtSecInclusive/TrigVrtSecInclusive/Constants.h:26
LArEM_Base_ID::m_vecOfPhiMin
std::vector< int > m_vecOfPhiMin
Definition: LArEM_Base_ID.h:428
LArEM_region::isPhiMax
bool isPhiMax(unsigned int index) const
is the considered cell in the last phi bin of the region ?
Definition: LArEM_region.h:91
LArCellBinning.etamin
etamin
Definition: LArCellBinning.py:137
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
LArEM_Base_ID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: LArEM_Base_ID.h:350
CaloIDHelper::region_hash
IdentifierHash region_hash(Identifier regionId) const
Convert a connected region Identifier to a hash code.
LArEM_Base_ID::m_LAR_INDEX
size_type m_LAR_INDEX
Definition: LArEM_Base_ID.h:409
LArEM_region::nextSamplingRegion
const std::vector< short int > & nextSamplingRegion() const
region number of the next region in sampling
Definition: LArEM_region.h:99
LArEM_Base_ID::init_hashes
int init_hashes()
Definition: LArEM_Base_ID.cxx:424
AtlasDetectorID::lar_em_exp
ExpandedIdentifier lar_em_exp(void) const
LAr.
Definition: AtlasDetectorID.h:569
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArEM_region::hashMin
unsigned int hashMin() const
hash Id of the first cell of the region
Definition: LArEM_region.h:64
LArEM_Base_ID::channel_hash_binary_search
IdentifierHash channel_hash_binary_search(Identifier channelId) const
create hash id from channel id – method NOT optimised, please use channel_hash() above
LArNeighbours::all2D
@ all2D
Definition: LArNeighbours.h:18
LArEM_Base_ID::m_REGION_INDEX
size_type m_REGION_INDEX
Definition: LArEM_Base_ID.h:413
LArEM_Base_ID::is_supercell
bool is_supercell(const Identifier id) const
Test if the identifier represents a supercell.
Definition: LArEM_Base_ID.cxx:38
LArEM_Base_ID::HashCalc::m_hash
IdentifierHash m_hash
Definition: LArEM_Base_ID.h:443
IdDictFieldImplementation::size_type
Identifier::size_type size_type
Definition: IdDictFieldImplementation.h:62
CaloIDHelper::HashGroup::hash_max
size_type hash_max() const
Return one more than the largest hash code.
LArEM_Base_ID::m_hash_calcs
std::vector< HashCalc > m_hash_calcs
Definition: LArEM_Base_ID.h:448
IdDictFieldImplementation::bits
size_type bits() const
Definition: IdDictFieldImplementation.h:202
Identifier
Definition: IdentifierFieldParser.cxx:14