ATLAS Offline Software
Classes | Public Member Functions | Private Member Functions | Private Attributes | List of all members
IdDictGroup Class Reference

#include <IdDictGroup.h>

Collaboration diagram for IdDictGroup:

Classes

struct  IdDictRegionTreeNode
 Tree structure for fast unpacking. More...
 

Public Member Functions

 IdDictGroup ()
 
 IdDictGroup (const std::string &name)
 
 ~IdDictGroup ()
 
const std::string & name ()
 
const std::vector< IdDictDictEntry * > & entries ()
 
const std::vector< IdDictRegion * > & regions ()
 
MultiRange build_multirange () const
 Get MultiRange for this group. More...
 
void add_dictentry (IdDictDictEntry *entry)
 
void resolve_references (const IdDictMgr &idd, IdDictDictionary &dictionary, size_t &index)
 
void generate_implementation (const IdDictMgr &idd, IdDictDictionary &dictionary, const std::string &tag="")
 
void reset_implementation ()
 
bool verify () const
 
void sort ()
 Sort: More...
 
void clear ()
 
int unpack (const Identifier &id, const ExpandedIdentifier &prefix, size_t index2, ExpandedIdentifier &unpackedId, std::vector< const IdDictFieldImplementation * > *impls=nullptr) const
 Unpack the value_type id to an expanded Identifier, considering the provided prefix (result will include the prefix) and up to index2 - (index1 is assumed to be 0, i.e. More...
 
void build_region_tree ()
 Take the list of regions and build a tree structure for fast unpacking. More...
 
void dump () const
 Dump regions and tree for this group. More...
 
void dump_regions () const
 Dump the list of regions for this group. More...
 
void dump_tree () const
 Dump the tree structure built from the regions for fast unpacking. More...
 

Private Member Functions

void add_tree_field (const IdDictRegion &re, unsigned ifield, unsigned inode)
 Recursively add new nodes to the tree structure. More...
 

Private Attributes

std::string m_name
 
std::vector< IdDictDictEntry * > m_entries
 
std::vector< IdDictRegion * > m_regions
 
bool m_generated_implementation
 
std::vector< IdDictRegionTreeNodem_region_tree
 The list of region nodes. More...
 

Detailed Description

Definition at line 25 of file IdDictGroup.h.

Constructor & Destructor Documentation

◆ IdDictGroup() [1/2]

IdDictGroup::IdDictGroup ( )

Definition at line 22 of file IdDictGroup.cxx.

23  :
25 }

◆ IdDictGroup() [2/2]

IdDictGroup::IdDictGroup ( const std::string &  name)

Definition at line 27 of file IdDictGroup.cxx.

28  :
29  m_name(name),
31 }

◆ ~IdDictGroup()

IdDictGroup::~IdDictGroup ( )

Definition at line 33 of file IdDictGroup.cxx.

33  {
34 }

Member Function Documentation

◆ add_dictentry()

void IdDictGroup::add_dictentry ( IdDictDictEntry entry)

Definition at line 74 of file IdDictGroup.cxx.

74  {
75  m_entries.push_back(region);
76 }

◆ add_tree_field()

void IdDictGroup::add_tree_field ( const IdDictRegion re,
unsigned  ifield,
unsigned  inode 
)
private

Recursively add new nodes to the tree structure.

Parameters
reThe region we're processing.
ifieldThe index of the next field to add.
inodeThe index of the node to which to add.

Definition at line 351 of file IdDictGroup.cxx.

