ATLAS Offline Software
Public Types | Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
IdentifierField Class Reference

This is the individual specification for the range of one ExpandedIdentifier IdentifierField. More...

#include <IdentifierField.h>

Collaboration diagram for IdentifierField:

Public Types

enum  continuation_mode {
  none, has_next, has_previous, has_both,
  has_wrap_around
}
 
using element_type = ExpandedIdentifier::element_type
 
using size_type = ExpandedIdentifier::size_type
 
using element_vector = std::vector< element_type >
 
using index_vector = std::vector< size_type >
 
using BoundedRange = std::pair< element_type, element_type >
 

Public Member Functions

 IdentifierField ()=default
 Create a wild-card value. More...
 
 IdentifierField (element_type value)
 Create a unique value (understood as : low bound = high bound = value) More...
 
 IdentifierField (element_type minimum, element_type maximum)
 Create a full range specification (with explicit min and max) More...
 
 IdentifierField (const element_vector &values)
 Create with enumerated values. More...
 
bool wrap_around () const
 
element_type get_minimum () const
 Query the values. More...
 
std::pair< element_type, element_typeget_minmax () const
 
element_type get_maximum () const
 
const element_vectorget_values () const
 
bool get_previous (element_type current, element_type &previous) const
 Returns false if previous/next is at end of range, or not possible. More...
 
bool get_next (element_type current, element_type &next) const
 
size_type get_indices () const
 
const index_vectorget_indexes () const
 
size_type get_bits () const
 
element_type get_value_at (size_type index) const
 
size_type get_value_index (element_type value) const
 
bool match (element_type value) const
 The basic match operation. More...
 
bool overlaps_with (const IdentifierField &other) const
 Check whether two IdentifierFields overlap. More...
 
void clear ()
 Set methods. More...
 
void set (element_type minimum, element_type maximum)
 
void add_value (element_type value)
 
void set (const element_vector &values)
 
void set (bool wraparound)
 
void set_next (int next)
 
void set_previous (int previous)
 
const IdentifierFieldoperator[] (IdentifierField::size_type index) const
 
void operator|= (const IdentifierField &other)
 
 operator std::string () const
 
bool operator== (const IdentifierField &other) const
 
void show () const
 
bool check_for_both_bounded ()
 Check mode - switch from enumerated to both_bounded if possible. More...
 
void optimize ()
 Optimize - try to switch mode to both_bounded, set up lookup table for finding index from value. More...
 
bool empty () const
 
bool isBounded () const
 
bool isEnumerated () const
 

Static Public Attributes

static constexpr auto minimum_possible = std::numeric_limits<element_type>::min()
 
static constexpr auto maximum_possible = std::numeric_limits<element_type>::max()
 
static constexpr auto invalidValues = element_vector{}
 

Private Member Functions

void set_minimum (element_type value)
 
void set_maximum (element_type value)
 
void create_index_table ()
 Create index table from value table. More...
 
template<class T >
T * dataPtr ()
 

Private Attributes

element_type m_minimum {}
 
element_type m_maximum {}
 
std::variant< element_vector, BoundedRangem_data {}
 
index_vector m_indexes {}
 
size_type m_size {}
 
element_type m_previous {}
 
element_type m_next {}
 
bool m_empty {true}
 
continuation_mode m_continuation_mode {none}
 

Static Private Attributes

static constexpr int m_maxNumberOfIndices = 100
 

Detailed Description

This is the individual specification for the range of one ExpandedIdentifier IdentifierField.


Definition at line 20 of file IdentifierField.h.

Member Typedef Documentation

◆ BoundedRange

Definition at line 27 of file IdentifierField.h.

◆ element_type

Definition at line 23 of file IdentifierField.h.

◆ element_vector

Definition at line 25 of file IdentifierField.h.

◆ index_vector

Definition at line 26 of file IdentifierField.h.

◆ size_type

Definition at line 24 of file IdentifierField.h.

Member Enumeration Documentation

◆ continuation_mode

Enumerator
none 
has_next 
has_previous 
has_both 
has_wrap_around 

Definition at line 32 of file IdentifierField.h.

32  {
33  none,
34  has_next,
35  has_previous,
36  has_both,
38  } ;

Constructor & Destructor Documentation

◆ IdentifierField() [1/4]

