ATLAS Offline Software
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Member Functions | Private Attributes | List of all members
ActsTrk::detail::AtlasMeasurementContainerList Class Reference

#include <AtlasUncalibSourceLinkAccessor.h>

Inheritance diagram for ActsTrk::detail::AtlasMeasurementContainerList:
Collaboration diagram for ActsTrk::detail::AtlasMeasurementContainerList:

Public Types

using Base
using measurement_container_variant_t

Public Member Functions

unsigned int getDimension (const xAOD::PixelClusterContainer &container)
std::size_t size () const
const measurement_container_variant_t & at (std::size_t container_index) const
const std::vector< measurement_container_variant_t > & containerList () const
void setContainer (std::size_t container_index, const container_t &container)

Static Public Member Functions

template<std::size_t DIM>
static bool isDimension (const SG::AuxVectorBase &container)
static constexpr std::size_t getMeasurementDimMax ()
static void dumpVariantTypes (std::ostream &out)

Protected Member Functions

const AtlasMeasurementContainerList & derived () const

Static Protected Member Functions

static constexpr T lvalue (T &&a)
static constexpr std::size_t dimMax (std::size_t max_dim=0ul)
static constexpr bool isSameContainer ()
static constexpr unsigned int countVariants ()
static unsigned int countDerivedVariants (const container_t &a)
static void dumpVariantTypesImpl (std::ostream &out)
static void throwContainerNotInVariant (const char *a)
static measurement_container_variant_t getContainerWithDimensionNoAmbiguities (const container_t &a, unsigned int dimension=0)
static unsigned int getDimensionOfDerivedVariantOption (const container_t &a)
static measurement_container_variant_t getContainerWithDimension (const container_t &a)

Private Attributes

std::vector< measurement_container_variant_t > m_containerList

Detailed Description

Definition at line 230 of file AtlasUncalibSourceLinkAccessor.h.

Member Typedef Documentation

◆ Base

using MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::Base
inherited

Definition at line 263 of file MeasurementContainerWithDimension.h.

◆ measurement_container_variant_t

using MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::measurement_container_variant_t
inherited

Definition at line 264 of file MeasurementContainerWithDimension.h.

Member Function Documentation

◆ at()

const measurement_container_variant_t & MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::at ( std::size_t container_index) const
inlineinherited

Definition at line 280 of file MeasurementContainerWithDimension.h.

280 {
281 return m_containerList.at(container_index);
282 }

◆ containerList()

const std::vector< measurement_container_variant_t > & MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::containerList ( ) const
inlineinherited

Definition at line 283 of file MeasurementContainerWithDimension.h.

283{ return m_containerList;}

◆ countDerivedVariants()

unsigned int MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::countDerivedVariants ( const container_t & a)
inlinestaticprotectedinherited

Definition at line 79 of file MeasurementContainerWithDimension.h.

79 {
80 if constexpr(N==0) {
81 return 0;
82 }
83 else {
84 if constexpr(isSameContainer<container_t, N-1>()) {
85 return countDerivedVariants<container_t, N-1>(a)+1;
86 }
87 else {
88 using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
89 using this_container_type = typename this_variant_type::container_type;
90 if constexpr(std::is_base_of_v<container_t, this_container_type>
91 && std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
92 return countDerivedVariants<container_t, N-1>(a)+ ( dynamic_cast<const this_container_type *>(&a) != nullptr );
93 }
94 else {
95 return countDerivedVariants<container_t, N-1>(a);
96 }
97 }
98 }
99 }

◆ countVariants()

constexpr unsigned int MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::countVariants ( )
inlinestaticconstexprprotectedinherited

Definition at line 70 of file MeasurementContainerWithDimension.h.

70 {
71 if constexpr(N==0) {
72 return 0;
73 }
74 else {
75 return countVariants<container_t, N-1>()+ isSameContainer<container_t, N-1>();
76 }
77 }

◆ derived()

const AtlasMeasurementContainerList & MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::derived ( ) const
inlineprotectedinherited

Definition at line 48 of file MeasurementContainerWithDimension.h.

48{ return *static_cast<const derived_t *>(this); }

◆ dimMax()

constexpr std::size_t MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::dimMax ( std::size_t max_dim = 0ul)
inlinestaticconstexprprotectedinherited