354 {
355  using element_type = IdentifierField::element_type;
356  using element_vector = IdentifierField::element_vector;
357  using size_type = IdentifierField::size_type;
358  using index_vector = IdentifierField::index_vector;
359 
360  // Helper to retrieve the indices that may actually be used by a field.
361  // n is the node we're looking for. We use the ored_field referenced there
362  // to know what can actually be stored in the field.
363  // impl gives the field that we're trying to match.
364  // So we return the indices for the ored_field corresponding
365  // to valid values for impl.
366  auto get_field_indices = [] (const IdDictRegionTreeNode& n,
368  {
369  index_vector indices;
370  const Range::field& ored_field = n.m_impl.ored_field();
371  if (impl.field().isEnumerated()) {
372  const element_vector& vals = impl.field().get_values();
373  indices.reserve (vals.size());
374  for (element_type v : vals) {
375  indices.push_back (ored_field.get_value_index (v));
376  }
377  }
378  else if (impl.field().isBounded()) {
379  auto [minval, maxval] = impl.field().get_minmax();
380  size_type minidx = ored_field.get_value_index (minval);
381  size_type maxidx = ored_field.get_value_index (maxval);
382  indices.resize (maxidx - minidx + 1);
383  std::iota (indices.begin(), indices.end(), minidx);
384  }
385  else {
386  std::abort();
387  }
388  return indices;
389  };
390 
391  // This will be the field we're matching.
392  const IdDictFieldImplementation& prev_impl = re.implementation(ifield-1);
393 
394  {
395  // Get the children for the current node.
396  IdDictRegionTreeNode& n = m_region_tree.at(inode);
397  auto& children = std::get<0> (n.m_children);
398 
399  // If we're looking at the last field, fill in the node pointersj
400  // with END; then we're done.
401  if (ifield == re.m_implementation.size()) {
402  index_vector indices = get_field_indices (n, prev_impl);
403  for (size_t idx : indices) {
405  }
406  return;
407  }
408 
409  // Verify consistency of the field with what's stored in the node.
410  if (prev_impl.bits() != n.m_impl.bits() ||
411  prev_impl.bits_offset() != n.m_impl.bits_offset() ||
412  prev_impl.ored_field() != n.m_impl.ored_field())
413  {
414  dump();
415  std::abort();
416  }
417 
418  // If this implementation has a field that is not equivalent with what
419  // we saved in the node, then save it in m_other_impls.
420  if (n.m_impl.field() != prev_impl.field()) {
421  if (!n.m_other_impls) {
422  n.m_other_impls = std::make_unique<std::vector<const IdDictFieldImplementation*> > (1, &prev_impl);
423  }
424  else {
425  if (std::ranges::find_if (*n.m_other_impls,
426  [&](const IdDictFieldImplementation* a)
427  { return a->field() == prev_impl.field(); })
428  == n.m_other_impls->end())
429  {
430  n.m_other_impls->push_back (&prev_impl);
431  }
432  }
433  }
434  }
435 
436  // Indices we want to store.
437  index_vector indices = get_field_indices (m_region_tree[inode], prev_impl);
438  const IdDictFieldImplementation& impl = re.implementation(ifield);
439 
440  // Children for the node.
441  auto children = [&]() -> std::vector<unsigned>& { return std::get<0> (m_region_tree[inode].m_children); };
442 
443  unsigned new_node = 0;
444  std::vector<unsigned> nodes_seen;
445 
446  // Loop over indices that we want to add.
447  for (size_t idx : indices) {
448 
449  // If we've already recorded this index as END, fail.
450  unsigned next_node = children().at (idx);
451  if (next_node == IdDictRegionTreeNode::END) {
452  dump();
453  std::abort();
454  }
455 
456  if (next_node != 0) {
457  // There is an existing node. Process it recursively; but we only
458  // need to this once for each unique node.
459  if (std::ranges::find (nodes_seen, next_node) == nodes_seen.end()) {
460  add_tree_field (re, ifield+1, next_node);
461  nodes_seen.push_back (next_node);
462  }
463  }
464  else {
465  // No node had been recorded for this index.
466  if (new_node != 0) {
467  // We've already made a new node. So just record it.
468  children().at(idx) = new_node;
469  }
470  else {
471  // Need to make a new node.
472  new_node = m_region_tree.size();
473  if (new_node == IdDictRegionTreeNode::END) {
474  std::abort();
475  }
476  // Careful --- this will invalidate references to nodes.
477  m_region_tree.emplace_back (impl);
478  children().at(idx) = new_node;
479  add_tree_field (re, ifield+1, new_node);
480  }
481  }
482  }
483 }

◆ build_multirange()

MultiRange IdDictGroup::build_multirange ( ) const

Get MultiRange for this group.

Definition at line 51 of file IdDictGroup.cxx.

51  {
53 
55 
56  for (it = m_regions.begin(); it != m_regions.end(); ++it) {
57  const IdDictRegion& region = *(*it);
58 
59  // skip regions created from parents
60  if ("dummy" == region.name()) continue;
61 
62  // skip empty regions - may arise from alternate_regions
63  // where a tag selects an empty region
64  if (region.m_is_empty) continue;
65 
66  Range r = region.build_range();
67  result.add(std::move(r));
68  }
69 
70  return(result);
71 }

◆ build_region_tree()

void IdDictGroup::build_region_tree ( )

Take the list of regions and build a tree structure for fast unpacking.

Definition at line 490 of file IdDictGroup.cxx.

491 {
492  // Loop through regions.
493  [[maybe_unused]] unsigned iregion = 0; // Region index, really only for debugging.
494  for (const IdDictRegion* re : m_regions) {
495  // Skip dummy/empty regions.
496  if (re->fieldSize() == 0 || re->name() == "dummy") {
497  ++iregion;
498  continue;
499  }
500 
501  // Add an initial node if we haven't done so already.
502  if (m_region_tree.empty()) {
503  m_region_tree.emplace_back (re->implementation(0));
504  }
505 
506  // Add nodes for the current region, starting at field 1.
507  add_tree_field (*re, 1, 0);
508 
509  ++iregion;
510  }
511 
512  // Compress child vectors if possible.
513  for (IdDictRegionTreeNode& n : m_region_tree) {
514  n.optimize();
515  }
516 }

◆ clear()

void IdDictGroup::clear ( )

Definition at line 187 of file IdDictGroup.cxx.

187  {
189 
190  for (it = m_entries.begin(); it != m_entries.end(); ++it) {
191  IdDictDictEntry* region = *it;
192  region->clear();
193  delete region;
194  }
195 
196  m_entries.clear();
197 }

◆ dump()

void IdDictGroup::dump ( ) const

Dump regions and tree for this group.

Definition at line 522 of file IdDictGroup.cxx.

523 {
524  std::cout << "===== IdDictGroup " << m_name << "\n";
525  dump_regions();
526  dump_tree();
527 }

◆ dump_regions()

void IdDictGroup::dump_regions ( ) const

Dump the list of regions for this group.

Definition at line 533 of file IdDictGroup.cxx.

534 {
535  std::cout << "Regions:\n";
536  for (unsigned iregion = 0; const IdDictRegion* re : m_regions) {
537  std::cout << " " << iregion++ << " " << re->name() << " " << re->m_group << " " << re->m_tag << "\n";
538  for (bool first = true; const IdDictFieldImplementation& impl : re->m_implementation) {
539  std::cout << (first ? " " : "; ") << impl.field() << " " << impl.ored_field() << " " << impl.bits() << "/" << impl.bits_offset();
540  first = false;
541  }
542  std::cout << "\n";
543  }
544 }

◆ dump_tree()

void IdDictGroup::dump_tree ( ) const

Dump the tree structure built from the regions for fast unpacking.

Definition at line 550 of file IdDictGroup.cxx.

551 {
552  size_t sz = 0;
553  for (const auto& n : m_region_tree) {
554  if (n.m_children.index() == 0) {
555  sz += std::get<0>(n.m_children).size();
556  }
557  }
558  std::cout << "Region Tree totsize " << sz << "\n";
559  for (unsigned inode = 0; const auto& n : m_region_tree) {
560  std::cout << " " << inode++ << " " << n.m_impl.field()
561  << " " << n.m_impl.ored_field() << " -- ";
562 
563  if (n.m_children.index() == 0) {
564  const auto& children = std::get<0> (n.m_children);
565  unsigned istart = 0;
566  unsigned ichild = 0;
567  bool first = true;
568  for (size_t i = 0; uint64_t c : children) {
569  if (c != ichild) {
570  if (ichild != 0) {
571  if (!first) std::cout << " ";
572  first = false;
573  if (istart != i-1) {
574  std::cout << istart << "-";
575  }
576  std::cout << i-1 << ":";
577  if (ichild == IdDictRegionTreeNode::END) {
578  std::cout << "END";
579  }
580  else {
581  std::cout << ichild;
582  }
583  }
584  ichild = c;
585  istart = i;
586  }
587  ++i;
588  }
589  if (ichild != 0) {
590  if (!first) std::cout << " ";
591  if (istart != children.size()-1) {
592  std::cout << istart << "-";
593  }
594  std::cout << children.size()-1 << ":";
595  if (ichild == IdDictRegionTreeNode::END) {
596  std::cout << "END";
597  }
598  else {
599  std::cout << ichild;
600  }
601  }
602  }
603  else {
604  const auto& children = std::get<1> (n.m_children);
605  if (children.first == 1) {
606  std::cout << "0:";
607  }
608  else {
609  std::cout << "0-" << children.first-1 << ":";
610  }
611  if (children.second == IdDictRegionTreeNode::END) {
612  std::cout << "END";
613  }
614  else {
615  std::cout << children.second;
616  }
617  }
618  if (n.m_other_impls) {
619  std::cout << " [";
620  bool first = true;
621  for (const IdDictFieldImplementation* ii : *n.m_other_impls) {
622  if (!first)
623  std::cout << "; ";
624  else
625  first = false;
626  std::cout << ii->field();
627  }
628  std::cout << "]";
629  }
630  std::cout << "\n";
631  }
632  std::cout.flush();
633 }

◆ entries()

const std::vector< IdDictDictEntry * > & IdDictGroup::entries ( )

Definition at line 41 of file IdDictGroup.cxx.

41  {
42  return(m_entries);
43 }

◆ generate_implementation()

void IdDictGroup::generate_implementation ( const IdDictMgr idd,
IdDictDictionary dictionary,
const std::string &  tag = "" 
)

Definition at line 92 of file IdDictGroup.cxx.

94  {
95  if (Debugger::debug()) {
96  std::cout << "IdDictGroup::generate_implementation>" << std::endl;
97  }
98 
100  // Loop over entries and fill regions vec with selected region
101  // (AltRegions have a selection)
103  for (it = m_entries.begin(); it != m_entries.end(); ++it) {
104  (*it)->generate_implementation(idd, dictionary, tag);
105  // Get region and save in m_regions
106  IdDictRegion* region = dynamic_cast<IdDictRegion*> (*it);
107  if (region) {
108  m_regions.push_back(region);
109  } else {
110  IdDictAltRegions* altregions = dynamic_cast<IdDictAltRegions*> (*it);
111  if (altregions) {
112  m_regions.push_back(altregions->m_selected_region);
113  }
114  }
115  }
116 
117  if (m_regions.size() != m_entries.size()) {
118  std::cout << "IdDictGroup::generate_implementation - mismatch of sizes: regions/entries "
119  << m_regions.size() << " " << m_entries.size()
120  << std::endl;
121  }
122 
124  }
125 }