IdentifierField::IdentifierField ( )
default

Create a wild-card value.

◆ IdentifierField() [2/4]

IdentifierField::IdentifierField ( element_type  value)

Create a unique value (understood as : low bound = high bound = value)

Definition at line 83 of file IdentifierField.cxx.

84  :
88  m_empty{false}{
89  //
90 }

◆ IdentifierField() [3/4]

IdentifierField::IdentifierField ( element_type  minimum,
element_type  maximum 
)

Create a full range specification (with explicit min and max)

Definition at line 93 of file IdentifierField.cxx.

93  {
94  set(minimum, maximum);
95 }

◆ IdentifierField() [4/4]

IdentifierField::IdentifierField ( const element_vector values)

Create with enumerated values.

Definition at line 99 of file IdentifierField.cxx.

99  {
100  set(values);
101 }

Member Function Documentation

◆ add_value()

void IdentifierField::add_value ( element_type  value)

Definition at line 250 of file IdentifierField.cxx.

250  {
251  if (auto * p = dataPtr<element_vector>(); !p) {
252  clear();
253  m_data = element_vector(1,value);//now its enumerated
254  m_size = 1;
255  } else {
256  //check whether value already exists in the enumeration vector
257  if (std::ranges::binary_search(*p, value)) return;
258  p->push_back(value);
259  std::ranges::sort(*p);
260  m_size = p->size();
261  }
262  m_minimum = get_values().front();
263  m_maximum = get_values().back();
264  m_empty = false;
265 }

◆ check_for_both_bounded()

bool IdentifierField::check_for_both_bounded ( )

Check mode - switch from enumerated to both_bounded if possible.

Definition at line 430 of file IdentifierField.cxx.

430  {
431  if (m_empty) return false;
432  if (isEnumerated()) {
433  //the enumerated values are kept sorted
434  if (m_size-1 == static_cast<size_type>(m_maximum - m_minimum)){
436  return true;
437  }
438  }
439  return false;
440 }

◆ clear()

void IdentifierField::clear ( )

Set methods.

Definition at line 224 of file IdentifierField.cxx.

224  {
225  m_minimum = 0;
226  m_maximum = 0;
227  m_previous = 0;
228  m_next = 0;
231  m_indexes.clear();
232  m_empty = true;
233 }

◆ create_index_table()

void IdentifierField::create_index_table ( )
private

Create index table from value table.

Create index table from value table

Definition at line 444 of file IdentifierField.cxx.

444  {
445  if (m_empty) return;
447  if (isEnumerated()) {
449  // return if we are over the maximum desired vector table size
450  if (size > m_maxNumberOfIndices) {
451  m_indexes.clear();
452  return;
453  }
454  // Set up vectors for decoding
455  m_indexes = std::vector<size_type>(size, 0);
456  size_type index{};
457  int i{};
458  auto &v = std::get<element_vector>(m_data);
459  for (const auto & thisValue: v) {
460  if (const auto idx=(thisValue - m_minimum); idx < (int)size) {
461  m_indexes[idx] = index;
462  index++;
463  } else {
464  std::cout << "size, value, index, i "
465  << size << " " << thisValue << " "
466  << index << " " << i++ << " min, max "
467  << m_minimum << " "
468  << m_maximum
469  << std::endl;
470  }
471  }
472  }
473 }

◆ dataPtr()

template<class T >
T* IdentifierField::dataPtr ( )
inlineprivate

Definition at line 127 of file IdentifierField.h.

127 {return std::get_if<T>(&m_data);}

◆ empty()

bool IdentifierField::empty ( ) const
inline

Definition at line 114 of file IdentifierField.h.

114 {return m_empty;}

◆ get_bits()

ExpandedIdentifier::size_type IdentifierField::get_bits ( ) const

Definition at line 40 of file IdentifierField.cxx.

40  {
41  size_t indices = get_indices ();
42  if (--indices) return std::bit_width(indices);
43  return 1;
44 }

◆ get_indexes()

const index_vector& IdentifierField::get_indexes ( ) const
inline

Definition at line 79 of file IdentifierField.h.

79 {return m_indexes;}

◆ get_indices()

size_type IdentifierField::get_indices ( ) const
inline

Definition at line 78 of file IdentifierField.h.

78 {return m_size;}