Definition at line 54 of file MeasurementContainerWithDimension.h.

54 {
55 if constexpr(N>0) {
56 using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
57 return dimMax<N-1>(std::max( this_variant_type::dimension(), max_dim ) );
58 }
59 return max_dim;
60 }

◆ dumpVariantTypes()

void MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::dumpVariantTypes ( std::ostream & out)
inlinestaticinherited

Definition at line 272 of file MeasurementContainerWithDimension.h.

272 {
273 Base::template dumpVariantTypesImpl<>(out);
274 }

◆ dumpVariantTypesImpl()

void MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::dumpVariantTypesImpl ( std::ostream & out)
inlinestaticprotectedinherited

Definition at line 102 of file MeasurementContainerWithDimension.h.

102 {
103 if constexpr(N>0) {
104 using a_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
105 out << N-1 << ": " << typeid(a_type).name() << std::endl;
106 dumpVariantTypesImpl<N-1>(out);
107 }
108 }

◆ getContainerWithDimension()

measurement_container_variant_t MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::getContainerWithDimension ( const container_t & a)
inlinestaticprotectedinherited

Definition at line 239 of file MeasurementContainerWithDimension.h.

239 {
240 constexpr unsigned int variant_multiplicity = countVariants<container_t>();
241 // the container must by among the options of the measurement_container_variant_t
242 static constexpr std::size_t NVariants = std::variant_size_v< measurement_container_variant_t >;
243 if constexpr( variant_multiplicity == 1) {
244 return getContainerWithDimensionNoAmbiguities<container_t, false, NVariants>(a);
245 }
246 else {
247 if (variant_multiplicity==0) {
248 if (countDerivedVariants<container_t>(a) == 1) {
249 return getContainerWithDimensionNoAmbiguities<container_t, false, NVariants>(a);
250 }
251 }
252 DEBUG_TRACE( std::cout << "DEBUG need to search with dimension check for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
253 << " multiplicity : " << variant_multiplicity << " derived " << countDerivedVariants<container_t>(a)
254 << std:: endl );
255 return getContainerWithDimensionNoAmbiguities<container_t, true, NVariants>(a, getDimensionOfDerivedVariantOption<container_t,NVariants>(a));
256 }
257 }
DEBUG_TRACE
#define DEBUG_TRACE(a)
Definition MeasurementContainerWithDimension.h:33
MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container... >::getContainerWithDimensionNoAmbiguities
static measurement_container_variant_t getContainerWithDimensionNoAmbiguities(const container_t &a, unsigned int dimension=0)
Definition MeasurementContainerWithDimension.h:117

◆ getContainerWithDimensionNoAmbiguities()

measurement_container_variant_t MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::getContainerWithDimensionNoAmbiguities ( const container_t & a,
unsigned int dimension = 0 )
inlinestaticprotectedinherited

Definition at line 117 of file MeasurementContainerWithDimension.h.