◆ name()

const std::string & IdDictGroup::name ( )

Definition at line 36 of file IdDictGroup.cxx.

36  {
37  return(m_name);
38 }

◆ regions()

const std::vector< IdDictRegion * > & IdDictGroup::regions ( )

Definition at line 46 of file IdDictGroup.cxx.

46  {
47  return(m_regions);
48 }

◆ reset_implementation()

void IdDictGroup::reset_implementation ( )

Definition at line 128 of file IdDictGroup.cxx.

128  {
130  m_regions.clear();
132  for (it = m_entries.begin(); it != m_entries.end(); ++it) {
133  (*it)->reset_implementation();
134  }
136  }
137 }

◆ resolve_references()

void IdDictGroup::resolve_references ( const IdDictMgr idd,
IdDictDictionary dictionary,
size_t &  index 
)

Definition at line 79 of file IdDictGroup.cxx.

81  {
83  for (it = m_entries.begin(); it != m_entries.end(); ++it) {
84  (*it)->set_index(index);
85  index++;
86 
87  (*it)->resolve_references(idd, dictionary);
88  }
89 }

◆ sort()

void IdDictGroup::sort ( )

Sort:

Loop over regions and sort according to their first identifier

Definition at line 154 of file IdDictGroup.cxx.

154  {
155  std::map< ExpandedIdentifier, IdDictDictEntry* > regions;
156 
158 
159  for (it = m_regions.begin(); it != m_regions.end(); ++it) {
160  const IdDictRegion& region = *(*it);
161  Range range = region.build_range();
162  RangeIterator itr(range);
163  auto first = itr.begin();
164  auto last = itr.end();
165  if (first != last) {
166  regions[*first] = *it;
167  } else {
168  std::cout << "IdDictDictionary::sort - WARNING empty region cannot sort "
169  << std::endl;
170  }
171  }
172  if (regions.size() == m_regions.size()) {
173  // Reorder the regions
175  std::vector<IdDictRegion*>::size_type vecIt = 0;
176  for (; mapIt != regions.end(); ++mapIt, ++vecIt) {
177  m_entries[vecIt] = (*mapIt).second;
178  }
179  } else {
180  std::cout << "IdDictGroup::sort - WARNING region map size is NOT the same as the vector size. Map size "
181  << regions.size() << " vector size " << m_regions.size()
182  << std::endl;
183  }
184 }