◆ get_maximum()

element_type IdentifierField::get_maximum ( ) const
inline

Definition at line 68 of file IdentifierField.h.

68 {return m_maximum;}

◆ get_minimum()

element_type IdentifierField::get_minimum ( ) const
inline

Query the values.

Definition at line 59 of file IdentifierField.h.

59 {return m_minimum;}

◆ get_minmax()

std::pair<element_type, element_type> IdentifierField::get_minmax ( ) const
inline

Definition at line 63 of file IdentifierField.h.

63  {
64  return {m_minimum, m_maximum};
65  }

◆ get_next()

bool IdentifierField::get_next ( element_type  current,
element_type next 
) const

Definition at line 149 of file IdentifierField.cxx.

149  {
150  if (m_empty){
151  next = current + 1;
152  return (current != maximum_possible);
153  }
154 
155  if (isBounded()){
156  if (current == m_maximum) {
158  next = m_minimum;
159  return (true);
160  }
161  if (has_next == m_continuation_mode) {
162  next = m_next;
163  return (true);
164  }
165  next = current;
166  return (false);
167  }
168  next = current + 1;
169  return (true);
170  }
171  const auto & values= get_values();
173  if ((index == values.size() - 1) || (index == 0 && current != values.front())) {
175  next = values.front();
176  return (true);
177  }
178  if (has_next == m_continuation_mode) {
179  next = m_next;
180  return (true);
181  }
182  next = current;
183  return (false);
184  }
185  ++index;
186  next = values[index];
187  return true;
188 }

◆ get_previous()

bool IdentifierField::get_previous ( element_type  current,
element_type previous 
) const

Returns false if previous/next is at end of range, or not possible.

Definition at line 106 of file IdentifierField.cxx.

106  {
107  if (m_empty){
108  previous = current - 1;
109  return (current != minimum_possible);
110  }
111  if (isBounded()){
112  if (current == m_minimum) {
115  return (true);
116  }
119  return (true);
120  }
121  previous = current;
122  return (false);
123  }
124  previous = current - 1;
125  return (true);
126  }
127  const auto & values= get_values();
129  if (index == 0) {
131  previous = values.back();
132  return (true);
133  }
136  return (true);
137  }
138  previous = current;
139  return (false);
140  }
141  --index;
142  previous = values[index];
143  return true;
144 }

◆ get_value_at()

IdentifierField::element_type IdentifierField::get_value_at ( size_type  index) const
inline

Definition at line 141 of file IdentifierField.h.

141  {
142  // Only both_bounded and enumerated are valid to calculate the
143  // value.
144  // both_bounded is the more frequent case and so comes first.
145  if (m_empty) return 0;
146  if (const auto * p{std::get_if<BoundedRange>(&m_data)}; p) {
147  if (index >= (size_type) (p->second - p->first + 1)) {
148  throw std::out_of_range("IdentifierField::get_value_at");
149  }
150  return (p->first + index);
151  }
152  return ((std::get<element_vector>(m_data)).at(index));
153 
154 }

◆ get_value_index()

ExpandedIdentifier::size_type IdentifierField::get_value_index ( element_type  value) const

Definition at line 49 of file IdentifierField.cxx.

49  {
50  // Only both_bounded and enumerated are valid to calculate the
51  // index.
52  // both_bounded if the more frequent case and so comes first.
53  if (isBounded()) {
54  return (value - m_minimum);
55  }
56  const auto & v = get_values();
57  if (v.size()==1) return 0;
58  if (not m_indexes.empty()) {
59  // Table has been created, do simple lookup
60  assert (value >= m_minimum && value - m_minimum < (int)m_indexes.size());
61  return (m_indexes.at(value - m_minimum));
62  } else {
63  auto it = std::ranges::find(v, value);
64  if (it != v.end()) return std::distance(v.begin(), it);
65  }
66  return 0;
67 }

◆ get_values()

const element_vector& IdentifierField::get_values ( ) const
inline

Definition at line 71 of file IdentifierField.h.

71  {
72  if (isBounded()) return invalidValues;
73  return std::get<element_vector>(m_data);
74  }

◆ isBounded()

bool IdentifierField::isBounded ( ) const
inline

Definition at line 116 of file IdentifierField.h.

116 {return std::holds_alternative<BoundedRange>(m_data);}