117 {
118 if constexpr(N==0) {
119 // this measns that the container_t has not been found in the list of possible options of the variant
120 // reasons: the type is not in the list, a derived type was provided and compaibility was not understood
121 throwContainerNotInVariant(typeid(a).name());
122 using this_variant_type = decltype( lvalue(std::get<0>(measurement_container_variant_t{}) ) );
123 return this_variant_type();
124 }
125 else {
126 using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
127 using this_container_type = typename this_variant_type::container_type ;
128 DEBUG_TRACE( std::cout << "DEBUG search option for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
129 << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
130 << " check dimension ? " << check_dimension << " desired dimension " << dimension
131 << std:: endl );
132 if constexpr(std::is_same_v<this_container_type, container_t>) {
133 // this option of the variant has perfect type match.
134 if constexpr(!check_dimension && countVariants<container_t>()==1) {
135 // if dimensions are not to be checked there must not be other options which also match the type
136 // the caller should have ensureed that this branch is impossible,
137 // but this can only be excluded at runtime, so a static_assert
138 // is impossible here
139 assert( (countVariants<this_container_type,N-1>()) == 0 );
140 DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
141 << " foumd unambiguous option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
142 << std:: endl );
143 return ContainerRefWithDim<container_t, this_variant_type::dimension()>(a);
144 }
145 else {
146 // otherwise check if the dimension of this option is identical to the
147 // expected dimension
148 if (this_variant_type::dimension() == dimension) {
149 DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
150 << " foumd dimension option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
151 << std:: endl );
152 return ContainerRefWithDim<container_t, this_variant_type::dimension()>(a);
153 }
154 }
155 }
156 else if constexpr(std::is_base_of_v<container_t, this_container_type>) {
157 // it is also possible that the container is a base of an option of the variant.
158 if constexpr(std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
159 // casting can only be done safely if dynamic casts are possible, which requires
160 // a virtuaal destructor
161 const this_container_type *derived_container = dynamic_cast<const this_container_type *>(&a);
162 if (derived_container) {
163 // if the provided container can be casted to the type of this variant option
164 // then check the dimensions
165 if constexpr(!check_dimension) {
166 // Branch may be incorrectly chose and/or assert may fail
167 // if A is base of B and B is Base of C and both B and C are options of the variant
168 // the auto-detection will treat B
169 if constexpr(countVariants<container_t,N-1>() != 0) {
170 return getContainerWithDimensionNoAmbiguities<container_t, check_dimension, N-1>(a, dimension);
171 }
172 else {
173 DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(this_container_type).name() << " (aka " << typeid(a).name() << ")"
174 << " foumd derived option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
175 << std:: endl );
176 return ContainerRefWithDim<this_container_type, this_variant_type::dimension()>(*derived_container);
177 }
178 }
179 else {
180 if (this_variant_type::dimension() == dimension) {
181 DEBUG_TRACE( std::cout << "DEBUG --> for " << typeid(this_container_type).name() << " (aka " << typeid(a).name() << ")"
182 << " derived with dimension option: " << N << " " << typeid(this_container_type).name()
183 << " dim " << this_variant_type::dimension()
184 << std:: endl );
185 return ContainerRefWithDim<this_container_type, this_variant_type::dimension()>(*derived_container);
186 }
187 }
188 }
189 }
190 }
191 return getContainerWithDimensionNoAmbiguities<container_t, check_dimension, N-1>(a, dimension);
192 }
193 }

◆ getDimension()

unsigned int ActsTrk::detail::AtlasMeasurementContainerList::getDimension ( const xAOD::PixelClusterContainer & container)
inline

Definition at line 246 of file AtlasUncalibSourceLinkAccessor.h.

246 {
247 if (isDimension<2>(container.auxbase())) { return 2u; }
248 else if (isDimension<3>(container.auxbase())) { return 3u; }
249 else {
250 throw std::runtime_error("Unsupported dimension for PixelClusterContainer");
251 }
252 }
ActsTrk::detail::AtlasMeasurementContainerList::isDimension
static bool isDimension(const SG::AuxVectorBase &container)
Definition AtlasUncalibSourceLinkAccessor.h:238
SG::container
const SG::AuxVectorData * container() const
Return the container holding this element.

◆ getDimensionOfDerivedVariantOption()

unsigned int MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::getDimensionOfDerivedVariantOption ( const container_t & a)
inlinestaticprotectedinherited

Definition at line 196 of file MeasurementContainerWithDimension.h.

196 {
197 if constexpr(N==0) {
198 // failure
199 return 0;
200 }
201 else {
202 using this_variant_type = decltype( lvalue(std::get<N-1>(measurement_container_variant_t{}) ) );
203 using this_container_type = typename this_variant_type::container_type;
204
205 DEBUG_TRACE( std::cout << "DEBUG determin dimension for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
206 << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
207 << std:: endl );
208
209 if constexpr(std::is_same<container_t, this_container_type>::value) {
210 DEBUG_TRACE( std::cout << "DEBUG get dimension for " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
211 << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
212 << std:: endl );
213 return derived_t::getDimension(a);
214 }
215 else if constexpr(std::is_base_of_v<container_t, this_container_type>) {
216 DEBUG_TRACE( std::cout << "DEBUG try get dimension for derived " << typeid(container_t).name() << " (aka " << typeid(a).name() << ")"
217 << " option: " << N << " " << typeid(this_container_type).name() << " dim " << this_variant_type::dimension()
218 << std:: endl );
219 // it is also possible that the container is a base of an option of the variant.
220 if constexpr(std::has_virtual_destructor_v<this_container_type> && std::has_virtual_destructor_v<container_t>) {
221 // if there is no ambiguity there is no point in determining the dimension
222 // @TODO but this does not guarantee that this option matches if the provided container
223 // can have multiple dimensions.
224 if constexpr(countVariants<this_container_type>() > 1) {
225 // casting can only be done safely if dynamic casts are possible, which requires
226 // a virtual destructor
227 const this_container_type *derived_container = dynamic_cast<const this_container_type *>(&a);
228 if (derived_container) {
229 return derived_t::getDimension(*derived_container);
230 }
231 }
232 }
233 }
234 return getDimensionOfDerivedVariantOption<container_t, N-1>(a);
235 }
236 }

