ATLAS Offline Software
LArOnlineID_Base.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "LArIdentifier/LArOnlineID_Base.h"
6 #include "GaudiKernel/MsgStream.h"
7 #include "IdDict/IdDictDefs.h"
8 #include "Identifier/IdentifierHash.h"
9 #include "LArIdentifier/LArOnlID_Exception.h"
10 #include <cmath>
11 #include <iostream>
12 #include <set>
13 #include <sstream>
14 #include <string>
15 
16 /* MAY-17-04:*/
17 /* AL added init_hashes for calib lines */
18 /* */
19 /* FEB-25-04: */
20 /* AL removed H6_channel_vec, H8_channel_vec and associated methods/iterators*/
21 /* replaced init_H8channelHashes by init_H8hashes */
22 /* replaced init_H6channelHashes by init_H6hashes */
23 /* removed init_H6febHashes and init_H8febHashes */
24 /* Choice of the init_hashes method NOW based on the "version" ID taken from */
25 /* the Dictionary */
26 /* FEB-16-04: */
27 /* AL added access to TestBeamH8 Channels via init_H8hashes */
28 /* added access to TestBeamH6 Channels via init_H6hashes*/
29 /* added access to TestBeamH8 febs via init_H8hashes */
30 /* added access to TestBeamH6 febs via init_H6hashes*/
31 /* */
32 /* FEB-12-04: */
33 /* FLG improved check_ids methods */
34 /* */
35 /* Set of instances developped in the following: */
36 /* LAronline_ID::destructor & constructor */
37 /* LArOnlineID::feedthroughContext() */
38 /* LArOnlineID::channelContext() */
39 /* LArOnlineID::initialize_from_dictionary(IdDictMgr&) */
40 /* LArOnlineID::get_expanded_id(HWIdentifier, ExpandedIdentifier, IdContext)*/
41 /* LArOnlineID::initLevelsFromDict() */
42 /* LArOnlineID::init_hashes() */
43 /* LArOnlineID::init_H8hashes() */
44 /* LArOnlineID::init_H6hashes() */
45 
46 LArOnlineID_Base::LArOnlineID_Base(void) :
47  m_this_is_slar(false),
48  m_laronlineRegion_index(999),
49  m_lar_index(999),
50  m_laronline_index(999),
51  m_bec_index(999),
52  m_side_index(999),
53  m_feedthrough_index(999),
54  m_slot_index(999),
55  m_channel_in_slot_index(999),
56  m_slar_index(999),
57  m_dict(nullptr),
58  m_feedthroughHashMax(0),
59  m_febHashMax(0),
60  m_channelHashMax(0),
61  m_calibModuleHashMax(0),
62  m_calibChannelHashMax(0)
63 {
64 }
65 
66 
67 LArOnlineID_Base::~LArOnlineID_Base(void)
68 = default;
69 
70 
71 //==================================================================
72 std::string LArOnlineID_Base::feedthrough_name( const HWIdentifier id )const{
73 //==================================================================
74  std::string result;
75  int ft = feedthrough(id);
76  if( barrel_ec(id)== 0 ){
77  // if BARREL
78  if( pos_neg(id) == 1 ){
79  // if EMBA
80  if( ft==31 ){result = "I01R";}
81  if( ft==0 ){result = "I01L";}
82  if( ft==1 ){result = "I02R";}
83  if( ft==2 ){result = "I02L";}
84  if( ft==3 ){result = "I03R";}
85  if( ft==4 ){result = "I03L";}
86  if( ft==5 ){result = "I04R";}
87  if( ft==6 ){result = "I04L";}
88  if( ft==7 ){result = "I05R";}
89  if( ft==8 ){result = "I05L";}
90  if( ft==9 ){result = "I06R";}
91  if( ft==10 ){result = "I06L";}
92  if( ft==11 ){result = "I07R";}
93  if( ft==12 ){result = "I07L";}
94  if( ft==13 ){result = "I08R";}
95  if( ft==14 ){result = "I08L";}
96  if( ft==15 ){result = "I09R";}
97  if( ft==16 ){result = "I09L";}
98  if( ft==17 ){result = "I10R";}
99  if( ft==18 ){result = "I10L";}
100  if( ft==19 ){result = "I11R";}
101  if( ft==20 ){result = "I11L";}
102  if( ft==21 ){result = "I12R";}
103  if( ft==22 ){result = "I12L";}
104  if( ft==23 ){result = "I13R";}
105  if( ft==24 ){result = "I13L";}
106  if( ft==25 ){result = "I14R";}
107  if( ft==26 ){result = "I14L";}
108  if( ft==27 ){result = "I15R";}
109  if( ft==28 ){result = "I15L";}
110  if( ft==29 ){result = "I16R";}
111  if( ft==30 ){result = "I16L";}
112  }
113  else{
114  // EMBC
115  if( ft==15 ){result = "H01R";}
116  if( ft==16 ){result = "H01L";}
117  if( ft==13 ){result = "H02R";}
118  if( ft==14 ){result = "H02L";}
119  if( ft==11 ){result = "H03R";}
120  if( ft==12 ){result = "H03L";}
121  if( ft==9 ){result = "H04R";}
122  if( ft==10){result = "H04L";}
123  if( ft==7 ){result = "H05R";}
124  if( ft==8 ){result = "H05L";}
125  if( ft==5 ){result = "H06R";}
126  if( ft==6 ){result = "H06L";}
127  if( ft==3 ){result = "H07R";}
128  if( ft==4 ){result = "H07L";}
129  if( ft==1 ){result = "H08R";}
130  if( ft==2 ){result = "H08L";}
131  if( ft==31){result = "H09R";}
132  if( ft==0 ){result = "H09L";}
133  if( ft==29 ){result = "H10R";}
134  if( ft==30 ){result = "H10L";}
135  if( ft==27 ){result = "H11R";}
136  if( ft==28 ){result = "H11L";}
137  if( ft==25 ){result = "H12R";}
138  if( ft==26 ){result = "H12L";}
139  if( ft==23 ){result = "H13R";}
140  if( ft==24 ){result = "H13L";}
141  if( ft==21 ){result = "H14R";}
142  if( ft==22 ){result = "H14L";}
143  if( ft==19 ){result = "H15R";}
144  if( ft==20 ){result = "H15L";}
145  if( ft==17 ){result = "H16R";}
146  if( ft==18 ){result = "H16L";}
147  }
148  }
149  if ( barrel_ec(id) == 1 ){
150  // ENDCAP
151  if( pos_neg(id) == 1 ){
152  // EMEC-A
153  if( ft==0 ){result = "A01R";}
154  if( ft==1 ){result = "A01L";}
155  if( ft==2 ){result = "A02R";}
156  if( ft==3 ){result = "A02L";}
157  if( ft==4 ){result = "A03R";}
158  if( ft==5 ){result = "A03L";}
159  if( ft==6 ){result = "A04R";}
160  if( ft==7 ){result = "A05R";}
161  if( ft==8 ){result = "A05L";}
162  if( ft==9 ){result = "A06R";}
163  if( ft==10){result = "A06L";}
164  if( ft==11){result = "A07R";}
165  if( ft==12){result = "A07L";}
166  if( ft==13){result = "A08R";}
167  if( ft==14){result = "A08L";}
168  if( ft==15){result = "A09R";}
169  if( ft==16){result = "A09L";}
170  if( ft==17){result = "A10R";}
171  if( ft==18){result = "A10L";}
172  if( ft==19){result = "A11R";}
173  if( ft==20){result = "A11L";}
174  if( ft==21){result = "A12R";}
175  if( ft==22){result = "A12L";}
176  if( ft==23){result = "A13R";}
177  if( ft==24){result = "A13L";}
178  if( ft==25){result = "A14R";} // ft25-27 are sFCal; A14R, A14L, A15L
179  if( ft==26){result = "A14L";} // will need to be replaced by actual
180  if( ft==27){result = "A15L";} // crate name once it exists
181  }
182  else{
183  // EMEC-C
184  if( ft==11 ){result = "C01R";}
185  if( ft==12 ){result = "C01L";}
186  if( ft==9 ){result = "C02R";}
187  if( ft==10 ){result = "C02L";}
188  if( ft==7 ){result = "C03R";}
189  if( ft==8 ){result = "C03L";}
190  if( ft==4 ){result = "C05R";}
191  if( ft==5 ){result = "C05L";}
192  if( ft==2 ){result = "C06R";}
193  if( ft==3 ){result = "C06L";}
194  if( ft==0 ){result = "C07R";}
195  if( ft==1 ){result = "C07L";}
196  if( ft==23 ){result = "C08R";}
197  if( ft==24 ){result = "C08L";}
198  if( ft==21 ){result = "C09R";}
199  if( ft==22 ){result = "C09L";}
200  if( ft==19 ){result = "C10R";}
201  if( ft==20 ){result = "C10L";}
202  if( ft==17 ){result = "C11R";}
203  if( ft==18 ){result = "C11L";}
204  if( ft==15 ){result = "C12R";}
205  if( ft==16 ){result = "C12L";}
206  if( ft==13 ){result = "C13R";}
207  if( ft==14 ){result = "C13L";}
208  if( ft==6 ){result = "C04L";}
209  if( ft==25 ){result = "C14R";} // ft25-27 are sFCal; C14R, C14L, C15L
210  if( ft==26 ){result = "C14L";} // will need to be replaced by actual
211  if( ft==27 ){result = "C15L";} // crate name once it exists
212  }
213  }
214  return result;
215 }
216 
217 //==================================================================
218 std::string LArOnlineID_Base::channel_name( const HWIdentifier id )const{
219 //==================================================================
220  std::ostringstream s1;
221  //std::string s2;
222  int Nchan = channel(id);
223  int Nslot = slot(id);
224  int Nft = feedthrough(id);
225  std::string det_barrel_endcap = "NODETE";
226  std::string det_side = "/X-SIDE";
227 
228  if( barrel_ec(id) == 0 ) det_barrel_endcap = "BARREL";
229  if( barrel_ec(id) == 1 ) det_barrel_endcap = "ENDCAP";
230  if( pos_neg(id) == 1 ) det_side = "/A-SIDE";
231  if( pos_neg(id) == 0 ) det_side = "/C-SIDE";
232 
233  s1 << det_barrel_endcap
234  << det_side
235  << "/FT-" << Nft
236  << "/SLOT-" << Nslot
237  << "/CHAN-" << Nchan;
238  return s1.str();
239  //return s2;
240 }
241 
242 
243 
244 /* =================================================================== */
245 IdContext LArOnlineID_Base::cryostatEndContext(void) const
246 /* =================================================================== */
247 {
248  ExpandedIdentifier id;
249  return (IdContext(id, 0, m_side_index));
250 }
251 
252 
253 
254 /* =================================================================== */
255 IdContext LArOnlineID_Base::feedthroughContext(void) const
256 /* =================================================================== */
257 {
258  ExpandedIdentifier id;
259  return (IdContext(id, 0, m_feedthrough_index));
260 }
261 
262 
263 
264 
265 /* =================================================================== */
266 IdContext LArOnlineID_Base::channelContext(void) const
267 /* =================================================================== */
268 {
269  ExpandedIdentifier id;
270  return (IdContext(id, 0, m_channel_in_slot_index));
271 }
272 
273 
274 
275 /* =================================================================== */
276 IdContext LArOnlineID_Base::febContext(void) const
277 /* =================================================================== */
278 {
279  ExpandedIdentifier id;
280  return (IdContext(id, 0, m_slot_index));
281 }
282 
283 
284 
285 /* =================================================================== */
286 int LArOnlineID_Base::channelInSlotMax(const HWIdentifier channelId) const
287 /* =================================================================== */
288 {
289 
290  ExpandedIdentifier expId;
291  IdContext context = channelContext();
292  if(!get_expanded_id(channelId, expId, &context)) {
293  int result = -999;
294  for (unsigned int i = 0; i < m_full_laronline_range.size(); ++i) {
295  const Range& range = m_full_laronline_range[i];
296  if (range.match(expId)) {
297  const Range::field& channel_in_slot_field = range[m_channel_in_slot_index];
298  if (channel_in_slot_field.has_maximum()) {
299  int channel_in_slotmax = channel_in_slot_field.get_maximum();
300  if (result < channel_in_slotmax) result = channel_in_slotmax + 1;
301  }
302  }
303  }
304  return (result);
305  }
306  return (-999); // default
307 }
308 
309 
310 
311 
312 
313 /* =================================================================== */
314 int LArOnlineID_Base::initialize_from_dictionary (const IdDictMgr& dict_mgr)
315 /* =================================================================== */
316 {
317  MsgStream log(m_msgSvc, "LArOnlineID_Base" );
318  if (!m_quiet) {
319  std::string strg = "initialize_from_dictionary";
320  if(m_msgSvc) {
321  log << MSG::INFO << strg << endmsg;
322  }
323  else {
324  std::cout << strg << std::endl;
325  }
326  }
327 
328  // Check whether this helper should be reinitialized
329  if (!reinitialize(dict_mgr)) {
330  if(m_msgSvc)log << MSG::DEBUG << "Request to reinitialize not satisfied - tags have not changed" << endmsg;
331  return (0);
332  }
333  else {
334  log << MSG::DEBUG << "(Re)initialize" << endmsg;
335  }
336 
337  // init base object
338  if(AtlasDetectorID::initialize_from_dictionary(dict_mgr)) return (1);
339  m_dict = dict_mgr.find_dictionary ("LArCalorimeter");
340  if(!m_dict) {
341 
342  std::string strg = " initialize_from_dictionary - cannot access LArCalorimeter dictionary ";
343  if(m_msgSvc) {
344  log << MSG::ERROR << strg << endmsg;
345  }
346  else {
347  std::cout << "LArOnlineID_Base::" << strg << std::endl;
348  }
349  return 1;
350  }
351 
352  // Register version of the dictionary used
353  if (register_dict_tag(dict_mgr, "LArCalorimeter")) return(1);
354 
355  // initialize dictionary version
356  AtlasDetectorID::setDictVersion(dict_mgr, "LArCalorimeter");
357 
358  /* Initialize the field indices */
359 // if(initLevelsFromDict()) return (1);
360  std::string group_name("LArOnline");
361  if ( m_this_is_slar ) group_name+="_SuperCell";
362  if(initLevelsFromDict(group_name)) return (1);
363 
364 
365  /* Find value for the field LAr Calorimeter */
366  const IdDictDictionary* atlasDict = dict_mgr.find_dictionary ("ATLAS");
367  int larField = -1;
368  if (atlasDict->get_label_value("subdet", "LArCalorimeter", larField)) {
369  std::stringstream strm;
370  strm << atlasDict->m_name;
371  std::string strg= " Could not get value for label 'LArCalorimeter' of field 'subdet' in dictionary "+strm.str();
372  if(m_msgSvc) {
373  log << MSG::ERROR << strg << endmsg;
374  }
375  else {
376  std::cout << "LArOnlineID_Base:" << strg << std::endl;
377  }
378  return (1);
379  }
380 
381  /* Find value for the field LArOnline */
382  int larOnlineField = -4;
383  if (m_dict->get_label_value("part", "LArOnline", larOnlineField)) {
384  std::stringstream strm;
385  strm << m_dict->m_name;
386  std::string strg = "Could not get value for label 'LArOnline' of field 'part' in dictionary "+strm.str();
387  if(m_msgSvc) {
388  log << MSG::ERROR << strg << endmsg;
389  }
390  else {
391  std::cout << strg << std::endl;
392  }
393  return (1);
394  }
395 
396  /* Find value for the field calibLArOnline */
397  int larOnlineCalibField = -5;
398  if (m_dict->get_label_value("part", "LArOnlineCalib", larOnlineCalibField)) {
399  std::stringstream strm;
400  strm << m_dict->m_name;
401  std::string strg = "Could not get value for label 'LArOnlineCalib' of field 'part' in dictionary "+strm.str();
402  if(m_msgSvc) {
403  log << MSG::ERROR << strg << endmsg;
404  }
405  else {
406  std::cout << strg << std::endl;
407  }
408  return (1);
409  }
410 
411  /* Set up id for Region and range prefix */
412  ExpandedIdentifier region_id;
413  region_id.add(larField);
414  region_id.add(larOnlineField);
415  Range prefix;
416  /* Calib Multirange */
417  ExpandedIdentifier region_id2;
418  region_id2.add(larField);
419  region_id2.add(larOnlineCalibField);
420  Range prefix2;
421 
422  /*Full range for all channels*/
423  m_full_laronline_range = m_dict->build_multirange( region_id , group_name, prefix);
424  m_full_feb_range = m_dict->build_multirange( region_id , group_name, prefix, "slot");
425  m_full_feedthrough_range = m_dict->build_multirange( region_id , group_name, prefix, "feedthrough");
426 
427  std::string strg0= " initialize_from_dictionary :";
428  std::string strg1= " feedthrough range -> " + (std::string)m_full_feedthrough_range;
429  std::string strg2= " feedthrough slot range -> " + (std::string)m_full_feb_range;
430  std::string strg3= " channel range -> " + (std::string)m_full_laronline_range;
431  if(m_msgSvc) {
432  log << MSG::DEBUG << strg0 << endmsg;
433  log << MSG::DEBUG << strg1 << endmsg;
434  log << MSG::DEBUG << strg2 << endmsg;
435  log << MSG::DEBUG << strg3 << endmsg;
436  }
437  else {
438  std::cout << strg0 << std::endl;
439  std::cout << strg1 << std::endl;
440  std::cout << strg2 << std::endl;
441  std::cout << strg3 << std::endl;
442  }
443 
444  /* calib */
445  /* Full range for calib channels */
446  m_full_calib_laronline_range = m_dict->build_multirange( region_id2 , group_name, prefix2);
447  m_full_calib_module_range = m_dict->build_multirange( region_id2 , group_name, prefix2, "slot");
448 
449  if (!m_quiet) {
450  std::string strg0= "=> initialize_from_dictionary : ";
451  std::string strg2= "=> Calib module range -> " + (std::string)m_full_calib_module_range;
452  std::string strg3= "=> Calib channel range -> " + (std::string)m_full_calib_laronline_range;
453  if(m_msgSvc) {
454  log << MSG::DEBUG << strg0 << endmsg;
455  log << MSG::DEBUG << strg2 << endmsg;
456  log << MSG::DEBUG << strg3 << endmsg;
457  }
458  else {
459  std::cout << strg0 << std::endl;
460  std::cout << strg2 << std::endl;
461  std::cout << strg3 << std::endl;
462  }
463  }
464 
465  /* Setup the hash tables */
466  std::string strg="[initialize_from_dictionary] version= " + dictionaryVersion();
467  if(m_msgSvc) {
468  log << MSG::DEBUG << strg << endmsg;
469  }
470  else {
471  std::cout << "LArOnlineID_Base: " << strg << std::endl;
472  }
473  if( dictionaryVersion() == "fullAtlas" ) {
474  if(init_hashes()) return (1);
475  }
476 
477  // Setup for hash calculation for channels (febs is further below)
478 
479  // Febs have a uniform number of channels
480  // The lookup table only needs to contain the
481  // hash offset for each feb
482 
483  // The implementation requires:
484 
485  // 1) a lookup table for each feb containing hash offset
486  // 2) a decoder to access the "index" corresponding to the
487  // bec/side/ft/slot fields. These fields use x bits, so the
488  // vector has a length of 2**x.
489 
490  /* Create decoder for fields bec to slot */
491  IdDictFieldImplementation::size_type bits =
492  m_bec_impl.bits() +
493  m_side_impl.bits() +
494  m_feedthrough_impl.bits() +
495  m_slot_impl.bits();
496  IdDictFieldImplementation::size_type bits_offset = m_bec_impl.bits_offset();
497  m_bec_slot_impl.set_bits(bits, bits_offset);
498  int size = (1 << bits);
499 
500  // Set up vector as lookup table for hash calculation.
501  m_chan_hash_calcs.resize(size);
502 
503  for (unsigned int i = 0; i < m_febHashMax; ++i) {
504 
505  HWIdentifier febId = feb_Id(i) ;
506 
507  HashCalc hc;
508 
509  HWIdentifier min = channel_Id ( febId, 0);
510 
511  IdentifierHash min_hash = channel_Hash_binary_search(min);
512  hc.m_hash = min_hash;
513  m_chan_hash_calcs[m_bec_slot_impl.unpack(min)] = hc;
514 
515  if (m_bec_slot_impl.unpack(min) >= size) {
516  strg = "Min > "+std::to_string(size);
517  strg1= " "+ show_to_string(min);
518  strg2= " "+std::to_string(m_bec_slot_impl.unpack(min));
519  if(m_msgSvc) {
520  log << MSG::DEBUG << strg << endmsg;
521  log << MSG::DEBUG << strg1 << endmsg;
522  log << MSG::DEBUG << strg2 << endmsg;
523  }
524  else {
525  std::cout << strg << std::endl;
526  std::cout << strg1 << std::endl;
527  std::cout << strg2 << std::endl;
528  }
529  }
530  }
531 
532  // Check channel hash calculation
533  for (unsigned int i = 0; i < m_channelHashMax; ++i) {
534  HWIdentifier id = channel_Id(i);
535  if (channel_Hash(id) != i) {
536  strg = " ***** Error channel ranges, id, hash, i = "+show_to_string(id);
537  strg1= " , "+std::to_string(channel_Hash(id));
538  strg2= " , "+std::to_string(i);
539  if(m_msgSvc) {
540  log << MSG::ERROR << strg << endmsg;
541  log << MSG::ERROR << strg1 << endmsg;
542  log << MSG::ERROR << strg2 << endmsg;
543  }
544  else {
545  std::cout << strg << std::endl;
546  std::cout << strg1 << std::endl;
547  std::cout << strg2 << std::endl;
548  }
549  }
550  }
551 
552 
553 
554  // Setup for hash calculation for febs
555 
556  // We calculate the feb hash by saving the hash of each
557  // feedthrough in a HashCalc object and then adding on the slot
558  // number for a particular feb
559 
560  // The implementation requires:
561 
562  // 1) a lookup table for each ft containing hash offset
563  // 2) a decoder to access the "index" corresponding to the
564  // bec/side/ft fields. These fields use x bits, so the
565  // vector has a length of 2**x.
566 
567  /* Create decoder for fields bec to ft */
568  bits = m_bec_impl.bits() +
569  m_side_impl.bits() +
570  m_feedthrough_impl.bits();
571  bits_offset = m_bec_impl.bits_offset();
572  m_bec_ft_impl.set_bits(bits, bits_offset);
573  size = (1 << bits);
574 
575  // Set up vector as lookup table for hash calculation.
576  m_feb_hash_calcs.resize(size);
577 
578  // Get context for conversion to expanded ids
579  IdContext ftContext = feedthroughContext();
580  ExpandedIdentifier ftExpId;
581 
582  for (unsigned int i = 0; i < m_feedthroughHashMax; ++i) {
583 
584  HWIdentifier min = feedthrough_Id(i) ;
585 
586  HashCalcFeb hc;
587 
588  // Set the hash id for each feedthrough, and then check if one
589  // needs to also save the slot values
590  IdentifierHash min_hash = feb_Hash_binary_search(min);
591  hc.m_hash = min_hash;
592 
593  // For each feedthrough we must check to see if the slot
594  // values are enumerated or not. If they are enumerate we must
595  // save the values in order to calculate the fed hash
596  if (get_expanded_id(min, ftExpId, &ftContext)) {
597  if(m_msgSvc) {
598  log << MSG::WARNING << " ***** Warning cannot get ft expanded id for " << show_to_string(min) << endmsg;
599  } else {
600  std::cout << " ***** Warning cannot get ft expanded id for " << show_to_string(min) << std::endl;
601  }
602  }
603  unsigned int nrangesFound = 0;
604  for (unsigned int i = 0; i < m_full_feb_range.size(); ++i) {
605  if (m_full_feb_range[i].match(ftExpId)) {
606  nrangesFound += 1;
607  const Range::field& slotField = m_full_feb_range[i][m_slot_index];
608  if (slotField.get_mode() == Range::field::enumerated) {
609  // save values
610  hc.m_slot_values = slotField.get_values();
611  }
612  }
613  }
614 
615  // Similarly, if there is more than one range per feedthrough,
616  // this means that slot values are not a continuous range. In
617  // this case, as well, we save all possible slot values
618  if (nrangesFound > 1) {
619  for (unsigned int i = 0; i < m_full_feb_range.size(); ++i) {
620  if (m_full_feb_range[i].match(ftExpId)) {
621  const Range::field& slotField = m_full_feb_range[i][m_slot_index];
622  if (slotField.get_mode() == Range::field::both_bounded) {
623  // save values
624  unsigned int nvalues = slotField.get_maximum() - slotField.get_minimum() + 1;
625  hc.m_slot_values.reserve(hc.m_slot_values.size() + nvalues);
626  for (unsigned int j = 0; j < nvalues; ++j) {
627  hc.m_slot_values.push_back(j + slotField.get_minimum());
628  }
629  }
630  else {
631  if(m_msgSvc) {
632  log << MSG::WARNING << " ***** Warning feb range slot field is NOT both_bounded - id, slot mode: "
633  << show_to_string(min) << " " << slotField.get_mode() << endmsg;
634  } else {
635  std::cout << " ***** Error feb range slot field is NOT both_bounded - id, slot mode: "
636  << show_to_string(min) << " " << slotField.get_mode() << std::endl;
637  }
638  }
639  }
640  }
641  }
642 
643 
644  // Set hash calculator
645  m_feb_hash_calcs[m_bec_ft_impl.unpack(min)] = hc;
646 
647 
648  if (m_bec_ft_impl.unpack(min) >= size) {
649  strg = "Min > " + std::to_string(size) + " " + show_to_string(min) +
650  " " + std::to_string(m_bec_ft_impl.unpack(min)) + " " +
651  std::to_string(min_hash);
652  if (m_msgSvc) {
653  log << MSG::DEBUG << strg << endmsg;
654  } else {
655  std::cout << strg << std::endl;
656  }
657  }
658  }
659 
660  // Check feb hash calculation
661  for (unsigned int i = 0; i < m_febHashMax; ++i) {
662  HWIdentifier id = feb_Id(i);
663  if (feb_Hash(id) != i) {
664  strg = " ***** Error feb ranges, id, hash, i = " +
665  show_to_string(id) + " , " + std::to_string(feb_Hash(id)) + " , "+std::to_string(i);
666  if(m_msgSvc) {
667  log << MSG::ERROR << strg << endmsg;
668  }
669  else {
670  std::cout << strg << std::endl;
671  }
672  }
673  }
674 
675  return 0;
676 }
677 
678 
679 
680 /* ================================================================*/
681 void LArOnlineID_Base::channel_Id_checks( int barrel_ec, int pos_neg, int feedthrough,
682  int slot, int channel ) const
683 /* ================================================================*/
684 {
685  // Check that id is within allowed range
686  // Fill expanded id
687  ExpandedIdentifier expId(lar_exp());
688  expId << s_lar_online_field_value << barrel_ec << pos_neg << feedthrough << slot << channel ;
689  if ( m_this_is_slar ) expId << 1;
690 
691  if (!m_full_laronline_range.match(expId)) {
692  std::string errorMessage = "LArOnlineID_Base::channel_Id_checks() result is not OK: ID, range = "
693  + std::string(expId) + " , " + (std::string)m_full_laronline_range;
694  LArOnlID_Exception except(errorMessage , 99);
695  throw except ;
696  }
697 }
698 
699 /* ================================================================*/
700 void LArOnlineID_Base::channel_Id_checks ( const HWIdentifier febId,
701  int channel ) const
702 /* ================================================================*/
703 {
704  // Check that id is within allowed range
705  // Fill expanded id
706  ExpandedIdentifier expId;
707  IdContext context = febContext();
708  if (get_expanded_id(febId, expId, &context)) {
709  std::string errorMessage = "LArOnlineID_Base::channel_Id_checks(febId) result is not OK: ID = "
710  + show_to_string(febId) ;
711  LArOnlID_Exception except(errorMessage , 99);
712  throw except ;
713  }
714 
715  expId << channel;
716  if ( m_this_is_slar ) expId << 1;
717  if (!m_full_laronline_range.match(expId)) {
718  std::string errorMessage = "LArOnlineID_Base::channel_Id_checks(febId) result is not OK: ID, range = "
719  + std::string(expId) + " , " + (std::string)m_full_laronline_range;
720  LArOnlID_Exception except(errorMessage , 99);
721  throw except ;
722  }
723 }
724 
725 /* ================================================================*/
726 void LArOnlineID_Base::channel_Id_checks ( const HWIdentifier feedthroughId,
727  int slot, int channel ) const
728 /* ================================================================*/
729 {
730  // Check that id is within allowed range
731  // Fill expanded id
732  ExpandedIdentifier expId;
733  IdContext context = feedthroughContext();
734  if (get_expanded_id(feedthroughId, expId, &context)) {
735  std::string errorMessage = "LArOnlineID_Base::channel_Id_checks(feedthroughId) result is not OK: ID = "
736  + show_to_string(feedthroughId) ;
737  LArOnlID_Exception except(errorMessage , 99);
738  throw except ;
739  }
740 
741  expId << slot << channel;
742  if ( m_this_is_slar ) expId << 1;
743  if (!m_full_laronline_range.match(expId)) {
744  std::string errorMessage = "LArOnlineID_Base::channel_Id_checks(feedthroughId) result is not OK: ID, range = "
745  + std::string(expId) + " , " + (std::string)m_full_laronline_range;
746  LArOnlID_Exception except(errorMessage , 99);
747  throw except ;
748  }
749 }
750 
751 /* ================================================================*/
752 void LArOnlineID_Base::feb_Id_checks( int barrel_ec, int pos_neg, int feedthrough, int slot ) const
753 /* ================================================================*/
754 {
755  // Check that id is within allowed range
756  // Fill expanded id
757  ExpandedIdentifier expId(lar_exp());
758  expId << s_lar_online_field_value << barrel_ec << pos_neg << feedthrough << slot ;
759 
760  if ( m_this_is_slar ) expId << 0 << 1;
761  if (!m_full_feedthrough_range.match(expId)) { std::string errorMessage = "LArOnlineID_Base::feb_Id_checks() result is not OK: ID, range = "
762  + std::string(expId) + " , " + (std::string)m_full_feb_range;
763  LArOnlID_Exception except(errorMessage , 99);
764  throw except ;
765  }
766 }
767 
768 /* ================================================================*/
769 void LArOnlineID_Base::feedthrough_Id_checks( int barrel_ec, int pos_neg, int feedthrough ) const
770 /* ==============================================================================*/
771 {
772  // Check that id is within allowed range
773  // Fill expanded id
774  ExpandedIdentifier expId(lar_exp());
775  expId << s_lar_online_field_value << barrel_ec << pos_neg << feedthrough << 0 << 0 << (int)m_this_is_slar;
776 
777 // if ( m_this_is_slar ) expId << 0 << 0 << 1;
778  if (!m_full_feedthrough_range.match(expId)) { std::string errorMessage = "LArOnlineID_Base::feedthrough_Id_checks() result is not OK: ID, range = "
779  + std::string(expId) + " , " + (std::string)m_full_feedthrough_range;
780  LArOnlID_Exception except(errorMessage , 99);
781  throw except ;
782  }
783 }
784 
785 
786 
787 /* =================================================================================*/
788 int LArOnlineID_Base::get_expanded_id (const HWIdentifier& id, ExpandedIdentifier& exp_id,
789  const IdContext* context) const
790 /*==================================================================================*/
791 {
792  // We assume that the context is >= feedthrough
793  exp_id.clear();
794  exp_id << lar_field_value()
795  << s_lar_online_field_value
796  << barrel_ec(id)
797  << pos_neg(id);
798  if(context && context->end_index() >= m_feedthrough_index) {
799  exp_id << feedthrough(id);
800  if(context && context->end_index() >= m_slot_index) {
801  exp_id << slot(id);
802  if(context->end_index() >= m_channel_in_slot_index) {
803  exp_id << channel(id);
804  if(context->end_index() >= m_slar_index) {
805  exp_id << is_slar(id);
806  }
807  }
808  }
809  }
810  return (0);
811 }
812 
813 
814 /* =================================================================================*/
815 int LArOnlineID_Base::get_expanded_calib_id (const HWIdentifier& id, ExpandedIdentifier& exp_id,
816  const IdContext* context) const
817 /*==================================================================================*/
818 {
819  // We assume that the context is >= feedthrough
820  exp_id.clear();
821  exp_id << lar_field_value()
822  << s_lar_onlineCalib_field_value
823  << barrel_ec(id)
824  << pos_neg(id)
825  << feedthrough(id);
826  if(context && context->end_index() >= m_slot_index) {
827  exp_id << slot(id);
828  if(context->end_index() >= m_channel_in_slot_index) {
829  exp_id << channel(id);
830  if(context->end_index() >= m_slar_index) {
831  exp_id << is_slar(id);
832  }
833  }
834  }
835  return (0);
836 }
837 
838 
839 
840 /*======================================*/
841 int LArOnlineID_Base::initLevelsFromDict(const std::string& group_name)
842 /*======================================*/
843 {
844  MsgStream log(m_msgSvc, "LArOnlineID_Base" );
845 
846  if(!m_dict)
847  {
848  if(m_msgSvc) {
849  log << MSG::ERROR << "initLevelsFromDict - dictionary NOT initialized "
850  << endmsg;
851  }
852  else {
853  std::cout << "LArEM_ID::initLevelsFromDict - dictionary NOT initialized "
854  << std::endl ;
855  }
856  return (1);
857  }
858 
859  /* Find out which identifier field corresponds to each level.*/
860 
861  m_lar_index = 999 ;
862  m_laronline_index = 999 ;
863  m_bec_index = 999 ;
864  m_side_index = 999 ;
865  m_feedthrough_index = 999 ;
866  m_slot_index = 999 ;
867  m_channel_in_slot_index = 999 ;
868  m_slar_index = 999 ;
869  std::string strg;
870 
871  // Save index to a DictionaryRegion for unpacking
872  IdDictRegion* reg = m_dict->find_region("laronline-barrel");
873  if (reg)
874  {
875  m_laronlineRegion_index = reg->m_index;
876  }
877  else
878  {
879  strg = "initLevelsFromDict - unable to find laronline region ";
880  if(m_msgSvc)
881  {
882  log << MSG::ERROR << strg << endmsg;
883  }
884  else
885  {
886  std::cout << "LAronline_ID::" << strg << std::endl;
887  }
888  return (1);
889  }
890  /* Find LAr field */
891  IdDictField* field = m_dict->find_field("subdet") ;
892  if (field)
893  {
894  m_lar_index = field->m_index ;
895  }
896  else
897  {
898  strg= "initLevelsFromDict - unable to find 'subdet' field ";
899  if(m_msgSvc)
900  {
901  log << MSG::ERROR << strg << endmsg;
902  }
903  else
904  {
905  std::cout << "LArOnlineID_Base::" << strg << std::endl;
906  }
907  return (1);
908  }
909 
910  /* Find LArOnline field */
911  field = m_dict->find_field("part") ;
912  if (field)
913  {
914  m_laronline_index = field->m_index ;
915  }
916  else
917  {
918  strg= "initLevelsFromDict - unable to find 'part' field ";
919  if(m_msgSvc)
920  {
921  log << MSG::ERROR << strg << endmsg;
922  }
923  else
924  {
925  std::cout << "LArOnlineID_Base::" << strg << std::endl;
926  }
927  return (1);
928  }
929 
930  /* Find barrel-endcap field */
931  field = m_dict->find_field("barrel-ec") ;
932  if (field)
933  {
934  m_bec_index = field->m_index ;
935  }
936  else
937  {
938  strg= "initLevelsFromDict - unable to find 'barrel-endcap' field ";
939  if(m_msgSvc)
940  {
941  log << MSG::ERROR << strg << endmsg;
942  }
943  else
944  {
945  std::cout << "LArOnlineID_Base::" << strg << std::endl;
946  }
947  return (1);
948  }
949 
950  /* Find detector-side field */
951  field = m_dict->find_field("pos_neg") ;
952  if (field)
953  {
954  m_side_index = field->m_index ;
955  }
956  else
957  {
958  strg= "initLevelsFromDict - unable to find 'barrel-endcap' field ";
959  if(m_msgSvc)
960  {
961  log << MSG::ERROR << strg << endmsg;
962  }
963  else
964  {
965  std::cout << "LArOnlineID_Base::" << strg << std::endl;
966  }
967  return (1);
968  }
969 
970  /* Find feedthrough field */
971  std::string feedthrough_name;
972  if ( m_this_is_slar ){
973  feedthrough_name+="slar_feedthrough";
974  } else {
975  feedthrough_name+="feedthrough";
976  }
977  field = m_dict->find_field(feedthrough_name) ;
978  if (field) {
979  m_feedthrough_index = field->m_index ;
980  }
981  else
982  {
983  strg = "initLevelsFromDict - unable to find 'feedthrough' field ";
984  if(m_msgSvc)
985  {
986  log << MSG::ERROR << strg << endmsg;
987  }
988  else
989  {
990  std::cout << "LArOnlineID_Base::" << strg << std::endl;
991  }
992  return (1);
993  }
994 
995  /* Find slot field */
996  std::string slot_name;
997  if ( m_this_is_slar ){
998  slot_name+="slar_slot";
999  } else {
1000  slot_name+="slot";
1001  }
1002  field = m_dict->find_field(slot_name) ;
1003  if (field)
1004  {
1005  m_slot_index = field->m_index ;
1006  }
1007  else
1008  {
1009  strg = "initLevelsFromDict - unable to find 'slot' field ";
1010  if(m_msgSvc)
1011  {
1012  log << MSG::ERROR << strg << endmsg;
1013  }
1014  else
1015  {
1016  std::cout << "LArOnlineID_Base::" << strg << std::endl;
1017  }
1018  return (1);
1019  }
1020 
1021  /* Find channel_in_slot field */
1022  std::string channel_name;
1023  if ( m_this_is_slar ){
1024  channel_name+="sch_in_slot";
1025  } else {
1026  channel_name+="channel_in_slot";
1027  }
1028  field = m_dict->find_field(channel_name) ;
1029  if (field)
1030  {
1031  m_channel_in_slot_index = field->m_index ;
1032  }
1033  else
1034  {
1035  strg = "initLevelsFromDict - unable to find 'channel_in_slot' field ";
1036  if(m_msgSvc)
1037  {
1038  log << MSG::ERROR << strg << endmsg;
1039  }
1040  else
1041  {
1042  std::cout << "LArOnlineID_Base::" << strg << std::endl;
1043  }
1044  return (1);
1045  }
1046 
1047  /* Find slar field */
1048  if ( m_this_is_slar ) {
1049  field = m_dict->find_field("is-slar") ;
1050  if (field)
1051  {
1052  m_slar_index = field->m_index ;
1053  }
1054  else
1055  {
1056  strg = "initLevelsFromDict - unable to find 'slar' field ";
1057  if(m_msgSvc)
1058  {
1059  log << MSG::ERROR << strg << endmsg;
1060  }
1061  else
1062  {
1063  std::cout << "LArOnline_SuperCellID::" << strg << std::endl;
1064  }
1065  return (1);
1066  }
1067  } // end of m_this_is_slar
1068 
1069  /* Set the field implementations */
1070 
1071  IdDictGroup* group = m_dict->find_group(group_name);
1072  if ( !group ) {
1073  log << MSG::ERROR << "initLevelsFromDict - cannot find "
1074  << group_name << endmsg;
1075  } else {
1076  m_laronlineRegion_index = group->regions()[0]->m_index;
1077  }
1078 
1079  const IdDictRegion& region = *m_dict->m_regions[m_laronlineRegion_index];
1080 
1081  m_lar_impl = region.m_implementation[m_lar_index];
1082  m_laronline_impl = region.m_implementation[m_laronline_index];
1083  m_bec_impl = region.m_implementation[m_bec_index];
1084  m_side_impl = region.m_implementation[m_side_index];
1085  m_feedthrough_impl = region.m_implementation[m_feedthrough_index];
1086  m_slot_impl = region.m_implementation[m_slot_index];
1087  m_channel_in_slot_impl= region.m_implementation[m_channel_in_slot_index];
1088  if ( m_this_is_slar )
1089  m_slar_impl = region.m_implementation[m_slar_index];
1090 
1091  if (!m_quiet) {
1092  if(m_msgSvc) {
1093  log << MSG::DEBUG << "decode index and bit fields for each level: " << endmsg;
1094  log << MSG::DEBUG << "lar " << m_lar_impl.show_to_string() << endmsg;
1095  log << MSG::DEBUG << "online " << m_laronline_impl.show_to_string() << endmsg;
1096  log << MSG::DEBUG << "bec " << m_bec_impl.show_to_string() << endmsg;
1097  log << MSG::DEBUG << "side " << m_side_impl.show_to_string() << endmsg;
1098  log << MSG::DEBUG << "ft " << m_feedthrough_impl.show_to_string() << endmsg;
1099  log << MSG::DEBUG << "slot " << m_slot_impl.show_to_string() << endmsg;
1100  log << MSG::DEBUG << "channel " << m_channel_in_slot_impl.show_to_string() << endmsg;
1101  if ( m_this_is_slar )
1102  log << MSG::DEBUG << "is-slar " << m_slar_impl.show_to_string() << endmsg;
1103  }
1104  else {
1105  std::cout << "decode index and bit fields for each level: " << std::endl;
1106  std::cout << "lar " << m_lar_impl.show_to_string() << std::endl;
1107  std::cout << "online " << m_laronline_impl.show_to_string() << std::endl;
1108  std::cout << "bec " << m_bec_impl.show_to_string() << std::endl;
1109  std::cout << "side " << m_side_impl.show_to_string() << std::endl;
1110  std::cout << "ft " << m_feedthrough_impl.show_to_string() << std::endl;
1111  std::cout << "solt " << m_slot_impl.show_to_string() << std::endl;
1112  std::cout << "channel " << m_channel_in_slot_impl.show_to_string() << std::endl;
1113  if ( m_this_is_slar )
1114  std::cout << "slar " << m_slar_impl.show_to_string() << std::endl;
1115  }
1116  }
1117 
1118  return(0) ;
1119 }
1120 
1121 
1122 
1123 /*======================================*/
1124 int LArOnlineID_Base::init_hashes(void)
1125 /*======================================*/
1126 {
1127  MsgStream log(m_msgSvc, "LArOnlineID_Base" );
1128  std::string strg1;
1129  std::string strg2;
1130  std::string strg3;
1131 
1132  /* channel hash */
1133  m_channelHashMax = m_full_laronline_range.cardinality();
1134  m_channel_vec.resize(m_channelHashMax);
1135  unsigned int nids = 0;
1136  std::set<HWIdentifier> ids;
1137  for (unsigned int i = 0; i < m_full_laronline_range.size(); ++i)
1138  {
1139  const Range& range = m_full_laronline_range[i];
1140  Range::const_identifier_factory first = range.factory_begin();
1141  Range::const_identifier_factory last = range.factory_end();
1142  for (; first != last; ++first)
1143  {
1144  const ExpandedIdentifier& exp_id = (*first);
1145  HWIdentifier id = this->channel_Id (exp_id[m_bec_index],
1146  exp_id[m_side_index],
1147  exp_id[m_feedthrough_index],
1148  exp_id[m_slot_index],
1149  exp_id[m_channel_in_slot_index]);
1150  if(!(ids.insert(id)).second)
1151  {
1152  strg1 = " init_hashes: duplicated id for channel nb = "+std::to_string(nids);
1153  strg3 = " expanded Id= "+show_to_string(id);
1154  if(m_msgSvc)
1155  {
1156  log << MSG::ERROR << strg1 << endmsg;
1157  //log << MSG::ERROR << strg2 << endmsg;
1158  log << MSG::ERROR << strg3 << endmsg;
1159  }
1160  else
1161  {
1162  std::cout << "LArOnlineID_Base::Error" << strg1 << std::endl;
1163  //std::cout << strg2 << std::endl;
1164  std::cout << strg3 << std::endl;
1165  }
1166  }
1167  nids++;
1168  }
1169  }
1170  if(ids.size() != m_channelHashMax)
1171  {
1172  strg1 = " init_hashes ";
1173  strg2 = " set size NOT EQUAL to hash max. size "+std::to_string(ids.size());
1174  strg3 = " hash max "+std::to_string(m_channelHashMax);
1175  if(m_msgSvc)
1176  {
1177  log << MSG::ERROR << strg1 << endmsg;
1178  log << MSG::ERROR << strg2 << endmsg;
1179  log << MSG::ERROR << strg3 << endmsg;
1180  }
1181  else
1182  {
1183  std::cout << "LArOnlineID_Base::" << strg1 << std::endl;
1184  std::cout << "Error" << strg2 << std::endl;
1185  std::cout << strg3 << std::endl;
1186  }
1187  return (1);
1188  }
1189  nids=0;
1190  std::set<HWIdentifier>::const_iterator first = ids.begin();
1191  std::set<HWIdentifier>::const_iterator last = ids.end();
1192  for (;first != last && nids < m_channel_vec.size(); ++first)
1193  {
1194  m_channel_vec[nids] = (*first) ;
1195  nids++;
1196  }
1197 
1198  /* feedthrough hash */
1199  m_feedthroughHashMax = m_full_feedthrough_range.cardinality();
1200  m_feedthrough_vec.resize(m_feedthroughHashMax);
1201  nids = 0;
1202  ids.clear();
1203  for (unsigned int i = 0; i < m_full_feedthrough_range.size(); ++i)
1204  {
1205  const Range& range = m_full_feedthrough_range[i];
1206  Range::const_identifier_factory first = range.factory_begin();
1207  Range::const_identifier_factory last = range.factory_end();
1208  for (; first != last; ++first) {
1209  const ExpandedIdentifier& exp_id = (*first);
1210  HWIdentifier feedthroughId = feedthrough_Id( exp_id[m_bec_index],
1211  exp_id[m_side_index],
1212  exp_id[m_feedthrough_index] );
1213  if(!(ids.insert(feedthroughId)).second){
1214  strg1 = " init_hashes: duplicated id for feedthrough nb = "+std::to_string(nids);
1215  strg3 = " expanded Id= "+show_to_string(feedthroughId);
1216  if(m_msgSvc)
1217  {
1218  log << MSG::ERROR << strg1 << endmsg;
1219  //log << MSG::ERROR << strg2 << endmsg;
1220  log << MSG::ERROR << strg3 << endmsg;
1221  }
1222  else
1223  {
1224  std::cout << "LArOnlineID_Base:: Error" << strg1 << std::endl;
1225  //std::cout << strg2 << std::endl;
1226  std::cout << strg3 << std::endl;
1227  }
1228  }
1229  nids++;
1230  }
1231  }
1232  if(ids.size() != m_feedthroughHashMax)
1233  {
1234  strg1 = " init_hashes ";
1235  strg2 = " set size NOT EQUAL to feedthrough hash max. size "+std::to_string(ids.size());
1236  strg3 = " hash max= "+std::to_string(m_feedthroughHashMax);
1237  if(m_msgSvc)
1238  {
1239  log << MSG::ERROR << strg1 << endmsg;
1240  log << MSG::ERROR << strg2 << endmsg;
1241  log << MSG::ERROR << strg3 << endmsg;
1242  }
1243  else
1244  {
1245  std::cout << "LArOnlineID_Base::" << strg1 << std::endl;
1246  std::cout << " Error:" << strg2 << std::endl;
1247  std::cout << strg3 << std::endl;
1248  }
1249  return (1);
1250  }
1251  nids=0;
1252  first = ids.begin();
1253  last = ids.end();
1254  for (;first != last && nids < m_feedthrough_vec.size(); ++first)
1255  {
1256  m_feedthrough_vec[nids] = (*first) ;
1257  nids++;
1258  }
1259 
1260  /* FEB hash */
1261  /*==========*/
1262  m_febHashMax = m_full_feb_range.cardinality();
1263  m_feb_vec.resize(m_febHashMax);
1264  nids = 0;
1265  ids.clear();
1266  for (unsigned int i = 0; i < m_full_feb_range.size(); ++i)
1267  {
1268  const Range& range = m_full_feb_range[i];
1269  Range::const_identifier_factory first = range.factory_begin();
1270  Range::const_identifier_factory last = range.factory_end();
1271  for (; first != last; ++first)
1272  {
1273  const ExpandedIdentifier& exp_id = (*first);
1274  HWIdentifier febId = feb_Id( exp_id[m_bec_index],
1275  exp_id[m_side_index],
1276  exp_id[m_feedthrough_index],
1277  exp_id[m_slot_index] );
1278  if(!(ids.insert(febId)).second)
1279  {
1280  strg1 = " init_hashes: duplicated id for FEB nb = "+std::to_string(nids);
1281  strg3 = " expanded Id= "+show_to_string(febId);
1282  if(m_msgSvc)
1283  {
1284  log << MSG::ERROR << strg1 << endmsg;
1285  //log << MSG::ERROR << strg2 << endmsg;
1286  log << MSG::ERROR << strg3 << endmsg;
1287  }
1288  else
1289  {
1290  std::cout << "LArOnlineID_Base::Error:" << strg1 << std::endl;
1291  //std::cout << strg2 << std::endl;
1292  std::cout << strg3 << std::endl;
1293  }
1294  }
1295  nids++;
1296  }
1297  }
1298  if(ids.size() != m_febHashMax)
1299  {
1300  strg1 = " init_hashes ";
1301  strg2 = " set size NOT EQUAL to FEB hash max. size "+std::to_string(ids.size());
1302  strg3 = " hash max "+std::to_string(m_febHashMax);
1303  if(m_msgSvc)
1304  {
1305  log << MSG::ERROR << strg1 << endmsg;
1306  log << MSG::ERROR << strg2 << endmsg;
1307  log << MSG::ERROR << strg3 << endmsg;
1308  }
1309  else
1310  {
1311  std::cout << "LArOnlineID_Base::" << strg1 << std::endl;
1312  std::cout << "Error:" << strg2 << std::endl;
1313  std::cout << strg3 << std::endl;
1314  }
1315  return (1);
1316  }
1317  nids=0;
1318  first = ids.begin();
1319  last = ids.end();
1320  for (;first != last && nids < m_feb_vec.size(); ++first)
1321  {
1322  m_feb_vec[nids] = (*first) ;
1323  nids++;
1324  }
1325 
1326 
1327  return (0);
1328 }
1329 
1330 
1331 
1332 
1333 bool LArOnlineID_Base::isValidId(const HWIdentifier id) const {
1334 
1335 
1336  const int larid=m_lar_impl.unpack(id);
1337  const int laronlineid=m_laronline_impl.unpack(id);
1338  if (larid!=lar_field_value()) return false;
1339 
1340  if (laronlineid!=s_lar_online_field_value && laronlineid!=s_lar_onlineCalib_field_value) return false;
1341 
1342  const int channel=m_channel_in_slot_impl.unpack(id);
1343  if (channel<0 || channel>128) return false;
1344 
1345  const int bec=m_bec_impl.unpack(id);
1346  const int ft=m_feedthrough_impl.unpack(id);
1347  const int slot=m_slot_impl.unpack(id);
1348  if (slot<1) return false;
1349  if (ft<0) return false;
1350  if (bec==0) { // Barrel case
1351  if (ft>31) return false;
1352  if (slot>14) return false;
1353  }
1354  else { //Endcap case
1355  if (ft>27) return false;
1356  if (ft==2 || ft==9 || ft==15 || ft==21){ //Special crate
1357  if (slot >15) return false;
1358  }
1359  else if (ft==6) { //FCAL
1360  if (slot>15) return false;
1361  }
1362  else if (ft>24 && ft<28) { //sFCAL
1363  if (slot>10) return false;
1364  }
1365  else if (ft==3 || ft==10 || ft==16 || ft==22) { //HEC
1366  if (slot==3 || slot==4 || slot>10) return false;
1367  }
1368  else //standard crate
1369  if (slot>13) return false;
1370  }//end endcap
1371  return true;
1372 }
1373 
1374 //=====================
1375 // Inline Definitions
1376 //=====================
1377 
1378 
1379 
1380 
1381 HWIdentifier
1382 LArOnlineID_Base::feedthrough_Id (int barrel_ec, int pos_neg, int feedthrough,
1383  bool checks) const
1384 {
1385  HWIdentifier result(0);
1386 
1387  /*Pack fields independently */
1388  m_lar_impl.pack (lar_field_value(), result);
1389  m_laronline_impl.pack (s_lar_online_field_value, result);
1390  m_bec_impl.pack (barrel_ec , result);
1391  m_side_impl.pack (pos_neg , result);
1392  m_feedthrough_impl.pack(feedthrough , result);
1393  if ( m_this_is_slar )
1394  m_slar_impl.pack (1 , result);
1395 
1396  /* Do checks */
1397  if(checks)
1398  {
1399  feedthrough_Id_checks ( barrel_ec, pos_neg, feedthrough );
1400  }
1401  return result;
1402 }
1403 HWIdentifier
1404 LArOnlineID_Base::feedthrough_Id (int barrel_ec, int pos_neg, int feedthrough) const
1405 {
1406  return feedthrough_Id (barrel_ec, pos_neg, feedthrough, do_checks());
1407 }
1408 
1409 
1410 HWIdentifier LArOnlineID_Base::feedthrough_Id(IdentifierHash feedthroughHashId) const
1411 /*=============================================================================== */
1412 {
1413  return(m_feedthrough_vec[feedthroughHashId]);
1414 }
1415 
1416 IdentifierHash LArOnlineID_Base::feedthrough_Hash (HWIdentifier feedthroughId) const
1417 /*=============================================================================== */
1418 {
1419  std::vector<HWIdentifier>::const_iterator it = std::lower_bound(m_feedthrough_vec.begin(),m_feedthrough_vec.end(),feedthroughId);
1420  if ( it != m_feedthrough_vec.end() ){
1421  return (it - m_feedthrough_vec.begin());
1422  }
1423  return (0);
1424 }
1425 
1426 HWIdentifier LArOnlineID_Base::feedthrough_Id(const HWIdentifier Id) const
1427 /*============================================================================== */
1428 {
1429  HWIdentifier result(Id);
1430  m_slot_impl.reset(result);
1431  m_channel_in_slot_impl.reset(result);
1432  return(result);
1433 }
1434 
1435 LArOnlineID_Base::id_iterator LArOnlineID_Base::feedthrough_begin() const
1436 /*====================================================================*/
1437 {
1438  return(m_feedthrough_vec.begin());
1439 }
1440 
1441 LArOnlineID_Base::id_iterator LArOnlineID_Base::feedthrough_end() const
1442 /*==================================================================*/
1443 {
1444  return(m_feedthrough_vec.end());
1445 }
1446 
1447 LArOnlineID_Base::id_range LArOnlineID_Base::feedthrough_range() const
1448 /*==================================================================*/
1449 {
1450  return {feedthrough_begin(), feedthrough_end()};
1451 }
1452 
1453 
1454 /* FEB id */
1455 /*========*/
1456 
1457 HWIdentifier
1458 LArOnlineID_Base::feb_Id(int barrel_ec, int pos_neg,
1459  int feedthrough, int slot,
1460  bool checks ) const
1461 /*==================================================================== */
1462 {
1463  HWIdentifier result(0);
1464 
1465  /*Pack fields independently */
1466  m_lar_impl.pack (lar_field_value(), result);
1467  m_laronline_impl.pack (s_lar_online_field_value, result);
1468  m_bec_impl.pack (barrel_ec , result);
1469  m_side_impl.pack (pos_neg , result);
1470  m_feedthrough_impl.pack(feedthrough , result);
1471  m_slot_impl.pack (slot , result);
1472  if ( m_this_is_slar )
1473  m_slar_impl.pack (1 , result);
1474 
1475  /* Do checks */
1476  if(checks) {
1477  feb_Id_checks ( barrel_ec, pos_neg, feedthrough, slot );
1478  }
1479  return result;
1480 }
1481 
1482 HWIdentifier
1483 LArOnlineID_Base::feb_Id(int barrel_ec, int pos_neg,
1484  int feedthrough, int slot) const
1485 {
1486  return feb_Id (barrel_ec, pos_neg, feedthrough, slot, do_checks());
1487 }
1488 
1489 HWIdentifier LArOnlineID_Base::feb_Id(const HWIdentifier feedthroughId , int slot) const
1490 /*==================================================================================== */
1491 {
1492  HWIdentifier result(feedthroughId);
1493  /* Pack fields independently */
1494  m_slot_impl.reset (result);
1495  m_slot_impl.pack (slot , result);
1496  if ( m_this_is_slar )
1497  m_slar_impl.pack (1 , result);
1498 
1499  return(result);
1500 }
1501 
1502 HWIdentifier LArOnlineID_Base::feb_Id(const HWIdentifier channelId ) const
1503 /*======================================================================= */
1504 {
1505  HWIdentifier result(channelId);
1506  m_channel_in_slot_impl.reset(result);
1507  return(result);
1508 }
1509 
1510 HWIdentifier LArOnlineID_Base::feb_Id(IdentifierHash febHashId) const
1511 /*================================================================== */
1512 {
1513  return(m_feb_vec[febHashId]);
1514 }
1515 
1516 IdentifierHash LArOnlineID_Base::feb_Hash (HWIdentifier febId) const
1517 /*=============================================================================== */
1518 {
1519  // Get the hash caculator for the febs
1520  const HashCalcFeb& hc = m_feb_hash_calcs[m_bec_ft_impl.unpack(febId)];
1521  // Two cases:
1522  // 1) slot values are enumerated and we must look for a matching
1523  // value to obtain the index
1524  // 2) slot values are a continuous range, then the slot index is
1525  // sufficient for the hash calculation
1526  if (!hc.m_slot_values.empty()) {
1527  // find matching value
1528  int slotValue = slot(febId);
1529  for (int i = 0; (unsigned int)i < hc.m_slot_values.size(); ++i) {
1530  if (slotValue == hc.m_slot_values[i]) return (hc.m_hash + i);
1531  }
1532  MsgStream log(m_msgSvc, "LArOnlineID_Base" );
1533  if(m_msgSvc) {
1534  log << MSG::WARNING << "LArOnlineID_Base::feb_Hash - ***** WARNING: could not match slot value for has calculation " << endmsg;
1535  } else {
1536  std::cout << "LArOnlineID_Base::feb_Hash - ***** WARNING: could not match slot value for has calculation " << std::endl;
1537  }
1538  }
1539  size_type slotIndex = m_slot_impl.unpackToIndex(febId);
1540  return (hc.m_hash + slotIndex);
1541 }
1542 
1543 HWIdentifier
1544 LArOnlineID_Base::channel_Id( int barrel_ec, int pos_neg, int feedthrough,
1545  int slot, int channel,
1546  bool checks) const
1547 /*============================================================================== */
1548 {
1549  HWIdentifier result(0);
1550  /* Pack fields independently */
1551  m_lar_impl.pack (lar_field_value() , result);
1552  m_laronline_impl.pack (s_lar_online_field_value , result);
1553  m_bec_impl.pack (barrel_ec , result);
1554  m_side_impl.pack (pos_neg , result);
1555  m_feedthrough_impl.pack (feedthrough , result);
1556  m_slot_impl.pack (slot , result);
1557  m_channel_in_slot_impl.pack(channel , result);
1558  if ( m_this_is_slar )
1559  m_slar_impl.pack (1 , result);
1560 
1561  /* Do checks */
1562  if(checks) {
1563  channel_Id_checks( barrel_ec, pos_neg, feedthrough, slot, channel );
1564  }
1565  return result;
1566 }
1567 
1568 HWIdentifier
1569 LArOnlineID_Base::channel_Id( int barrel_ec, int pos_neg, int feedthrough,
1570  int slot, int channel) const
1571 {
1572  return channel_Id (barrel_ec, pos_neg, feedthrough, slot, channel,
1573  do_checks());
1574 }
1575 
1576 HWIdentifier LArOnlineID_Base::channel_Id(IdentifierHash channelHashId) const
1577 /*===================================================================*/
1578 {
1579  return(m_channel_vec[channelHashId]);
1580 }
1581 
1582 
1583 HWIdentifier
1584 LArOnlineID_Base::channel_Id(const HWIdentifier feedthroughId,int slot,int channel,
1585  bool checks) const
1586 /*==================================================================================================== */
1587 {
1588  HWIdentifier result(feedthroughId);
1589  /* Pack fields independently */
1590  m_slot_impl.reset (result);
1591  m_channel_in_slot_impl.reset(result);
1592  m_slot_impl.pack (slot , result);
1593  m_channel_in_slot_impl.pack (channel, result);
1594  if ( m_this_is_slar )
1595  m_slar_impl.pack (1 , result);
1596 
1597  /* Do checks */
1598  if(checks) {
1599  channel_Id_checks( feedthroughId, slot, channel );
1600  }
1601  return result;
1602 }
1603 
1604 HWIdentifier
1605 LArOnlineID_Base::channel_Id(const HWIdentifier feedthroughId,int slot,int channel) const
1606 {
1607  return channel_Id (feedthroughId, slot, channel, do_checks());
1608 }
1609 
1610 HWIdentifier
1611 LArOnlineID_Base::channel_Id(const HWIdentifier febId, int channel,
1612  bool checks) const
1613 /*======================================================================================= */
1614 {
1615  HWIdentifier result(febId);
1616  /* Pack fields independently */
1617  m_channel_in_slot_impl.reset(result);
1618  m_channel_in_slot_impl.pack (channel, result);
1619  if ( m_this_is_slar )
1620  m_slar_impl.pack (1, result);
1621 
1622  /* Do checks */
1623  if(checks) {
1624  channel_Id_checks( febId, channel );
1625  }
1626  return result;
1627 }
1628 
1629 HWIdentifier
1630 LArOnlineID_Base::channel_Id(const HWIdentifier febId, int channel) const
1631 {
1632  return channel_Id (febId, channel, do_checks());
1633 }
1634 
1635 //----------------------------------------------------------------------------
1636 IdentifierHash LArOnlineID_Base::channel_Hash (HWIdentifier channelId) const
1637 {
1638  const HashCalc& hc = m_chan_hash_calcs[m_bec_slot_impl.unpack(channelId)];
1639  return (hc.m_hash + channel(channelId));
1640 }
1641 
1642 /* BOOLEAN */
1643 
1644 /*
1645  *=============================================================
1646  *=============================================================
1647  * Recommended methods
1648  *=============================================================
1649  *=============================================================
1650  */
1651 
1652 bool LArOnlineID_Base::isEMBchannel(const HWIdentifier id) const
1653 /*========================================================*/
1654 {
1655  return (barrel_ec(id)==0);
1656 }
1657 bool LArOnlineID_Base::isFCALchannel(const HWIdentifier id) const
1658 /*========================================================*/
1659 {
1660  return ( barrel_ec(id)==1 && feedthrough(id) == 6 );
1661 }
1662 
1663 
1664 
1665 bool LArOnlineID_Base::isEMBPS(const HWIdentifier id) const
1666 /*=================================================================*/
1667 {
1668  int bec= barrel_ec(id);
1669  int sl = slot(id);
1670  return (
1671  bec == 0 && sl == 1
1672  );
1673 }
1674 
1675 bool LArOnlineID_Base::isEMECPS(const HWIdentifier id) const
1676 /*=================================================================*/
1677 {/* redefinition (bug fix) */
1678  return (isEMECOW(id) && slot(id)==1);
1679 }
1680 
1681 bool LArOnlineID_Base::isPS(const HWIdentifier id) const
1682 /*=================================================================*/
1683 {/* redefinition with isEMBPS and isEMECPS */
1684  return ( isEMBPS(id) || isEMECPS(id));
1685 }
1686 
1687 
1688 bool LArOnlineID_Base::isNotWarmCableConnected(const HWIdentifier id) const
1689 /*========================================================*/
1690 {
1691  int ft = feedthrough(id);
1692  int sl = slot(id);
1693  int ch = channel(id);
1694  return (
1695  (
1696  isEMBchannel(id) &&
1697  ( (-1 < ft && ft < 32) &&
1698  ( sl == 14 ) &&
1699  ( 63 < ch && ch < 128 )
1700  )
1701  )
1702  ||
1703  (
1704  isEMECchannel(id) && sl == 1 &&
1705  (ft == 2 || ft == 9 || ft == 15 || ft == 21 ) &&
1706  (63 < ch && ch < 128)
1707  )
1708  );
1709 }
1710 
1711 
1712 /*
1713  *=============================================================
1714  *=============================================================
1715  * Obsolete methods
1716  *=============================================================
1717  *=============================================================
1718  */
1719 
1720 bool LArOnlineID_Base::isEmBarrelOnline(const HWIdentifier id) const
1721 /*========================================================*/
1722 {/* redefined to isEMBchannel() */
1723  return (isEMBchannel(id));
1724 }
1725 
1726 bool LArOnlineID_Base::isEndcapOnline(const HWIdentifier id) const
1727 /*========================================================*/
1728 {
1729  return (barrel_ec(id)==1);
1730 }
1731 
1732 bool LArOnlineID_Base::isFcalOnline(const HWIdentifier id) const
1733 /*========================================================*/
1734 {/* redefinition (was redundant with isFCALchannel) */
1735  return isFCALchannel(id);
1736 }
1737 bool LArOnlineID_Base::isEmEndcapOnline(const HWIdentifier id) const
1738 /*========================================================*/
1739 {/* redefinition */
1740  return isEMECchannel(id);
1741 }
1742 
1743 
1744 /*
1745  *=============================================================
1746  *=============================================================
1747  * Specific UseCases
1748  *=============================================================
1749  *=============================================================
1750  */
1751 
1752 bool LArOnlineID_Base::isEmEndcapStandardOnline(const HWIdentifier id) const
1753 /*======================================================================*/
1754 {
1755  int ft = feedthrough(id);
1756  return ( barrel_ec(id)==1 &&
1757  (ft==0 ||
1758  ft==1 ||
1759  ft==4 ||
1760  ft==5 ||
1761  ft==7 ||
1762  ft==8 ||
1763  ft==11 ||
1764  ft==12 ||
1765  ft==13 ||
1766  ft==14 ||
1767  ft==17 ||
1768  ft==18 ||
1769  ft==19 ||
1770  ft==20 ||
1771  ft==23 ||
1772  ft==24)
1773  );
1774 }
1775 bool LArOnlineID_Base::isEmEndcapSpecialOnline(const HWIdentifier id) const
1776 /*======================================================================*/
1777 {
1778  int ft = feedthrough(id);
1779  return ( barrel_ec(id)==1 &&
1780  (ft==2 ||
1781  ft==9 ||
1782  ft==15 ||
1783  ft==21 )
1784  );
1785 }
1786 
1787 bool LArOnlineID_Base::isCalibration(const HWIdentifier id) const
1788 /*========================================================*/
1789 {
1790  int bec= barrel_ec(id);
1791  int ft = feedthrough(id);
1792  int sl = slot(id);
1793  return ( (bec==0 && sl==15)
1794  ||
1795  ( bec==1 && sl==15 &&
1796  (ft==0 ||
1797  ft==1 ||
1798  ft==4 ||
1799  ft==5 ||
1800  ft==7 ||
1801  ft==8 ||
1802  ft==11 ||
1803  ft==12 ||
1804  ft==13 ||
1805  ft==14 ||
1806  ft==17 ||
1807  ft==18 ||
1808  ft==19 ||
1809  ft==20 ||
1810  ft==23 ||
1811  ft==24 )
1812  )
1813  ||
1814  ( barrel_ec(id)==1 &&
1815  (sl==3 || sl==4 || sl==12) &&
1816  (ft==3 ||
1817  ft==10 ||
1818  ft==16 ||
1819  ft==22 )
1820  )
1821  ||
1822  ( barrel_ec(id)==1 && sl==16 )
1823  ||
1824  ( barrel_ec(id)==1 && ft==27 && sl==11 )
1825  );
1826 }
1827 
1828 
1829 /*
1830  *================================================================
1831  *================================================================
1832  * The following methods should NOT be used for new applications:
1833  *================================================================
1834  *================================================================
1835  */
1836 
1837 bool LArOnlineID_Base::isHecOnline(const HWIdentifier id) const
1838 /*========================================================*/
1839 {
1840  /* Must be used with CARE !
1841  * This method returns true for all slots/channel in HEC crates,
1842  * thus including the EMEC slot/channels that are present
1843  * in slot 1 and slot 2 of HEC crates !
1844  * To access specifically EMEC in HEC slot/channel, you then
1845  * have to use isEMECinHECchannel()
1846  */
1847  int ft = feedthrough(id);
1848  return (
1849  //(slot(id)!=1 && slot(id)!= 2) &&
1850  barrel_ec(id)==1 &&
1851  (ft==3 ||
1852  ft==10 ||
1853  ft==16 ||
1854  ft==22 )
1855  );
1856 }
1857 
1858 bool LArOnlineID_Base::isHecOnlineFebId(const HWIdentifier febId) const
1859 /*========================================================*/
1860 {
1861  /* Must be used with CARE !
1862  * This method returns true for all slots/channel in HEC crates,
1863  * thus including the EMEC slot/channels that are present
1864  * in slot 1 and slot 2 of HEC crates !
1865  * To access specifically EMEC in HEC slot/channel, you then
1866  * have to use isEMECinHECchannel()
1867  */
1868  int ft = feedthrough(febId);
1869  return ( barrel_ec(febId)==1 &&
1870  (ft==3 ||
1871  ft==10 ||
1872  ft==16 ||
1873  ft==22 )
1874  );
1875 }
1876 
1877 bool LArOnlineID_Base::isEMECinHECchannel(const HWIdentifier id) const
1878 /*=================================================================*/
1879 {/* re-definition with isEMECIW */
1880  return isEMECIW(id);
1881 }
1882 
1883 
1884 
1885 
1886 
1887 
1888 
1889 
1890 
1891 LArOnlineID_Base::size_type LArOnlineID_Base::feedthroughHashMax (void) const
1892  /*=======================================================================*/
1893 {
1894  return m_feedthroughHashMax;
1895 }
1896 LArOnlineID_Base::size_type LArOnlineID_Base::febHashMax (void) const
1897 /*=======================================================================*/
1898 {
1899  return m_febHashMax;
1900 }
1901 LArOnlineID_Base::size_type LArOnlineID_Base::channelHashMax (void) const
1902 /*====================================================================*/
1903 {
1904  return m_channelHashMax;
1905 }
1906 
1907 
1908 
1909 
1910 LArOnlineID_Base::id_iterator LArOnlineID_Base::feb_begin() const
1911 /*====================================================================*/
1912 {
1913  return(m_feb_vec.begin());
1914 }
1915 LArOnlineID_Base::id_iterator LArOnlineID_Base::feb_end() const
1916 /*==================================================================*/
1917 {
1918  return(m_feb_vec.end());
1919 }
1920 LArOnlineID_Base::id_range LArOnlineID_Base::feb_range() const
1921 /*==================================================================*/
1922 {
1923  return {feb_begin(), feb_end()};
1924 }
1925 
1926 LArOnlineID_Base::id_iterator LArOnlineID_Base::channel_begin() const
1927 /*======================================================================*/
1928 {
1929  return(m_channel_vec.begin());
1930 }
1931 LArOnlineID_Base::id_iterator LArOnlineID_Base::channel_end() const
1932 /*======================================================================*/
1933 {
1934  return(m_channel_vec.end());
1935 }
1936 LArOnlineID_Base::id_range LArOnlineID_Base::channel_range() const
1937 /*======================================================================*/
1938 {
1939  return {channel_begin(), channel_end()};
1940 }
1941 
1942 int LArOnlineID_Base::barrel_ec(const HWIdentifier id)const
1943 /*=========================================================*/
1944 {
1945  return (m_bec_impl.unpack(id));
1946 }
1947 
1948 int LArOnlineID_Base::feedthrough(const HWIdentifier id)const
1949 /*===========================================================*/
1950 {
1951  return (m_feedthrough_impl.unpack(id));
1952 }
1953 
1954 int LArOnlineID_Base::pos_neg(const HWIdentifier id)const
1955 /*===========================================================*/
1956 {
1957  return (m_side_impl.unpack(id));
1958 }
1959 
1960 
1961 int LArOnlineID_Base::slot(const HWIdentifier id)const
1962 /*=====================================================*/
1963 {
1964  return (m_slot_impl.unpack(id));
1965 }
1966 
1967 int LArOnlineID_Base::channel(const HWIdentifier id)const
1968 /*=====================================================*/
1969 {
1970  return (m_channel_in_slot_impl.unpack(id));
1971 }
1972 
1973 int LArOnlineID_Base::is_slar(const HWIdentifier id)const
1974 /*=====================================================*/
1975 {
1976  return (m_slar_impl.unpack(id));
1977 }
1978 
1979 
1980 /*========================================*/
1981 int LArOnlineID_Base::init_calib_hashes(void)
1982 /*========================================*/
1983 {
1984  MsgStream log(m_msgSvc, "LArOnlineID_Base" );
1985  unsigned int nids=0;
1986  std::set<HWIdentifier> ids;
1987  for (unsigned int i = 0; i < m_full_calib_laronline_range.size(); ++i) {
1988  const Range& range = m_full_calib_laronline_range[i];
1989  Range::const_identifier_factory first = range.factory_begin();
1990  Range::const_identifier_factory last = range.factory_end();
1991  for (; first != last; ++first) {
1992  const ExpandedIdentifier& exp_id = (*first);
1993  HWIdentifier id = this->calib_channel_Id(exp_id[m_bec_index],
1994  exp_id[m_side_index],
1995  exp_id[m_feedthrough_index],
1996  exp_id[m_slot_index],
1997  exp_id[m_channel_in_slot_index]);
1998  if(!(ids.insert(id)).second) {
1999  if(m_msgSvc) {
2000  log << MSG::WARNING << " LArOnlineID_Base::init_calib_Hashes "
2001  << " Error: duplicated id for channel id. nids= " << nids
2002  << " compact Id " << std::string(*first) << " " << show_to_string(id) << endmsg;
2003  } else {
2004  std::cout << " LArOnlineID_Base::init_calib_Hashes "
2005  << " Error: duplicated id for channel id. nids= " << nids
2006  << " compact Id " ;
2007  (*first).show();
2008  std::cout << " " << show_to_string(id) << std::endl;
2009  }
2010  }
2011  nids++;
2012  }
2013  }
2014  unsigned int nidtb=0;
2015  std::set<HWIdentifier>::const_iterator first = ids.begin();
2016  std::set<HWIdentifier>::const_iterator last = ids.end();
2017  for (;first != last && nidtb < nids; ++first) {
2018  m_calib_channel_vec.push_back(*first);
2019  nidtb++;
2020  }
2021  m_calibChannelHashMax = m_calib_channel_vec.size();
2022 
2023  /* FEB hash */
2024  /*==========*/
2025  nids = 0;
2026  ids.clear();
2027  for (unsigned int i = 0; i < m_full_calib_module_range.size(); ++i) {
2028  const Range& range = m_full_calib_module_range[i];
2029  Range::const_identifier_factory first = range.factory_begin();
2030  Range::const_identifier_factory last = range.factory_end();
2031  for (; first != last; ++first) {
2032  const ExpandedIdentifier& exp_id = (*first);
2033  HWIdentifier febId = calib_module_Id( exp_id[m_bec_index],
2034  exp_id[m_side_index],
2035  exp_id[m_feedthrough_index],
2036  exp_id[m_slot_index] );
2037  if(!(ids.insert(febId)).second){
2038  if(m_msgSvc) {
2039  log << MSG::WARNING << " LArOnlineID_Base::init_calibhashes "
2040  << " Warning: duplicated id for feb id. nids= " << nids
2041  << " compact Id " << std::string(*first) << " " << show_to_string(febId) << endmsg;
2042  } else {
2043  std::cout << " LArOnlineID_Base::init_calibhashes "
2044  << " Error: duplicated id for feb id. nids= " << nids
2045  << " compact Id " ;
2046  (*first).show();
2047  std::cout << " " << show_to_string(febId) << std::endl;
2048  std::cout << std::endl;
2049 
2050  }
2051  }
2052  nids++;
2053  }
2054  }
2055  nidtb=0;
2056  first = ids.begin();
2057  last = ids.end();
2058  for (;first != last && nidtb < nids; ++first)
2059  {
2060  m_calib_module_vec.push_back(*first);
2061  nidtb++;
2062  }
2063  m_calibModuleHashMax = m_calib_module_vec.size();
2064  return (0);
2065 }
2066 
2067 
2068 
2069 
2070 
2071 
2072 
LArOnlineID_Base::m_side_index
size_type m_side_index
Definition: LArOnlineID_Base.h:482
IdDictDictionary::find_region
IdDictRegion * find_region(const std::string &region_name) const
Definition: IdDictMgr.cxx:366
LArOnlineID_Base::feedthroughHashMax
size_type feedthroughHashMax(void) const
Define feedthrough hash tables max size.
Definition: LArOnlineID_Base.cxx:1891
LArOnlineID_Base::febContext
IdContext febContext(void) const
Define context for feb.
Definition: LArOnlineID_Base.cxx:276
IdDictDictionary::build_multirange
MultiRange build_multirange() const
Get MultiRange for full dictionary.
Definition: IdDictMgr.cxx:1048
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1636
PlotCalibFromCool.ft
ft
Definition: PlotCalibFromCool.py:329
AtlasDetectorID::initialize_from_dictionary
virtual int initialize_from_dictionary(const IdDictMgr &dict_mgr) override
Initialization from the identifier dictionary.
Definition: AtlasDetectorID.cxx:320
get_generator_info.result
result
Definition: get_generator_info.py:21
LArOnlineID_Base::cryostatEndContext
IdContext cryostatEndContext(void) const
Define context for cryostat (obsolete)
Definition: LArOnlineID_Base.cxx:245
LArOnlineID_Base::feedthrough_range
id_range feedthrough_range() const
Definition: LArOnlineID_Base.cxx:1447
IdDictGroup
Definition: IdDictDefs.h:355
LArOnlineID_Base::febHashMax
size_type febHashMax(void) const
define feb hash tables max size
Definition: LArOnlineID_Base.cxx:1896
LArOnlineID_Base::m_slar_impl
IdDictFieldImplementation m_slar_impl
Definition: LArOnlineID_Base.h:519
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
LArOnlineID_Base::HashCalcFeb::m_hash
IdentifierHash m_hash
Definition: LArOnlineID_Base.h:534
LArOnlineID_Base::feedthrough_name
std::string feedthrough_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
Definition: LArOnlineID_Base.cxx:72
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
LArOnlineID_Base::size_type
Identifier::size_type size_type
Definition: LArOnlineID_Base.h:108
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
IdDictFieldImplementation::show_to_string
std::string show_to_string(void) const
Definition: IdDictFieldImplementation.cxx:57
LArOnlineID_Base::HashCalcFeb::m_slot_values
std::vector< int > m_slot_values
Definition: LArOnlineID_Base.h:535
LArOnlineID_Base::m_feedthrough_impl
IdDictFieldImplementation m_feedthrough_impl
Definition: LArOnlineID_Base.h:514
Range::field::both_bounded
@ both_bounded
Definition: DetectorDescription/Identifier/Identifier/Range.h:48
LArOnlineID_Base::init_calib_hashes
int init_calib_hashes(void)
Definition: LArOnlineID_Base.cxx:1981
LArOnlineID_Base.h
LArOnlineID_Base::isHecOnlineFebId
bool isHecOnlineFebId(const HWIdentifier febId) const
Definition: LArOnlineID_Base.cxx:1858
LArOnlineID_Base::feb_Id_checks
void feb_Id_checks(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Definition: LArOnlineID_Base.cxx:752
LArOnlID_Exception.h
LArOnlineID_Base::m_channel_vec
std::vector< HWIdentifier > m_channel_vec
Definition: LArOnlineID_Base.h:499
ExpandedIdentifier::add
void add(element_type value)
skel.it
it
Definition: skel.GENtoEVGEN.py:423
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1961
ExpandedIdentifier
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:108
IdDictFieldImplementation::pack
void pack(int value, Identifier &id) const
Definition: IdDictFieldImplementation.h:174
LArOnlineID_Base::m_slot_impl
IdDictFieldImplementation m_slot_impl
Definition: LArOnlineID_Base.h:515
LArOnlineID_Base::HashCalc
Define the Hash identifier for channels and febs.
Definition: LArOnlineID_Base.h:525
LArOnlineID_Base::m_laronline_impl
IdDictFieldImplementation m_laronline_impl
Definition: LArOnlineID_Base.h:511
AtlasDetectorID::m_msgSvc
IMessageSvc * m_msgSvc
pointer to the message service
Definition: AtlasDetectorID.h:368
LArOnlineID_Base::feb_begin
id_iterator feb_begin() const
Returns an iterator pointing to a feb identifier collection.
Definition: LArOnlineID_Base.cxx:1910
LArOnlineID_Base::feedthrough_begin
id_iterator feedthrough_begin() const
Return an iterator pointing to Feedthrough identifiers collection.
Definition: LArOnlineID_Base.cxx:1435
LArOnlineID_Base::feedthroughContext
IdContext feedthroughContext(void) const
Define context for feedthroughs.
Definition: LArOnlineID_Base.cxx:255
LArOnlineID_Base::isFcalOnline
bool isFcalOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1732
LArOnlineID_Base::calib_module_Id
HWIdentifier calib_module_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Build calibration module identifier from fields.
Definition: LArOnlineID_Base.h:573
ReadOfcFromCool.field
field
Definition: ReadOfcFromCool.py:48
LArOnlineID_Base::m_laronline_index
size_type m_laronline_index
Definition: LArOnlineID_Base.h:480
LArOnlineID_Base::m_dict
const IdDictDictionary * m_dict
Definition: LArOnlineID_Base.h:488
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:562
AtlasDetectorID::lar_field_value
int lar_field_value() const
Definition: AtlasDetectorID.h:614
LArOnlineID_Base::m_side_impl
IdDictFieldImplementation m_side_impl
Definition: LArOnlineID_Base.h:513
HWIdentifier
Definition: HWIdentifier.h:13
LArOnlineID_Base::barrel_ec
int barrel_ec(const HWIdentifier id) const
Return the position barrel or endcap of a hardware cell identifier: barrel_ec = [0,...
Definition: LArOnlineID_Base.cxx:1942
IdDictFieldImplementation::unpack
int unpack(Identifier id) const
Identifier manipulation methods.
Definition: IdDictFieldImplementation.h:148
python.DomainsRegistry.reg
reg
globals -----------------------------------------------------------------—
Definition: DomainsRegistry.py:343
LArOnlineID_Base::channel_end
id_iterator channel_end() const
Definition: LArOnlineID_Base.cxx:1931
LArOnlineID_Base::id_iterator
std::vector< HWIdentifier >::const_iterator id_iterator
Type for iterators over identifiers.
Definition: LArOnlineID_Base.h:111
IdDictDictionary::find_field
IdDictField * find_field(const std::string &name) const
Definition: IdDictMgr.cxx:309
CalibDbCompareRT.region_id
region_id
Definition: CalibDbCompareRT.py:68
IdDictRegion
Definition: IdDictDefs.h:448
LArOnlineID_Base::m_feedthroughHashMax
size_type m_feedthroughHashMax
Definition: LArOnlineID_Base.h:493
AtlasDetectorID::dictionaryVersion
virtual std::string dictionaryVersion(void) const override
Definition: AtlasDetectorID.cxx:347
LArOnlineID_Base::initialize_from_dictionary
virtual int initialize_from_dictionary(const IdDictMgr &dict_mgr)
initialization from the identifier dictionary
Definition: LArOnlineID_Base.cxx:314
LArOnlineID_Base::m_calib_channel_vec
std::vector< HWIdentifier > m_calib_channel_vec
Definition: LArOnlineID_Base.h:507
LArOnlineID_Base::m_bec_slot_impl
IdDictFieldImplementation m_bec_slot_impl
Definition: LArOnlineID_Base.h:518
LArOnlineID_Base::m_calibModuleHashMax
size_type m_calibModuleHashMax
Definition: LArOnlineID_Base.h:504
IdDictDefs.h
AtlasDetectorID::size_type
Identifier::size_type size_type
Definition: AtlasDetectorID.h:384
LArOnlineID_Base::m_feb_hash_calcs
std::vector< HashCalcFeb > m_feb_hash_calcs
Definition: LArOnlineID_Base.h:537
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LArOnlineID_Base::isFCALchannel
bool isFCALchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1657
LArOnlineID_Base::is_slar
int is_slar(const HWIdentifier id) const
Return whether the channel is in slar or not is_ slar = [0,1] in all FEB.
Definition: LArOnlineID_Base.cxx:1973
LArOnlineID_Base::m_channel_in_slot_impl
IdDictFieldImplementation m_channel_in_slot_impl
Definition: LArOnlineID_Base.h:516
IdDictMgr
Definition: IdDictDefs.h:32
LArOnlineID_Base::id_range
boost::iterator_range< id_iterator > id_range
Type for range over identifiers.
Definition: LArOnlineID_Base.h:113
LArOnlineID_Base::m_full_feedthrough_range
MultiRange m_full_feedthrough_range
Definition: LArOnlineID_Base.h:490
IdDictDictionary::find_group
IdDictGroup * find_group(const std::string &group_name) const
Definition: IdDictMgr.cxx:383
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1967
IdDictMgr::find_dictionary
IdDictDictionary * find_dictionary(const std::string &name) const
Access dictionary by name.
Definition: IdDictMgr.cxx:161
LArOnlineID_Base::feb_range
id_range feb_range() const
Definition: LArOnlineID_Base.cxx:1920
LArOnlineID_Base::m_febHashMax
size_type m_febHashMax
Definition: LArOnlineID_Base.h:494
LArOnlineID_Base::feedthrough_Hash
IdentifierHash feedthrough_Hash(HWIdentifier feedthroughId) const
Create hash id from feedthrough identifiers.
Definition: LArOnlineID_Base.cxx:1416
LArOnlineID_Base::channel_range
id_range channel_range() const
Definition: LArOnlineID_Base.cxx:1936
LArOnlineID_Base::m_slar_index
size_type m_slar_index
Definition: LArOnlineID_Base.h:486
lumiFormat.i
int i
Definition: lumiFormat.py:92
IdDictFieldImplementation::set_bits
void set_bits(size_type bits, size_type bits_offset)
Definition: IdDictFieldImplementation.h:279
LArOnlineID_Base::channelInSlotMax
int channelInSlotMax(const HWIdentifier Id) const
Return the Maximum channel number of a given feb slot.
Definition: LArOnlineID_Base.cxx:286
LArOnlineID_Base::m_calibChannelHashMax
size_type m_calibChannelHashMax
Definition: LArOnlineID_Base.h:505
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
LArOnlID_Exception
Exception class for LAr online Identifiers.
Definition: LArOnlID_Exception.h:16
LArOnlineID_Base::isEMECPS
bool isEMECPS(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1675
LArOnlineID_Base::get_expanded_id
int get_expanded_id(const HWIdentifier &id, ExpandedIdentifier &exp_id, const IdContext *context) const
create expanded HWIdentifier from HWIdentifier (return == 0 for OK)
Definition: LArOnlineID_Base.cxx:788
IdDictFieldImplementation::bits_offset
size_type bits_offset() const
Definition: IdDictFieldImplementation.h:209
IdDictDictionary::m_regions
std::vector< IdDictRegion * > m_regions
Definition: IdDictDefs.h:302
LArOnlineID_Base::channel_Id
HWIdentifier channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create channel identifier from fields
Definition: LArOnlineID_Base.cxx:1569
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
LArOnlineID_Base::pos_neg
int pos_neg(const HWIdentifier id) const
Return the side of a hardware cell identifier pos_neg = [0,1] positive-side or negative-side Barrel...
Definition: LArOnlineID_Base.cxx:1954
LArOnlineID_Base::isEmEndcapStandardOnline
bool isEmEndcapStandardOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1752
mc.group_name
group_name
Definition: mc.PhPy8EG_A14NNPDF23_NNLOPS_example.py:33
LArOnlineID_Base::initLevelsFromDict
int initLevelsFromDict(const std::string &group_name)
Definition: LArOnlineID_Base.cxx:841
LArOnlineID_Base::m_channelHashMax
size_type m_channelHashMax
Definition: LArOnlineID_Base.h:495
LArOnlineID_Base::m_full_calib_laronline_range
MultiRange m_full_calib_laronline_range
Definition: LArOnlineID_Base.h:502
LArOnlineID_Base::isEndcapOnline
bool isEndcapOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1726
Range::const_identifier_factory
Definition: DetectorDescription/Identifier/Identifier/Range.h:191
CaloCondBlobAlgs_fillNoiseFromASCII.channelId
channelId
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:122
LArOnlineID_Base::isValidId
bool isValidId(const HWIdentifier id) const
Returns false if the identifier is not a LAr-online id or any of the sub-fields is out of range.
Definition: LArOnlineID_Base.cxx:1333
AtlasDetectorID::m_quiet
bool m_quiet
If true, suppress DEBUG/INFO messages.
Definition: AtlasDetectorID.h:371
LArOnlineID_Base::m_lar_index
size_type m_lar_index
Definition: LArOnlineID_Base.h:479
Range::field::get_minimum
element_type get_minimum() const
Definition: DetectorDescription/Identifier/Identifier/Range.h:524
LArOnlineID_Base::isHecOnline
bool isHecOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1837
LArOnlineID_Base::init_hashes
int init_hashes(void)
Definition: LArOnlineID_Base.cxx:1124
LArOnlineID_Base::feb_Id
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
Definition: LArOnlineID_Base.cxx:1483
LArOnlineID_Base::m_feedthrough_index
size_type m_feedthrough_index
Definition: LArOnlineID_Base.h:483
min
#define min(a, b)
Definition: cfImp.cxx:40
LArOnlineID_Base::m_bec_index
size_type m_bec_index
Definition: LArOnlineID_Base.h:481
LArOnlineID_Base::channel_Hash_binary_search
IdentifierHash channel_Hash_binary_search(HWIdentifier channelId) const
Definition: LArOnlineID_Base.h:560
AtlasDetectorID::register_dict_tag
int register_dict_tag(const IdDictMgr &dict_mgr, const std::string &dict_name)
Register the file and tag names for a particular IdDict dictionary.
Definition: AtlasDetectorID.cxx:266
Range::field::has_maximum
bool has_maximum() const
Definition: DetectorDescription/Identifier/src/Range.cxx:398
LArOnlineID_Base::feb_end
id_iterator feb_end() const
Definition: LArOnlineID_Base.cxx:1915
IdDictDictionary::get_label_value
int get_label_value(const std::string &field, const std::string &label, int &value) const
Definition: IdDictMgr.cxx:338
LArOnlineID_Base::m_feedthrough_vec
std::vector< HWIdentifier > m_feedthrough_vec
Definition: LArOnlineID_Base.h:497
LArOnlineID_Base::m_lar_impl
IdDictFieldImplementation m_lar_impl
Field Implementation.
Definition: LArOnlineID_Base.h:510
LArOnlineID_Base::feb_Hash_binary_search
IdentifierHash feb_Hash_binary_search(HWIdentifier channelId) const
Definition: LArOnlineID_Base.h:549
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:191
python.subdetectors.mmg.ids
ids
Definition: mmg.py:8
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
IdentifierHash.h
LArOnlineID_Base::HashCalc::m_hash
IdentifierHash m_hash
Definition: LArOnlineID_Base.h:528
LArOnlineID_Base::channelHashMax
size_type channelHashMax(void) const
Define channel hash tables max size.
Definition: LArOnlineID_Base.cxx:1901
LArOnlineID_Base::isCalibration
bool isCalibration(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1787
AtlasDetectorID::setDictVersion
virtual void setDictVersion(const IdDictMgr &dict_mgr, const std::string &name) override
Definition: AtlasDetectorID.cxx:759
Range
A Range describes the possible ranges for the field values of an ExpandedIdentifier.
Definition: DetectorDescription/Identifier/Identifier/Range.h:27
LArOnlineID_Base::isEmEndcapSpecialOnline
bool isEmEndcapSpecialOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1775
LArOnlineID_Base::isEMBchannel
bool isEMBchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1652
LArOnlineID_Base::m_chan_hash_calcs
std::vector< HashCalc > m_chan_hash_calcs
Definition: LArOnlineID_Base.h:538
IdDictDictionary
Definition: IdDictDefs.h:97
LArOnlineID_Base::m_bec_impl
IdDictFieldImplementation m_bec_impl
Definition: LArOnlineID_Base.h:512
Range::field::get_maximum
element_type get_maximum() const
Definition: DetectorDescription/Identifier/Identifier/Range.h:531
LArOnlineID_Base::channel_Id_checks
void channel_Id_checks(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
Definition: LArOnlineID_Base.cxx:681
LArOnlineID_Base::get_expanded_calib_id
int get_expanded_calib_id(const HWIdentifier &id, ExpandedIdentifier &exp_id, const IdContext *context) const
Definition: LArOnlineID_Base.cxx:815
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1948
LArOnlineID_Base::feedthrough_Id_checks
void feedthrough_Id_checks(int barrel_ec, int pos_neg, int feedthrough) const
Definition: LArOnlineID_Base.cxx:769
AtlasDetectorID::reinitialize
bool reinitialize(const IdDictMgr &dict_mgr)
Test whether an idhelper should be reinitialized based on the change of tags.
Definition: AtlasDetectorID.cxx:284
LArOnlineID_Base::m_full_feb_range
MultiRange m_full_feb_range
Definition: LArOnlineID_Base.h:491
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
IdDictDictionary::m_name
std::string m_name
Definition: IdDictDefs.h:283
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:574
LArOnlineID_Base::m_feb_vec
std::vector< HWIdentifier > m_feb_vec
Definition: LArOnlineID_Base.h:498
LArOnlineID_Base::channelContext
IdContext channelContext(void) const
Define context for channel.
Definition: LArOnlineID_Base.cxx:266
LArOnlineID_Base::feedthrough_end
id_iterator feedthrough_end() const
Definition: LArOnlineID_Base.cxx:1441
LArOnlineID_Base::~LArOnlineID_Base
~LArOnlineID_Base(void)
Default destructor.
LArOnlineID_Base::m_full_laronline_range
MultiRange m_full_laronline_range
Definition: LArOnlineID_Base.h:489
MultiRange::size
size_type size() const
Definition: DetectorDescription/Identifier/src/Range.cxx:2488
DeMoScan.first
bool first
Definition: DeMoScan.py:534
LArOnlineID_Base::isEMBPS
bool isEMBPS(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1665
DEBUG
#define DEBUG
Definition: page_access.h:11
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
LArOnlineID_Base::isPS
bool isPS(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1681
LArOnlineID_Base::m_full_calib_module_range
MultiRange m_full_calib_module_range
Definition: LArOnlineID_Base.h:503
LArOnlineID_Base::LArOnlineID_Base
LArOnlineID_Base(void)
Default constructor.
Definition: LArOnlineID_Base.cxx:46
Range::field::get_mode
mode get_mode() const
Query the values.
Definition: DetectorDescription/Identifier/Identifier/Range.h:517
LArOnlineID_Base::m_slot_index
size_type m_slot_index
Definition: LArOnlineID_Base.h:484
LArOnlineID_Base::isEmEndcapOnline
bool isEmEndcapOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1737
LArOnlineID_Base::isNotWarmCableConnected
bool isNotWarmCableConnected(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1688
Range::field
This is the individual specification for the range of one ExpandedIdentifier field.
Definition: DetectorDescription/Identifier/Identifier/Range.h:37
IdDictField
Definition: IdDictDefs.h:318
MultiRange::cardinality
size_type cardinality() const
Computes a possible cardinality from all ranges.
Definition: DetectorDescription/Identifier/src/Range.cxx:2503
LArOnlineID_Base::m_channel_in_slot_index
size_type m_channel_in_slot_index
Definition: LArOnlineID_Base.h:485
IdentifierHash
Definition: IdentifierHash.h:38
Range::field::get_values
const element_vector & get_values() const
Definition: DetectorDescription/Identifier/Identifier/Range.h:538
LArOnlineID_Base::channel_name
std::string channel_name(const HWIdentifier id) const
Return a string corresponding to a feedthrough name given an identifier.
Definition: LArOnlineID_Base.cxx:218
LArOnlineID_Base::m_calib_module_vec
std::vector< HWIdentifier > m_calib_module_vec
Definition: LArOnlineID_Base.h:506
LArOnlineID_Base::HashCalcFeb
Definition: LArOnlineID_Base.h:531
AtlasDetectorID::do_checks
virtual bool do_checks(void) const override
Checks are performed by default in debug compilation and NOT in optimized compilation.
Definition: AtlasDetectorID.cxx:728
LArOnlineID_Base::m_laronlineRegion_index
size_type m_laronlineRegion_index
Definition: LArOnlineID_Base.h:478
IdContext
class IdContext
Definition: IdContext.h:34
LArOnlineID_Base::calib_channel_Id
HWIdentifier calib_channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create calibration channel identifiers from fields
Definition: LArOnlineID_Base.h:622
IdDictRegion::m_implementation
std::vector< IdDictFieldImplementation > m_implementation
Definition: IdDictDefs.h:474
LArOnlineID_Base::isEMECinHECchannel
bool isEMECinHECchannel(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1877
LArOnlineID_Base::m_bec_ft_impl
IdDictFieldImplementation m_bec_ft_impl
Definition: LArOnlineID_Base.h:517
LArOnlineID_Base::channel_begin
id_iterator channel_begin() const
Returns an iterator pointing to a channel identifier collection.
Definition: LArOnlineID_Base.cxx:1926
LArOnlineID_Base::feb_Hash
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
Definition: LArOnlineID_Base.cxx:1516
LArOnlineID_Base::isEmBarrelOnline
bool isEmBarrelOnline(const HWIdentifier id) const
Definition: LArOnlineID_Base.cxx:1720
match
bool match(std::string s1, std::string s2)
match the individual directories of two strings
Definition: hcg.cxx:356
LArOnlineID_Base::feedthrough_Id
HWIdentifier feedthrough_Id(int barrel_ec, int pos_neg, int feedthrough) const
Create a feedthrough identifier from fields.
Definition: LArOnlineID_Base.cxx:1404
LArOnlineID_Base::m_this_is_slar
bool m_this_is_slar
Definition: LArOnlineID_Base.h:443
IdDictFieldImplementation::size_type
Identifier::size_type size_type
Definition: IdDictFieldImplementation.h:62
Range::field::enumerated
@ enumerated
Definition: DetectorDescription/Identifier/Identifier/Range.h:49
IdDictFieldImplementation::bits
size_type bits() const
Definition: IdDictFieldImplementation.h:203
Generated on Sun Jun 30 2024 21:20:31 for ATLAS Offline Software by   doxygen 1.8.18