◆ isEnumerated()

bool IdentifierField::isEnumerated ( ) const
inline

Definition at line 117 of file IdentifierField.h.

117 {return std::holds_alternative<element_vector>(m_data);}

◆ match()

bool IdentifierField::match ( element_type  value) const

The basic match operation.

Definition at line 71 of file IdentifierField.cxx.

71  {
72  if (isBounded()) {
73  return ((value >= m_minimum) && (value <= m_maximum));
74  }
75  if (m_empty) return true;
76  const auto & v = get_values();
77  return (std::ranges::find(v, value)!=v.end());
78 }

◆ operator std::string()

IdentifierField::operator std::string ( ) const

Definition at line 343 of file IdentifierField.cxx.

343  {
344  std::string result;
345  if (m_empty) {
346  result = "*";
347  } else {
348  const auto & [minimum, maximum] = get_minmax();
349  if (minimum == maximum) {
350  result = std::to_string(minimum);
351  } else {
352  if (isEnumerated()) {
353  std::string prefix;
354  for (size_type i = 0; i < get_indices (); ++i) {
356  prefix = ",";
357  }
358  } else {
359  result = std::format("{}:{}", minimum, maximum);
360  }
361  }
362  }
363  return result;
364 }

◆ operator==()

bool IdentifierField::operator== ( const IdentifierField other) const

Definition at line 368 of file IdentifierField.cxx.

368  {
369  if (m_data != other.m_data) return false;
370  return (true);
371 }

◆ operator[]()

const IdentifierField& IdentifierField::operator[] ( IdentifierField::size_type  index) const

◆ operator|=()

void IdentifierField::operator|= ( const IdentifierField other)

If there is no overlap we should build a multi-segment specification. The current algorithm is only correct if the overlap in not empty !! A multi-segment specification might also be implemented as an expanded enumerated set (not very optimized !!)

Definition at line 319 of file IdentifierField.cxx.

319  {
320  if (m_empty or other.m_empty){
321  clear();
322  m_size = 1;
323  return;
324  }
325  if (isEnumerated() and other.isEnumerated()){
326  set(other.get_values ());
327  return;
328  }
335  // all other cases...
336  const auto min = std::min(m_minimum, other.m_minimum);
337  const auto max = std::max(m_maximum, other.m_maximum);
338  set(min, max);
339 }

◆ optimize()

void IdentifierField::optimize ( )

Optimize - try to switch mode to both_bounded, set up lookup table for finding index from value.

Check mode - switch from enumerated to both_bounded if possible

Definition at line 422 of file IdentifierField.cxx.

422  {
425 }

◆ overlaps_with()

bool IdentifierField::overlaps_with ( const IdentifierField other) const

Check whether two IdentifierFields overlap.

Definition at line 194 of file IdentifierField.cxx.

194  {
195  if (m_empty or other.m_empty) return true;
196  //
197  if (isBounded() and other.isBounded()){
198  return ((m_minimum <= other.m_maximum) && (m_maximum >= other.m_minimum));
199  }
200  //
201  if (isBounded() and other.isEnumerated() ){
202  const element_vector& ev = other.get_values();
203  for (const auto & v: ev) {
204  if (v >= m_minimum and v<= m_maximum) return (true);
205  }
206  return false;
207  } else if (isEnumerated() and other.isBounded()){
208  const element_vector& ev = get_values();
209  for (const auto & v: ev){
210  if ((v >= other.m_minimum) and (v <= other.m_maximum)) return (true);
211  }
212  return false;
213  }
214  // Both fields are enumerated only if there is possibility of overlap
215  if ((m_minimum <= other.m_maximum) && (m_maximum >= other.m_minimum)) {
216  return share_element(get_values(), other.get_values());
217  }
218  return (false);
219 }

◆ set() [1/3]

void IdentifierField::set ( bool  wraparound)

Definition at line 287 of file IdentifierField.cxx.

287  {
288  if (wraparound) {
290  }
291 }

◆ set() [2/3]

void IdentifierField::set ( const element_vector values)

◆ set() [3/3]

void IdentifierField::set ( element_type  minimum,
element_type  maximum 
)

Definition at line 237 of file IdentifierField.cxx.