◆ getMeasurementDimMax()

constexpr std::size_t MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::getMeasurementDimMax ( )
inlinestaticconstexprinherited

Definition at line 269 of file MeasurementContainerWithDimension.h.

269 {
270 return Base::dimMax();
271 }

◆ isDimension()

template<std::size_t DIM>
bool ActsTrk::detail::AtlasMeasurementContainerList::isDimension ( const SG::AuxVectorBase & container)
inlinestatic

Definition at line 238 of file AtlasUncalibSourceLinkAccessor.h.

238 {
239 static const xAOD::PosAccessor<DIM> acc{"localPositionDim" + std::to_string(DIM)};
240 return container.isAvailable(acc.auxid());
241 }
SG::AuxVectorData::isAvailable
bool isAvailable(auxid_t id) const
Test to see if a variable exists in the store.
xAOD::PosAccessor
SG::AuxElement::Accessor< std::array< float, N > > PosAccessor
xAOD Accessor to the position
Definition MeasurementDefs.h:52

◆ isSameContainer()

constexpr bool MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::isSameContainer ( )
inlinestaticconstexprprotectedinherited

Definition at line 63 of file MeasurementContainerWithDimension.h.

63 {
64 using this_variant_type = decltype( lvalue(std::get<N>(measurement_container_variant_t{}) ) );
65 return std::is_same<container_t, typename this_variant_type::container_type>::value;
66 }

◆ lvalue()

constexpr T MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::lvalue ( T && a)
inlinestaticconstexprprotectedinherited

Definition at line 51 of file MeasurementContainerWithDimension.h.

51{ return a;}

◆ setContainer()

void MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::setContainer ( std::size_t container_index,
const container_t & container )
inlineinherited

Definition at line 286 of file MeasurementContainerWithDimension.h.

286 {
287 if (container_index>=m_containerList.size()) {
288 m_containerList.resize(container_index+1);
289 }
290 m_containerList[container_index] = this->getContainerWithDimension(container);
291 if ( std::holds_alternative< decltype(this->lvalue(get<0>(measurement_container_variant_t{}))) >( m_containerList[container_index])
292 && std::get<0>(m_containerList[container_index]).containerPtr() == nullptr) {
293 // @TODO should never happen
294 std::runtime_error("Unhandled measurement type");
295 }
296
297 }

◆ size()

std::size_t MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::size ( ) const
inlineinherited

Definition at line 276 of file MeasurementContainerWithDimension.h.

276 {
277 return m_containerList.size();
278 }

◆ throwContainerNotInVariant()

void MeasurementContainerWithDimension< AtlasMeasurementContainerList, T_Container >::throwContainerNotInVariant ( const char * a)
inlinestaticprotectedinherited

Definition at line 109 of file MeasurementContainerWithDimension.h.

109 {
110 std::stringstream msg;
111 msg << "Container " << a << " not in variant:" << std::endl;
112 dumpVariantTypesImpl(msg);
113 throw std::runtime_error(msg.str());
114 }

Member Data Documentation

◆ m_containerList

std::vector< measurement_container_variant_t > MeasurementContainerListWithDimension< AtlasMeasurementContainerList, T_Container >::m_containerList
privateinherited

Definition at line 266 of file MeasurementContainerWithDimension.h.

The documentation for this class was generated from the following file:
Generated on for ATLAS Offline Software by doxygen 1.17.0