◆ unpack()

int IdDictGroup::unpack ( const Identifier id,
const ExpandedIdentifier prefix,
size_t  index2,
ExpandedIdentifier unpackedId,
std::vector< const IdDictFieldImplementation * > *  impls = nullptr 
) const

Unpack the value_type id to an expanded Identifier, considering the provided prefix (result will include the prefix) and up to index2 - (index1 is assumed to be 0, i.e.

part of prefix). If impls is provided, then fill it with pointers to the implementations for each unpacked field.

Returns 0 on success, nonzero on error.

Definition at line 242 of file IdDictGroup.cxx.

247 {
248  using element_type = ExpandedIdentifier::element_type;
249  using size_type = IdentifierField::size_type;
250 
251  // Give up if the tree representation hasn't been built.
252  if (m_region_tree.empty()) std::abort();
253 
254  // Clear output.
255  unpackedId.clear();
256  if (impls) {
257  impls->clear();
258  impls->reserve (12);
259  }
260 
261  // Start at the first node, and assume success.
262  unsigned inode = 0;
263  int ret = 0;
264 
265  // Loop over fields.
266  for (size_t index = 0; index <= index2; ++index) {
267 
268  // Fetch the node.
269  const IdDictRegionTreeNode& n = m_region_tree.at(inode);
270 
271  // Find the index+value for this field. If we're looking at a prefix,
272  // get it from there; otherwise, unpack from the input identifier.
273  element_type val;
274  size_type validx;
275  if (index < prefix.fields()) {
276  val = prefix[index];
277  validx = n.m_impl.ored_field().get_value_index (val);
278  }
279  else {
280  validx = n.m_impl.unpackToIndex (id);
281  try {
282  val = n.m_impl.ored_field().get_value_at (validx);
283  } catch (const std::out_of_range&) {
284  ret = 1;
285  break;
286  }
287  }
288 
289  // Find the next node.
290  if (n.m_children.index() == 0) {
291  // Children stored as a vector.
292  const auto& children = std::get<0> (n.m_children);
293  if (validx < children.size()) {
294  inode = children[validx];
295  }
296  else {
297  inode = 0;
298  }
299  }
300  else {
301  // Children stored as a size,node-number field.
302  const auto& children = std::get<1> (n.m_children);
303  if (validx < children.first) {
304  inode = children.second;
305  }
306  else {
307  inode = 0;
308  }
309  }
310 
311  // Give up if no regions match the identifier.
312  if (!inode) {
313  break;
314  }
315 
316  // Record this field in the output.
317  unpackedId.add (val);
318 
319  // Also return the implementation, if requested.
320  // But we need to be sure that we return an implementation that actually
321  // matches the field value.
322  if (impls) {
323  if (n.m_impl.field().match (val)) {
324  impls->push_back (&n.m_impl);
325  }
326  else if (n.m_other_impls) {
327  for (const IdDictFieldImplementation* ii : *n.m_other_impls) {
328  if (ii->field().match (val)) {
329  impls->push_back (ii);
330  break;
331  }
332  }
333  }
334  if (unpackedId.fields() != impls->size()) std::abort();
335  }
336 
337  // Stop if we've reached the end of the identifier.
338  if (inode == IdDictRegionTreeNode::END) break;
339  }
340 
341  return ret;
342 }

