ATLAS Offline Software
LArOnline_SuperCellID.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 #include "GaudiKernel/MsgStream.h"
7 #include "IdDict/IdDictDefs.h"
10 #include <cmath>
11 #include <iostream>
12 #include <set>
13 #include <sstream>
14 #include <string>
15 
16 /* See comments in Base class */
17 
19  LArOnlineID_Base("LArOnline_SuperCellID", "LArOnline_SuperCell", true)
20 {
21 }
22 
23 
25 
26 /* =================================================================== */
28 /* =================================================================== */
29 {
30  MsgStream log(m_msgSvc, "LArOnline_SuperCellID" );
31  std::string strg = "initialize_from_dictionary";
32  if(m_msgSvc) {
33  log << MSG::INFO << strg << endmsg;
34  }
35  else {
36  std::cout << strg << std::endl;
37  }
38 
39  // Check whether this helper should be reinitialized
40  if (!reinitialize(dict_mgr)) {
41  if(m_msgSvc) log << MSG::DEBUG << "Request to reinitialize not satisfied - tags have not changed" << endmsg;
42  return (0);
43  }
44  else {
45  if(m_msgSvc) log << MSG::DEBUG << "(Re)initialize" << endmsg;
46  }
47 
48  // init base object
49  if(AtlasDetectorID::initialize_from_dictionary(dict_mgr)) return (1);
50  m_dict = dict_mgr.find_dictionary ("LArCalorimeter");
51  if(!m_dict) {
52 
53  strg = " initialize_from_dictionary - cannot access LArCalorimeter dictionary ";
54  if(m_msgSvc) {
55  log << MSG::ERROR << strg << endmsg;
56  }
57  else {
58  std::cout << "LArOnline_SuperCellID::" << strg << std::endl;
59  }
60  return 1;
61  }
62 
63  // Register version of the dictionary used
64  if (register_dict_tag(dict_mgr, "LArCalorimeter")) return(1);
65 
66  // initialize dictionary version
67  AtlasDetectorID::setDictVersion(dict_mgr, "LArCalorimeter");
68 
69  /* Initialize the field indices */
71 
72  if(m_msgSvc) {
73  log << MSG::INFO << "Finished initLevelsFromDict" << endmsg;
74  } else {
75  std::cout << "Finished initLevelsFromDict" << std::endl;
76  }
77 
78 
79  /* Find value for the field LAr Calorimeter */
80  const IdDictDictionary* atlasDict = dict_mgr.find_dictionary ("ATLAS");
81  int larField = -1;
82  if (atlasDict->get_label_value("subdet", "LArCalorimeter", larField)) {
83  std::stringstream strm;
84  strm << atlasDict->name();
85  strg= " Could not get value for label 'LArCalorimeter' of field 'subdet' in dictionary "+strm.str();
86  if(m_msgSvc) {
87  log << MSG::ERROR << strg << endmsg;
88  }
89  else {
90  std::cout << "LArOnline_SuperCellID:" << strg << std::endl;
91  }
92  return (1);
93  }
94 
95  /* Find value for the field LArOnline */
96  int larOnlineField = -4;
97  if (m_dict->get_label_value("part", "LArOnline", larOnlineField)) {
98  std::stringstream strm;
99  strm << m_dict->name();
100  strg = "Could not get value for label 'LArOnline' of field 'part' in dictionary "+strm.str();
101  if(m_msgSvc) {
102  log << MSG::ERROR << strg << endmsg;
103  }
104  else {
105  std::cout << strg << std::endl;
106  }
107  return (1);
108  }
109 
110  /* Find value for the field calibLArOnline */
111  int larOnlineCalibField = -5;
112  if (m_dict->get_label_value("part", "LArOnlineCalib", larOnlineCalibField)) {
113  std::stringstream strm;
114  strm << m_dict->name();
115  strg = "Could not get value for label 'LArOnlineCalib' of field 'part' in dictionary "+strm.str();
116  if(m_msgSvc) {
117  log << MSG::ERROR << strg << endmsg;
118  }
119  else {
120  std::cout << strg << std::endl;
121  }
122  return (1);
123  }
124 
125  /* Set up id for Region and range prefix */
127  region_id.add(larField);
128  region_id.add(larOnlineField);
129  Range prefix;
130 
131  /*Full range for all channels*/
135 
136  std::string strg0= " initialize_from_dictionary :";
137  std::string strg1= " feedthrough range -> " + (std::string)m_full_feedthrough_range;
138  std::string strg2= " feedthrough slot range -> " + (std::string)m_full_feb_range;
139  std::string strg3= " channel range -> " + (std::string)m_full_laronline_range;
140  if(m_msgSvc) {
141  log << MSG::DEBUG << strg0 << endmsg;
142  log << MSG::DEBUG << strg1 << endmsg;
143  log << MSG::DEBUG << strg2 << endmsg;
144  log << MSG::DEBUG << strg3 << endmsg;
145  }
146  else {
147  std::cout << strg0 << std::endl;
148  std::cout << strg1 << std::endl;
149  std::cout << strg2 << std::endl;
150  std::cout << strg3 << std::endl;
151  }
152 
153  /* Setup the hash tables */
154  std::stringstream strm;
155  strm << dictionaryVersion();
156  strg="[initialize_from_dictionary] version= " + strm.str();
157  if(m_msgSvc) {
158  log << MSG::DEBUG << strg << endmsg;
159  }
160  else {
161  std::cout << "LArOnline_SuperCellID: " << strg << std::endl;
162  }
163  if( dictionaryVersion() == "fullAtlas" ) {
164  if(LArOnlineID_Base::init_hashes()) return (1);
165  }
166 
167  // Setup for hash calculation for channels (febs is further below)
168 
169  // Febs have a uniform number of channels
170  // The lookup table only needs to contain the
171  // hash offset for each feb
172 
173  // The implementation requires:
174 
175  // 1) a lookup table for each feb containing hash offset
176  // 2) a decoder to access the "index" corresponding to the
177  // bec/side/ft/slot fields. These fields use x bits, so the
178  // vector has a length of 2**x.
179 
180  /* Create decoder for fields bec to slot */
182  m_bec_impl.bits() +
183  m_side_impl.bits() +
185  m_slot_impl.bits();
187  m_bec_slot_impl.set_bits(bits, bits_offset);
188  int size = (1 << bits);
189 
190  // Set up vector as lookup table for hash calculation.
191  m_chan_hash_calcs.resize(size);
192 
193  std::stringstream strm1;
194  std::stringstream strm2;
195  for (unsigned int i = 0; i < m_febHashMax; ++i) {
196 
197  HWIdentifier febId = feb_Id(i) ;
198 
199  HashCalc hc;
200 
201  HWIdentifier min = channel_Id ( febId, 0);
202 
204  hc.m_hash = min_hash;
206 
207  if (m_bec_slot_impl.unpack(min) >= size) {
208  strm << size;
209  strm1 << show_to_string(min);
210  strm2 << m_bec_slot_impl.unpack(min);
211  strg = "Min > "+strm.str();
212  strg1= " "+strm1.str();
213  strg2= " "+strm2.str();
214  if(m_msgSvc) {
215  log << MSG::DEBUG << strg << endmsg;
216  log << MSG::DEBUG << strg1 << endmsg;
217  log << MSG::DEBUG << strg2 << endmsg;
218  }
219  else {
220  std::cout << strg << std::endl;
221  std::cout << strg1 << std::endl;
222  std::cout << strg2 << std::endl;
223  }
224  }
225  }
226 
227  // Check channel hash calculation
228  for (unsigned int i = 0; i < m_channelHashMax; ++i) {
229  HWIdentifier id = channel_Id(i);
230  if (channel_Hash(id) != i) {
231  strm << show_to_string(id);
232  strm1 << channel_Hash(id);
233  strm2 << i;
234  strg = " ***** Error channel ranges, id, hash, i = "+strm.str();
235  strg1= " , "+strm1.str();
236  strg2= " , "+strm2.str();
237  if(m_msgSvc) {
238  log << MSG::ERROR << strg << endmsg;
239  log << MSG::ERROR << strg1 << endmsg;
240  log << MSG::ERROR << strg2 << endmsg;
241  }
242  else {
243  std::cout << strg << std::endl;
244  std::cout << strg1 << std::endl;
245  std::cout << strg2 << std::endl;
246  }
247  }
248  }
249 
250 
251 
252  // Setup for hash calculation for febs
253 
254  // We calculate the feb hash by saving the hash of each
255  // feedthrough in a HashCalc object and then adding on the slot
256  // number for a particular feb
257 
258  // The implementation requires:
259 
260  // 1) a lookup table for each ft containing hash offset
261  // 2) a decoder to access the "index" corresponding to the
262  // bec/side/ft fields. These fields use x bits, so the
263  // vector has a length of 2**x.
264 
265  /* Create decoder for fields bec to ft */
266  bits = m_bec_impl.bits() +
267  m_side_impl.bits() +
269  bits_offset = m_bec_impl.bits_offset();
270  m_bec_ft_impl.set_bits(bits, bits_offset);
271  size = (1 << bits);
272 
273  // Set up vector as lookup table for hash calculation.
274  m_feb_hash_calcs.resize(size);
275 
276  // Get context for conversion to expanded ids
277  IdContext ftContext = feedthroughContext();
278  ExpandedIdentifier ftExpId;
279 
280  for (unsigned int i = 0; i < m_feedthroughHashMax; ++i) {
281 
283 
284  HashCalcFeb hc;
285 
286  // Set the hash id for each feedthrough, and then check if one
287  // needs to also save the slot values
289  hc.m_hash = min_hash;
290 
291  // For each feedthrough we save the possible slot values for
292  // the hash calculation.
293  if (get_expanded_id(min, ftExpId, &ftContext)) {
294  if(m_msgSvc) {
295  log << MSG::WARNING << " ***** Warning cannot get ft expanded id for " << show_to_string(min) << endmsg;
296  } else {
297  std::cout << " ***** Warning cannot get ft expanded id for " << show_to_string(min) << std::endl;
298  }
299  }
300 
301  // Now and save values if we either have an
302  // enumerated set of slots, or more than one FT
303  for (unsigned int i = 0; i < m_full_feb_range.size(); ++i) {
304  if (m_full_feb_range[i].match(ftExpId)) {
305  const Range::field& slotField = m_full_feb_range[i][m_slot_index];
306  if (slotField.isBounded() || slotField.isEnumerated()) {
307  // save values
308  unsigned int nvalues = slotField.get_indices();
309  hc.m_slot_values.reserve(hc.m_slot_values.size() + nvalues);
310  for (unsigned int j = 0; j < nvalues; ++j) {
311  hc.m_slot_values.push_back(slotField.get_value_at(j));
312  }
313  }
314  }
315  }
316 
317  // Set hash calculator
319 
320 
321  if (m_bec_ft_impl.unpack(min) >= size) {
322  std::stringstream strm, strm1, strm2, strm3;
323  strm << size;
324  strm1 << show_to_string(min);
325  strm2 << m_bec_ft_impl.unpack(min);
326  strm3 << min_hash;
327  strg = "Min > " + strm.str() + " " + strm1.str() + " " + strm2.str() + " " + strm3.str();
328  if(m_msgSvc) {
329  log << MSG::DEBUG << strg << endmsg;
330  }
331  else {
332  std::cout << strg << std::endl;
333  }
334  }
335  }
336 
337  // Check feb hash calculation
338  for (unsigned int i = 0; i < m_febHashMax; ++i) {
339  HWIdentifier id = feb_Id(i);
340  if (feb_Hash(id) != i) {
341  std::stringstream strm, strm1, strm2;
342  strm << show_to_string(id);
343  strm1 << feb_Hash(id);
344  strm2 << i;
345  strg = " ***** Error feb ranges, id, hash, i = " +
346  strm.str() + " , " + strm1.str() + " , "+strm2.str();
347  if(m_msgSvc) {
348  log << MSG::ERROR << strg << endmsg;
349  }
350  else {
351  std::cout << strg << std::endl;
352  }
353  }
354  }
355 
356  return 0;
357 }
358 
360 /*========================================================*/
361 {
362  int ft = feedthrough(id);
363  return ( barrel_ec(id)==1
364  &&
365  ( ft==3 || ft==10 || ft==16 || ft==22 )
366  );
367 }
368 
369 
370 //pos_neg : 0 = negative eta side (C side)
371 // 1 = positive eta side (A side)
372 
374  /*======================================================*/
375  //
376  int bec= barrel_ec(id);
377  int ft = feedthrough(id);
378  int sl = slot(id);
379  int ch = channel(id);
380  bool sideCondition= (pos_neg(id)==1 && ch>95) || (pos_neg(id)==0 && ch<64);
381 
382  return (bec==1 && sl==2 && sideCondition && (ft==2 || ft==9 ||
383  ft==15 || ft==21));
384 }
385 
387  /*======================================================*/
388  //
389  int bec= barrel_ec(id);
390  int ft = feedthrough(id);
391  int sl = slot(id);
392  int ch = channel(id);
393  bool sideCondition=(pos_neg(id)==1 && ch<=95) || (pos_neg(id)==0 && ch>=64);
394 
395  return (bec == 1 &&
396  ((sl == 1 &&
397  (ft == 0 || ft == 1 || ft == 2 || ft == 4 || ft == 5 || ft == 7 || ft == 8 || ft == 9 || ft == 11 || ft == 12 || ft == 13 || ft == 14 || ft == 15 ||
398  ft == 17 || ft == 18 || ft == 19 || ft == 20 || ft == 21 || ft == 23 || ft == 24)) ||
399  (sl==2 && sideCondition && (ft==2 ||ft==9 || ft==15 || ft==21))));
400 }
401 
403  int bec= barrel_ec(id);
404  int ft = feedthrough(id);
405  return (bec == 1 && !( ft==3 || ft==10 || ft==16 || ft==22 || ft==6));
406 }
LArOnline_SuperCellID::LArOnline_SuperCellID
LArOnline_SuperCellID()
Default constructor.
Definition: LArOnline_SuperCellID.cxx:18
IdDictDictionary::build_multirange
MultiRange build_multirange() const
Get MultiRange for full dictionary.
Definition: IdDictDictionary.cxx:291
LArOnline_SuperCellID::isEMECOW
bool isEMECOW(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:386
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:1632
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:250
LArOnlineID_Base::HashCalcFeb::m_hash
IdentifierHash m_hash
Definition: LArOnlineID_Base.h:536
ParticleGun_SamplingFraction.bec
int bec
Definition: ParticleGun_SamplingFraction.py:89
LArOnlineID_Base::HashCalcFeb::m_slot_values
std::vector< int > m_slot_values
Definition: LArOnlineID_Base.h:537
LArOnline_SuperCellID::isEMECIW
bool isEMECIW(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:373
LArOnlineID_Base::m_feedthrough_impl
IdDictFieldImplementation m_feedthrough_impl
Definition: LArOnlineID_Base.h:516
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
LArOnlID_Exception.h
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:1957
ExpandedIdentifier
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:102
LArOnlineID_Base::m_slot_impl
IdDictFieldImplementation m_slot_impl
Definition: LArOnlineID_Base.h:517
LArOnlineID_Base::HashCalc
Define the Hash identifier for channels and febs.
Definition: LArOnlineID_Base.h:527
AtlasDetectorID::m_msgSvc
IMessageSvc * m_msgSvc
pointer to the message service
Definition: AtlasDetectorID.h:369
IdDictDictionary::name
const std::string & name() const
Dictionary name.
Definition: IdDictDictionary.h:323
LArOnlineID_Base::m_dict
const IdDictDictionary * m_dict
Definition: LArOnlineID_Base.h:490
LArOnlineID_Base::feedthroughContext
IdContext feedthroughContext() const
Define context for feedthroughs.
Definition: LArOnlineID_Base.cxx:258
LArOnlineID_Base::m_side_impl
IdDictFieldImplementation m_side_impl
Definition: LArOnlineID_Base.h:515
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:1938
IdDictFieldImplementation::unpack
int unpack(Identifier id) const
Identifier manipulation methods.
Definition: IdDictFieldImplementation.h:147
CalibDbCompareRT.region_id
region_id
Definition: CalibDbCompareRT.py:67
LArOnlineID_Base::m_feedthroughHashMax
size_type m_feedthroughHashMax
Definition: LArOnlineID_Base.h:495
AtlasDetectorID::dictionaryVersion
virtual std::string dictionaryVersion(void) const override
Definition: AtlasDetectorID.cxx:276
LArOnlineID_Base::m_bec_slot_impl
IdDictFieldImplementation m_bec_slot_impl
Definition: LArOnlineID_Base.h:520
IdDictDefs.h
LArOnlineID_Base::m_feb_hash_calcs
std::vector< HashCalcFeb > m_feb_hash_calcs
Definition: LArOnlineID_Base.h:539
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
IdDictMgr
Definition: IdDictMgr.h:14
LArOnlineID_Base::m_full_feedthrough_range
MultiRange m_full_feedthrough_range
Definition: LArOnlineID_Base.h:492
LArOnline_SuperCellID::isHECchannel
bool isHECchannel(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:359
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:1963
IdDictMgr::find_dictionary
IdDictDictionary * find_dictionary(const std::string &name) const
Access dictionary by name.
Definition: IdDictMgr.cxx:115
LArOnlineID_Base::m_febHashMax
size_type m_febHashMax
Definition: LArOnlineID_Base.h:496
lumiFormat.i
int i
Definition: lumiFormat.py:85
IdDictFieldImplementation::set_bits
void set_bits(size_type bits, size_type bits_offset)
Definition: IdDictFieldImplementation.h:278
LArOnline_SuperCellID::isEMECchannel
bool isEMECchannel(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:402
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
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:790
IdDictFieldImplementation::bits_offset
size_type bits_offset() const
Definition: IdDictFieldImplementation.h:208
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:1565
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:1950
LArOnlineID_Base::initLevelsFromDict
int initLevelsFromDict(const std::string &group_name)
Definition: LArOnlineID_Base.cxx:843
AtlasDetectorID::group
const std::string & group() const
Group name for this helper.
Definition: AtlasDetectorID.cxx:27
LArOnlineID_Base::m_channelHashMax
size_type m_channelHashMax
Definition: LArOnlineID_Base.h:497
IdentifierField::isEnumerated
bool isEnumerated() const
Definition: IdentifierField.h:185
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:1479
LArOnlineID_Base::channel_Hash_binary_search
IdentifierHash channel_Hash_binary_search(HWIdentifier channelId) const
Definition: LArOnlineID_Base.h:562
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:196
IdDictDictionary::get_label_value
int get_label_value(const std::string &field, const std::string &label, int &value) const
Definition: IdDictDictionary.cxx:64
LArOnline_SuperCellID::initialize_from_dictionary
int initialize_from_dictionary(const IdDictMgr &dict_mgr) override final
initialization from the identifier dictionary
Definition: LArOnline_SuperCellID.cxx:27
LArOnlineID_Base
Helper for the Liquid Argon Calorimeter cell identifiers.
Definition: LArOnlineID_Base.h:105
LArOnlineID_Base::feb_Hash_binary_search
IdentifierHash feb_Hash_binary_search(HWIdentifier channelId) const
Definition: LArOnlineID_Base.h:551
IdentifierHash.h
LArOnlineID_Base::HashCalc::m_hash
IdentifierHash m_hash
Definition: LArOnlineID_Base.h:530
AtlasDetectorID::setDictVersion
virtual void setDictVersion(const IdDictMgr &dict_mgr, const std::string &name) override
Definition: AtlasDetectorID.cxx:494
Range
A Range describes the possible ranges for the field values of an ExpandedIdentifier.
Definition: DetectorDescription/Identifier/Identifier/Range.h:29
LArOnlineID_Base::m_chan_hash_calcs
std::vector< HashCalc > m_chan_hash_calcs
Definition: LArOnlineID_Base.h:540
IdDictDictionary
Definition: IdDictDictionary.h:30
LArOnlineID_Base::m_bec_impl
IdDictFieldImplementation m_bec_impl
Definition: LArOnlineID_Base.h:514
IdentifierField::isBounded
bool isBounded() const
Definition: IdentifierField.h:184
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:1944
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
LArOnlineID_Base::m_full_feb_range
MultiRange m_full_feb_range
Definition: LArOnlineID_Base.h:493
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
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
LArOnlineID_Base::m_full_laronline_range
MultiRange m_full_laronline_range
Definition: LArOnlineID_Base.h:491
MultiRange::size
size_type size() const
Definition: MultiRange.cxx:70
DEBUG
#define DEBUG
Definition: page_access.h:11
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
IdentifierField::get_value_at
element_type get_value_at(size_type index) const
Definition: IdentifierField.h:209
LArOnline_SuperCellID.h
LArOnline_SuperCellID::~LArOnline_SuperCellID
~LArOnline_SuperCellID()
Default destructor.
LArOnlineID_Base::m_slot_index
size_type m_slot_index
Definition: LArOnlineID_Base.h:486
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
LArOnlineID_Base::HashCalcFeb
Definition: LArOnlineID_Base.h:533
IdContext
This class saves the "context" of an expanded identifier (ExpandedIdentifier) for compact or hash ver...
Definition: IdContext.h:26
LArOnlineID_Base::m_bec_ft_impl
IdDictFieldImplementation m_bec_ft_impl
Definition: LArOnlineID_Base.h:519
IdentifierField::get_indices
size_type get_indices() const
Definition: IdentifierField.h:140
LArOnlineID_Base::feb_Hash
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
Definition: LArOnlineID_Base.cxx:1512
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:1400
IdDictFieldImplementation::size_type
Identifier::size_type size_type
Definition: IdDictFieldImplementation.h:62
LArOnlineID_Base::init_hashes
int init_hashes()
Definition: LArOnlineID_Base.cxx:1126
IdDictFieldImplementation::bits
size_type bits() const
Definition: IdDictFieldImplementation.h:202