237  {
238  if (minimum == maximum) {
239  add_value(minimum);
240  } else {
241  std::tie(m_minimum,m_maximum) = std::minmax(minimum,maximum);
243  m_size = m_maximum - m_minimum + 1;
244  }
245  m_empty=false;
246 }

◆ set_maximum()

void IdentifierField::set_maximum ( element_type  value)
private

◆ set_minimum()

void IdentifierField::set_minimum ( element_type  value)
private

◆ set_next()

void IdentifierField::set_next ( int  next)

Definition at line 295 of file IdentifierField.cxx.

295  {
298  } else {
300  }
301  m_next = next;
302 }

◆ set_previous()

void IdentifierField::set_previous ( int  previous)

Definition at line 307 of file IdentifierField.cxx.

307  {
308  if (has_next == m_continuation_mode) {
310  } else {
312  }
314 }

◆ show()

void IdentifierField::show ( ) const

Definition at line 376 of file IdentifierField.cxx.

376  {
377  std::cout << "min/max " << m_minimum << " " << m_maximum << " ";
378  std::cout << "values ";
379  for (const auto& v: get_values()) {
380  std::cout << v << " ";
381  }
382  std::cout << "indexes ";
383  for (const auto & idx: m_indexes) {
384  std::cout << idx << " ";
385  }
386  std::cout << "indices " << m_size << " ";
387  std::cout << "prev " << m_previous << " ";
388  std::cout << "next " << m_next << " ";
389  std::cout << "mode ";
390  if (m_empty){
391  std::cout << "unbounded ";
392  }else if (isBounded()){
393  std::cout << "both_bounded ";
394  }else if (isEnumerated()) {
395  std::cout << "enumerated ";
396  }
397  std::cout << "cont mode ";
398  switch (m_continuation_mode) {
399  case IdentifierField::none:
400  std::cout << "none ";
401  break;
403  std::cout << "has_next ";
404  break;
406  std::cout << "has_previous ";
407  break;
409  std::cout << "has_both ";
410  break;
412  std::cout << "has_wrap_around ";
413  break;
414  }
415  std::cout << std::endl;
416 }

◆ wrap_around()

bool IdentifierField::wrap_around ( ) const
inline

Definition at line 54 of file IdentifierField.h.

54 { return (has_wrap_around == m_continuation_mode);}

Member Data Documentation

◆ invalidValues

constexpr auto IdentifierField::invalidValues = element_vector{}
staticconstexpr

Definition at line 30 of file IdentifierField.h.

◆ m_continuation_mode

continuation_mode IdentifierField::m_continuation_mode {none}
private

Definition at line 137 of file IdentifierField.h.

◆ m_data

std::variant<element_vector, BoundedRange> IdentifierField::m_data {}
private

Definition at line 131 of file IdentifierField.h.

◆ m_empty

bool IdentifierField::m_empty {true}
private

Definition at line 136 of file IdentifierField.h.

◆ m_indexes

index_vector IdentifierField::m_indexes {}
private

Definition at line 132 of file IdentifierField.h.

◆ m_maximum

element_type IdentifierField::m_maximum {}
private

Definition at line 130 of file IdentifierField.h.

◆ m_maxNumberOfIndices

constexpr int IdentifierField::m_maxNumberOfIndices = 100
staticconstexprprivate

Definition at line 120 of file IdentifierField.h.

◆ m_minimum

element_type IdentifierField::m_minimum {}
private

Definition at line 129 of file IdentifierField.h.

◆ m_next

element_type IdentifierField::m_next {}
private

Definition at line 135 of file IdentifierField.h.

◆ m_previous

element_type IdentifierField::m_previous {}
private

Definition at line 134 of file IdentifierField.h.

◆ m_size

size_type IdentifierField::m_size {}
private

Definition at line 133 of file IdentifierField.h.

◆ maximum_possible

constexpr auto IdentifierField::maximum_possible = std::numeric_limits<element_type>::max()
staticconstexpr

Definition at line 29 of file IdentifierField.h.

◆ minimum_possible

constexpr auto IdentifierField::minimum_possible = std::numeric_limits<element_type>::min()
staticconstexpr

Definition at line 28 of file IdentifierField.h.


