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 82 of file IdentifierField.cxx.

83  :
87  m_empty{false}{
88  //
89 }

◆ IdentifierField() [3/4]

IdentifierField::IdentifierField ( element_type  minimum,
element_type  maximum 
)

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

Definition at line 92 of file IdentifierField.cxx.

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

◆ IdentifierField() [4/4]

IdentifierField::IdentifierField ( const element_vector values)

Create with enumerated values.

Definition at line 98 of file IdentifierField.cxx.

98  {
99  set(values);
100 }

Member Function Documentation

◆ add_value()

void IdentifierField::add_value ( element_type  value)

Definition at line 249 of file IdentifierField.cxx.

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

◆ check_for_both_bounded()

bool IdentifierField::check_for_both_bounded ( )

Check mode - switch from enumerated to both_bounded if possible.

Definition at line 429 of file IdentifierField.cxx.

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

◆ clear()

void IdentifierField::clear ( )

Set methods.

Definition at line 223 of file IdentifierField.cxx.

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

◆ create_index_table()

void IdentifierField::create_index_table ( )
private

Create index table from value table.

Create index table from value table

Definition at line 443 of file IdentifierField.cxx.

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

◆ 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 148 of file IdentifierField.cxx.

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

◆ 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 105 of file IdentifierField.cxx.

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

◆ 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  if (not m_indexes.empty()) {
57  // Table has been created, do simple lookup
58  assert (value >= m_minimum && value - m_minimum < (int)m_indexes.size());
59  return (m_indexes.at(value - m_minimum));
60  } else {
61  const auto & v = get_values();
62  auto it = std::ranges::lower_bound(v, value);
63  if (it != v.end()) return std::distance(v.begin(), it);
64  }
65  return 0;
66 }

◆ 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 70 of file IdentifierField.cxx.

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

◆ operator std::string()

IdentifierField::operator std::string ( ) const

Definition at line 342 of file IdentifierField.cxx.

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

◆ operator==()

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

Definition at line 367 of file IdentifierField.cxx.

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

◆ 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 318 of file IdentifierField.cxx.

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

◆ 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 421 of file IdentifierField.cxx.

421  {
424 }

◆ overlaps_with()

bool IdentifierField::overlaps_with ( const IdentifierField other) const

Check whether two IdentifierFields overlap.

Definition at line 193 of file IdentifierField.cxx.

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

◆ set() [1/3]

void IdentifierField::set ( bool  wraparound)

Definition at line 286 of file IdentifierField.cxx.

286  {
287  if (wraparound) {
289  }
290 }

◆ 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 236 of file IdentifierField.cxx.

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

◆ 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 294 of file IdentifierField.cxx.

294  {
297  } else {
299  }
300  m_next = next;
301 }

◆ set_previous()

void IdentifierField::set_previous ( int  previous)

Definition at line 306 of file IdentifierField.cxx.

306  {
307  if (has_next == m_continuation_mode) {
309  } else {
311  }
313 }

◆ show()

void IdentifierField::show ( ) const

Definition at line 375 of file IdentifierField.cxx.

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

◆ 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
max
#define max(a, b)
Definition: cfImp.cxx:41
vtune_athena.format
format
Definition: vtune_athena.py:14
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
IdentifierField::get_minmax
std::pair< element_type, element_type > get_minmax() const
Definition: IdentifierField.h:63
index
Definition: index.py:1
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:396
IdentifierField::clear
void clear()
Set methods.
Definition: IdentifierField.cxx:223
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:236
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:443
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
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
min
#define min(a, b)
Definition: cfImp.cxx:40
IdentifierField::check_for_both_bounded
bool check_for_both_bounded()
Check mode - switch from enumerated to both_bounded if possible.
Definition: IdentifierField.cxx:429
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:249
IdentifierField::get_indices
size_type get_indices() const
Definition: IdentifierField.h:78
Trk::previous
@ previous
Definition: BinningData.h:32