◆ verify()

bool IdDictGroup::verify ( ) const

Definition at line 140 of file IdDictGroup.cxx.

140  {
141  // Should check that all regions have the same number of levels,
142  // which is part of the definition of a group
143  return(true);
144 }

Member Data Documentation

◆ m_entries

std::vector<IdDictDictEntry*> IdDictGroup::m_entries
private

Definition at line 100 of file IdDictGroup.h.

◆ m_generated_implementation

bool IdDictGroup::m_generated_implementation
private

Definition at line 102 of file IdDictGroup.h.

◆ m_name

std::string IdDictGroup::m_name
private

Definition at line 99 of file IdDictGroup.h.

◆ m_region_tree

std::vector<IdDictRegionTreeNode> IdDictGroup::m_region_tree
private

The list of region nodes.

Definition at line 197 of file IdDictGroup.h.

◆ m_regions

std::vector<IdDictRegion*> IdDictGroup::m_regions
private

Definition at line 101 of file IdDictGroup.h.


The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
beamspotman.r
def r
Definition: beamspotman.py:672
IdDictGroup::m_name
std::string m_name
Definition: IdDictGroup.h:99
IdDictRegion::build_range
virtual Range build_range() const override
Definition: IdDictRegion.cxx:153
fitman.sz
sz
Definition: fitman.py:527
get_generator_info.result
result
Definition: get_generator_info.py:21
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
IdentifierField::element_type
ExpandedIdentifier::element_type element_type
Definition: IdentifierField.h:85
index
Definition: index.py:1
IdDictAltRegions::m_selected_region
IdDictRegion * m_selected_region
Definition: IdDictAltRegions.h:40
IdDictGroup::m_regions
std::vector< IdDictRegion * > m_regions
Definition: IdDictGroup.h:101
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
ExpandedIdentifier::add
void add(element_type value)
Append a value into a new field.
skel.it
it
Definition: skel.GENtoEVGEN.py:407
RangeIterator
This iterator is able to generate all possible identifiers, from a fully bounded Range.
Definition: RangeIterator.h:19
ExpandedIdentifier::fields
size_type fields() const
IdDictDictEntry::clear
virtual void clear()=0
IdDictDictEntry
Definition: IdDictDictEntry.h:13
IdDictAltRegions
Definition: IdDictAltRegions.h:20
IdDictGroup::dump_tree
void dump_tree() const
Dump the tree structure built from the regions for fast unpacking.
Definition: IdDictGroup.cxx:550
IdDictRegion
Definition: IdDictRegion.h:20
IdDictGroup::m_entries
std::vector< IdDictDictEntry * > m_entries
Definition: IdDictGroup.h:100
IdentifierField::match
bool match(element_type value) const
The basic match operation Given a value, test to see if it satisfies the constraints for this field.
Definition: IdentifierField.cxx:71
IdDictFieldImplementation::field
const Range::field & field() const
Definition: IdDictFieldImplementation.h:191
IdentifierField::get_value_index
size_type get_value_index(element_type value) const
Definition: IdentifierField.cxx:49
lumiFormat.i
int i
Definition: lumiFormat.py:85
beamspotman.n
n
Definition: beamspotman.py:727
IdDictRegion::m_is_empty
bool m_is_empty
Definition: IdDictRegion.h:87
IdDictFieldImplementation::bits_offset
size_type bits_offset() const
Definition: IdDictFieldImplementation.h:208
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
IdDictDictionary::regions_it
regions_type::iterator regions_it
Definition: IdDictDictionary.h:293
IdDictFieldImplementation::ored_field
const Range::field & ored_field() const
Definition: IdDictFieldImplementation.h:196
Debugger::debug
static bool debug()
Definition: Debugger.h:18
IdDictGroup::regions
const std::vector< IdDictRegion * > & regions()
Definition: IdDictGroup.cxx:46
IdentifierField::element_vector
std::vector< element_type > element_vector
Definition: IdentifierField.h:87
IdDictDictionary::regions_const_it
regions_type::const_iterator regions_const_it
Definition: IdDictDictionary.h:294
IdDictGroup::m_region_tree
std::vector< IdDictRegionTreeNode > m_region_tree
The list of region nodes.
Definition: IdDictGroup.h:197
IdDictGroup::IdDictRegionTreeNode::END
static constexpr unsigned END
Special value used to indicate that we've reached the end.
Definition: IdDictGroup.h:194
MultiRange
A MultiRange combines several Ranges.
Definition: MultiRange.h:17
master.dictionary
dictionary
Definition: master.py:47
Trk::index2
@ index2
Definition: BoundarySurfaceFace.h:49
IdentifierField::size_type
ExpandedIdentifier::size_type size_type
Definition: IdentifierField.h:86
IdDictDictionary::entries_it
entries_type::iterator entries_it
Definition: IdDictDictionary.h:289
IdentifierField::index_vector
std::vector< size_type > index_vector
Definition: IdentifierField.h:88
ReadLUTFromCool.maxidx
maxidx
Definition: ReadLUTFromCool.py:116
Range
A Range describes the possible ranges for the field values of an ExpandedIdentifier.
Definition: DetectorDescription/Identifier/Identifier/Range.h:29
python.PyAthena.v
v
Definition: PyAthena.py:154
impl
Definition: CaloGPUClusterAndCellDataMonitorOptions.h:46
IdDictGroup::name
const std::string & name()
Definition: IdDictGroup.cxx:36
DeMoScan.index
string index
Definition: DeMoScan.py:362
a
TList * a
Definition: liststreamerinfos.cxx:10
IdDictGroup::m_generated_implementation
bool m_generated_implementation
Definition: IdDictGroup.h:102
IdDictGroup::add_tree_field
void add_tree_field(const IdDictRegion &re, unsigned ifield, unsigned inode)
Recursively add new nodes to the tree structure.
Definition: IdDictGroup.cxx:351
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
DeMoScan.first
bool first
Definition: DeMoScan.py:534
re
const boost::regex re(r_e)
IdentifierField
This is the individual specification for the range of one ExpandedIdentifier IdentifierField.
Definition: IdentifierField.h:83
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ExpandedIdentifier::clear
void clear()
Erase all fields.
python.DecayParser.children
children
Definition: DecayParser.py:31
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
IdDictFieldImplementation
IdDictFieldImplementation is used to capture the specification of a single field of an Identifier.
Definition: IdDictFieldImplementation.h:58
ExpandedIdentifier::element_type
int element_type
Definition: DetectorDescription/Identifier/Identifier/ExpandedIdentifier.h:106
IdDictGroup::dump_regions
void dump_regions() const
Dump the list of regions for this group.
Definition: IdDictGroup.cxx:533
python.compressB64.c
def c
Definition: compressB64.py:93
IdDictRegion::name
const std::string & name() const
Definition: IdDictRegion.h:112
inode
Definition: listroot.cxx:155
IdDictFieldImplementation::bits
size_type bits() const
Definition: IdDictFieldImplementation.h:202
IdDictGroup::dump
void dump() const
Dump regions and tree for this group.
Definition: IdDictGroup.cxx:522
PlotCalibFromCool.vals
vals
Definition: PlotCalibFromCool.py:474