The documentation for this class was generated from the following files:
fillPileUpNoiseLumi.current
current
Definition: fillPileUpNoiseLumi.py:52
get_generator_info.result
result
Definition: get_generator_info.py:21
vtune_athena.format
format
Definition: vtune_athena.py:14
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
IdentifierField::get_minmax
std::pair< element_type, element_type > get_minmax() const
Definition: IdentifierField.h:63
index
Definition: index.py:1
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
IdentifierField::m_maxNumberOfIndices
static constexpr int m_maxNumberOfIndices
Definition: IdentifierField.h:120
Trk::indices
std::pair< long int, long int > indices
Definition: AlSymMatBase.h:24
skel.it
it
Definition: skel.GENtoEVGEN.py:401
IdentifierField::clear
void clear()
Set methods.
Definition: IdentifierField.cxx:224
IdentifierField::m_maximum
element_type m_maximum
Definition: IdentifierField.h:130
athena.value
value
Definition: athena.py:124
IdentifierField::get_values
const element_vector & get_values() const
Definition: IdentifierField.h:71
IdentifierField::set
void set(element_type minimum, element_type maximum)
Definition: IdentifierField.cxx:237
IdentifierField::has_both
@ has_both
Definition: IdentifierField.h:36
IdentifierField::m_continuation_mode
continuation_mode m_continuation_mode
Definition: IdentifierField.h:137
IdentifierField::m_next
element_type m_next
Definition: IdentifierField.h:135
IdentifierField::create_index_table
void create_index_table()
Create index table from value table.
Definition: IdentifierField.cxx:444
python.Bindings.values
values
Definition: Control/AthenaPython/python/Bindings.py:805
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
IdentifierField::m_size
size_type m_size
Definition: IdentifierField.h:133
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ev
int ev
Definition: globals.cxx:25
IdentifierField::get_value_index
size_type get_value_index(element_type value) const
Definition: IdentifierField.cxx:49
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
lumiFormat.i
int i
Definition: lumiFormat.py:85
IdentifierField::m_previous
element_type m_previous
Definition: IdentifierField.h:134
IdentifierField::minimum_possible
static constexpr auto minimum_possible
Definition: IdentifierField.h:28
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
IdentifierField::m_minimum
element_type m_minimum
Definition: IdentifierField.h:129
IdentifierField::m_data
std::variant< element_vector, BoundedRange > m_data
Definition: IdentifierField.h:131
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
IdentifierField::isEnumerated
bool isEnumerated() const
Definition: IdentifierField.h:117
IdentifierField::element_vector
std::vector< element_type > element_vector
Definition: IdentifierField.h:25
IdentifierField::none
@ none
Definition: IdentifierField.h:33
IdentifierField::check_for_both_bounded
bool check_for_both_bounded()
Check mode - switch from enumerated to both_bounded if possible.
Definition: IdentifierField.cxx:430
IdentifierField::size_type
ExpandedIdentifier::size_type size_type
Definition: IdentifierField.h:24
IdentifierField::maximum_possible
static constexpr auto maximum_possible
Definition: IdentifierField.h:29
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
IdentifierField::isBounded
bool isBounded() const
Definition: IdentifierField.h:116
python.PyAthena.v
v
Definition: PyAthena.py:154
IdentifierField::has_wrap_around
@ has_wrap_around
Definition: IdentifierField.h:37
IdentifierField::m_empty
bool m_empty
Definition: IdentifierField.h:136
DeMoScan.index
string index
Definition: DeMoScan.py:364
InDetDD::other
@ other
Definition: InDetDD_Defs.h:16
IdentifierField::m_indexes
index_vector m_indexes
Definition: IdentifierField.h:132
IdentifierField::BoundedRange
std::pair< element_type, element_type > BoundedRange
Definition: IdentifierField.h:27
IdentifierField::has_next
@ has_next
Definition: IdentifierField.h:34
IdentifierField::get_value_at
element_type get_value_at(size_type index) const
Definition: IdentifierField.h:141
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
IdentifierField::invalidValues
static constexpr auto invalidValues
Definition: IdentifierField.h:30
IdentifierField::has_previous
@ has_previous
Definition: IdentifierField.h:35
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
IdentifierField::add_value
void add_value(element_type value)
Definition: IdentifierField.cxx:250
IdentifierField::get_indices
size_type get_indices() const
Definition: IdentifierField.h:78
Trk::previous
@ previous
Definition: BinningData.h:32