ATLAS Offline Software
Public Member Functions | Static Private Member Functions | Private Attributes | List of all members
Trk::CombinedVolumeBounds Class Referencefinal

#include <CombinedVolumeBounds.h>

Inheritance diagram for Trk::CombinedVolumeBounds:
Collaboration diagram for Trk::CombinedVolumeBounds:

Public Member Functions

 CombinedVolumeBounds ()
 Default Constructor. More...
 
 CombinedVolumeBounds (std::unique_ptr< Volume > first, std::unique_ptr< Volume > second, bool intersection)
 Constructor - the box boundaries. More...
 
 CombinedVolumeBounds (const CombinedVolumeBounds &bobo)
 Copy Constructor. More...
 
virtual ~CombinedVolumeBounds ()
 Destructor. More...
 
CombinedVolumeBounds & operator= (const CombinedVolumeBounds &bobo)
 Assignment operator. More...
 
virtual CombinedVolumeBounds * clone () const override final
 Virtual constructor. More...
 
virtual bool inside (const Amg::Vector3D &, double tol=0.) const override final
 This method checks if position in the 3D volume frame is inside the volume. More...
 
virtual std::vector< std::unique_ptr< Trk::Surface > > decomposeToSurfaces (const Amg::Transform3D &transform) override final
 Method to decompose the Bounds into boundarySurfaces. More...
 
virtual ObjectAccessor boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &dir, bool forceInside=false) const override final
 Provide accessor for BoundarySurfaces. More...
 
const Volume * first () const
 This method returns the first VolumeBounds. More...
 
const Volume * second () const
 This method returns the second VolumeBounds. More...
 
bool intersection () const
 This method distinguishes between Union(0) and Intersection(1) More...
 
const std::vector< bool > & boundsOrientation () const
 This method returns bounds orientation. More...
 
virtual MsgStream & dump (MsgStream &sl) const override final
 Output Method for MsgStream. More...
 
virtual std::ostream & dump (std::ostream &sl) const override final
 Output Method for std::ostream. More...
 

Static Private Member Functions

static Trk::Volume * createSubtractedVolume (const Amg::Transform3D &transf, const Trk::Volume *subtrVol)
 

Private Attributes

std::unique_ptr< Volume > m_first {}
 
std::unique_ptr< Volume > m_second {}
 
bool m_intersection {}
 
EightObjectsAccessor m_objectAccessor {}
 
std::vector< bool > m_boundsOrientation {}
 

Detailed Description

Bounds for a generic combined volume, the decomposeToSurfaces method creates a vector of n surfaces (n1+n2-nshared):

BoundarySurfaceFace [index]: [n1+n2-nshared] combined surfaces

designed to allow transcript of GeoShapeUnion and GeoShapeIntersection

Author
Sarka.nosp@m..Tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch
Christos Anastopoulos (Athena MT modifications)

Definition at line 44 of file CombinedVolumeBounds.h.

Constructor & Destructor Documentation

◆ CombinedVolumeBounds() [1/3]

Trk::CombinedVolumeBounds::CombinedVolumeBounds ( )
default

Default Constructor.

◆ CombinedVolumeBounds() [2/3]

Trk::CombinedVolumeBounds::CombinedVolumeBounds ( std::unique_ptr< Volume >  first,
std::unique_ptr< Volume >  second,
bool  intersection 
)

Constructor - the box boundaries.

Definition at line 36 of file CombinedVolumeBounds.cxx.

40  : VolumeBounds()
41  , m_first(std::move(vol1))
42  , m_second(std::move(vol2))
43  , m_intersection(intersection)
44  , m_objectAccessor()
45  , m_boundsOrientation()
46 {}

◆ CombinedVolumeBounds() [3/3]

Trk::CombinedVolumeBounds::CombinedVolumeBounds ( const CombinedVolumeBounds &  bobo)

Copy Constructor.

Definition at line 48 of file CombinedVolumeBounds.cxx.

50  : VolumeBounds()
51  , m_first{bobo.m_first->clone()}
52  , m_second{bobo.m_second->clone()}
53  , m_intersection(bobo.m_intersection)
54  , m_objectAccessor(bobo.m_objectAccessor)
55  , m_boundsOrientation(bobo.m_boundsOrientation)
56 {}

◆ ~CombinedVolumeBounds()

Trk::CombinedVolumeBounds::~CombinedVolumeBounds ( )
virtualdefault

Destructor.

Member Function Documentation

◆ boundarySurfaceAccessor()

ObjectAccessor Trk::CombinedVolumeBounds::boundarySurfaceAccessor ( const Amg::Vector3D &  gp,
const Amg::Vector3D &  dir,
bool  forceInside = false 
) const
inlinefinaloverridevirtual

Provide accessor for BoundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 131 of file CombinedVolumeBounds.h.

132  {
133  return Trk::ObjectAccessor(m_objectAccessor);
134 }

◆ boundsOrientation()

const std::vector< bool > & Trk::CombinedVolumeBounds::boundsOrientation ( ) const
inline

This method returns bounds orientation.

Definition at line 136 of file CombinedVolumeBounds.h.

136  {
137  return (m_boundsOrientation);
138 }

◆ clone()

CombinedVolumeBounds * Trk::CombinedVolumeBounds::clone ( ) const
inlinefinaloverridevirtual

Virtual constructor.

Implements Trk::VolumeBounds.

Definition at line 108 of file CombinedVolumeBounds.h.

108  {
109  return new CombinedVolumeBounds(*this);
110 }

◆ createSubtractedVolume()

Trk::Volume * Trk::CombinedVolumeBounds::createSubtractedVolume ( const Amg::Transform3D &  transf,
const Trk::Volume *  subtrVol 
)
staticprivate

Definition at line 341 of file CombinedVolumeBounds.cxx.

344 {
345  if (!subtrVol){
346  return nullptr;
347  }
348  return new Trk::Volume(*subtrVol, transf);
349 }

◆ decomposeToSurfaces()

std::vector< std::unique_ptr< Trk::Surface > > Trk::CombinedVolumeBounds::decomposeToSurfaces ( const Amg::Transform3D &  transform)
finaloverridevirtual

Method to decompose the Bounds into boundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 74 of file CombinedVolumeBounds.cxx.

74  {
75 
76  auto retsf = std::vector<std::unique_ptr<Trk::Surface>>();
77 
78  const Trk::CylinderVolumeBounds* cylVol = dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_first->volumeBounds()));
79  const Trk::SimplePolygonBrepVolumeBounds* spbVol = dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(&(m_first->volumeBounds()));
80  const Trk::CombinedVolumeBounds* comVol = dynamic_cast<const Trk::CombinedVolumeBounds*>(&(m_first->volumeBounds()));
81  const Trk::SubtractedVolumeBounds* subVol = dynamic_cast<const Trk::SubtractedVolumeBounds*>(&(m_first->volumeBounds()));
82 
83  // get surfaces for first boundaries
84  std::vector<std::unique_ptr<Trk::Surface>> firstSurfaces =
85  m_first->volumeBounds().decomposeToSurfaces(transf * m_first->transform());
86  // get surfaces for second boundaries
87  std::vector<std::unique_ptr<Trk::Surface>> secondSurfaces =
88  m_second->volumeBounds().decomposeToSurfaces(transf * m_second->transform());
89  unsigned int nSurf = firstSurfaces.size() + secondSurfaces.size();
90  m_boundsOrientation.resize(nSurf);
91 
92  std::vector<unsigned int> subtrSecond;
93 
94  // loop over surfaces; convert disc surface to a plane surface using elliptic
95  // bounds
96  for (unsigned int out = 0; out < firstSurfaces.size(); out++) {
97  //
98  const SubtractedPlaneSurface* splo = dynamic_cast<const SubtractedPlaneSurface*>(firstSurfaces[out].get());
99  const PlaneSurface* plo = dynamic_cast<const PlaneSurface*>(firstSurfaces[out].get());
100  const SubtractedCylinderSurface* sclo = dynamic_cast<const SubtractedCylinderSurface*>(firstSurfaces[out].get());
101  const CylinderSurface* clo = dynamic_cast<const CylinderSurface*>(firstSurfaces[out].get());
102  const DiscSurface* dlo = dynamic_cast<const DiscSurface*>(firstSurfaces[out].get());
103 
104  // resolve bounds orientation : copy from combined/subtracted, swap inner
105  // cyl, swap bottom spb
106  if (comVol){
107  m_boundsOrientation[out] = comVol->boundsOrientation()[out];
108  }
109  else if (subVol){
110  m_boundsOrientation[out] = subVol->boundsOrientation()[out];
111  }
112  else if (cylVol && clo && out == 3){
113  m_boundsOrientation[out] = false;
114  }
115  else if (spbVol && out == 0){
116  m_boundsOrientation[out] = false;
117  }
118  else{
119  m_boundsOrientation[out] = true;
120  }
121 
122  std::unique_ptr<Trk::Volume> secondSub(createSubtractedVolume(
123  firstSurfaces[out]->transform().inverse() * transf, m_second.get()));
124 
125  if (sclo || splo) {
126  bool shared = false;
127  const Trk::AreaExcluder* vEx;
128  if (splo) {
129  vEx = splo->subtractedVolume();
130  shared = splo->shared();
131  }
132  if (sclo) {
133  vEx = sclo->subtractedVolume();
134  shared = sclo->shared();
135  }
136  const Trk::VolumeExcluder* volExcl = dynamic_cast<const Trk::VolumeExcluder*>(vEx);
137  if (!volExcl){
138  throw std::logic_error("Not a VolumeExcluder");
139  }
140 
141  auto firstSub = std::make_unique<Trk::Volume>(*volExcl->volume());
142 
143  std::unique_ptr<Trk::Volume> comb_sub{};
144  if (!shared && !m_intersection){
145  comb_sub = std::make_unique<Trk::Volume>(
146  nullptr,
147  std::make_shared<Trk::CombinedVolumeBounds>(std::move(secondSub), std::move(firstSub), m_intersection));
148  }
149  if (!shared && m_intersection){
150  comb_sub = std::make_unique<Trk::Volume>(
151  nullptr,
152  std::make_shared<Trk::SubtractedVolumeBounds>(std::move(secondSub), std::move(firstSub)));
153  }
154  if (shared && m_intersection){
155  comb_sub = std::make_unique<Trk::Volume>(
156  nullptr,
157  std::make_shared<Trk::CombinedVolumeBounds>(std::move(secondSub), std::move(firstSub), m_intersection));
158  }
159  if (shared && !m_intersection){
160  comb_sub = std::make_unique<Trk::Volume>(
161  nullptr,
162  std::make_shared<Trk::SubtractedVolumeBounds>(std::move(firstSub), std::move(secondSub)));
163  }
164  auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(comb_sub));
165  bool new_shared = shared;
166  if (m_intersection){
167  new_shared = true;
168  }
169  if (splo){
170  retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*splo, std::move(volEx), new_shared));
171  }
172  else if (sclo){
173  retsf.push_back(std::make_unique<Trk::SubtractedCylinderSurface>(*sclo, std::move(volEx), new_shared));
174  }
175  } else if (plo || clo || dlo) {
176  auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(secondSub));
177  if (plo){
178  retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*plo, std::move(volEx), m_intersection));
179  }
180  else if (clo){
181  retsf.push_back(std::make_unique<Trk::SubtractedCylinderSurface>(*clo, std::move(volEx), m_intersection));
182  }
183  else if (dlo) {
184  const DiscBounds* db = dynamic_cast<const DiscBounds*>(&(dlo->bounds()));
185  if (!db){
186  throw std::logic_error("Not DiscBounds");
187  }
188  auto eb = std::make_shared<EllipseBounds>(db->rMin(), db->rMin(), db->rMax(), db->rMax(), db->halfPhiSector());
189  retsf.push_back( std::make_unique<Trk::SubtractedPlaneSurface>(
190  PlaneSurface(Amg::Transform3D(dlo->transform()), eb),
191  std::move(volEx),
192  m_intersection));
193  }
194  } else {
195  throw std::runtime_error(
196  "Unhandled surface in CombinedVolumeBounds::decomposeToSurfaces.");
197  }
198  }
199 
200  cylVol =
201  dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_second->volumeBounds()));
202  spbVol = dynamic_cast<const Trk::SimplePolygonBrepVolumeBounds*>(
203  &(m_second->volumeBounds()));
204  comVol =
205  dynamic_cast<const Trk::CombinedVolumeBounds*>(&(m_second->volumeBounds()));
206  subVol = dynamic_cast<const Trk::SubtractedVolumeBounds*>(
207  &(m_second->volumeBounds()));
208  unsigned int nOut = firstSurfaces.size();
209 
210  for (unsigned int in = 0; in < secondSurfaces.size(); in++) {
211  //
212  const SubtractedPlaneSurface* spli = dynamic_cast<const SubtractedPlaneSurface*>(secondSurfaces[in].get());
213  const PlaneSurface* pli = dynamic_cast<const PlaneSurface*>(secondSurfaces[in].get());
214  const SubtractedCylinderSurface* scli = dynamic_cast<const SubtractedCylinderSurface*>(secondSurfaces[in].get());
215  const CylinderSurface* cli = dynamic_cast<const CylinderSurface*>(secondSurfaces[in].get());
216  const DiscSurface* dli = dynamic_cast<const DiscSurface*>(secondSurfaces[in].get());
217 
218  // resolve bounds orientation : copy from combined/subtracted, swap inner
219  // cyl, swap bottom spb
220  if (comVol){
221  m_boundsOrientation[nOut + in] = comVol->boundsOrientation()[in];
222  }
223  else if (subVol){
224  m_boundsOrientation[nOut + in] = subVol->boundsOrientation()[in];
225  }
226  else if (cylVol && cli && in == 3){
227  m_boundsOrientation[nOut + in] = false;
228  }
229  else if (spbVol && in == 0){
230  m_boundsOrientation[nOut + in] = false;
231  }
232  else{
233  m_boundsOrientation[nOut + in] = true;
234  }
235 
236  std::unique_ptr<Trk::Volume> firstSub(createSubtractedVolume(
237  secondSurfaces[in]->transform().inverse() * transf, m_first.get()));
238  if (scli || spli) {
239  bool shared = false;
240  const Trk::AreaExcluder* vEx;
241  if (spli) {
242  vEx = spli->subtractedVolume();
243  shared = spli->shared();
244  }
245  if (scli) {
246  vEx = scli->subtractedVolume();
247  shared = scli->shared();
248  }
249  const Trk::VolumeExcluder* volExcl = dynamic_cast<const Trk::VolumeExcluder*>(vEx);
250  if (!volExcl){
251  throw std::logic_error("Not a VolumeExcluder");
252  }
253  auto secondSub = std::make_unique<Trk::Volume>(*volExcl->volume());
254 
255  std::unique_ptr<Trk::Volume> comb_sub{};
256  if (!shared && !m_intersection){
257  comb_sub = std::make_unique<Trk::Volume>(
258  nullptr,
259  std::make_shared<Trk::CombinedVolumeBounds>(std::move(firstSub), std::move(secondSub), m_intersection));
260  }
261  if (!shared && m_intersection){
262  comb_sub = std::make_unique<Trk::Volume>(
263  nullptr,
264  std::make_shared<Trk::SubtractedVolumeBounds>(std::move(firstSub), std::move(secondSub)));
265  }
266  if (shared && m_intersection){
267  comb_sub = std::make_unique<Trk::Volume>(
268  nullptr,
269  std::make_shared<Trk::CombinedVolumeBounds>(std::move(firstSub), std::move(secondSub), m_intersection));
270  }
271  if (shared && !m_intersection){
272  comb_sub = std::make_unique<Trk::Volume>(
273  nullptr,
274  std::make_shared<Trk::SubtractedVolumeBounds>(std::move(secondSub), std::move(firstSub)));
275  }
276  auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(comb_sub));
277  bool new_shared = shared;
278  if (m_intersection){
279  new_shared = true;
280  }
281  if (spli){
282  retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*spli, std::move(volEx), new_shared));
283  }
284  else if (scli)
285  retsf.push_back( std::make_unique<Trk::SubtractedCylinderSurface>(*scli, std::move(volEx), new_shared));
286 
287  } else if (pli || cli || dli) {
288  auto volEx = std::make_shared<const Trk::VolumeExcluder>(std::move(firstSub));
289  if (pli){
290  retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(*pli, std::move(volEx), m_intersection));
291  }
292  else if (cli){
293  retsf.push_back(std::make_unique<Trk::SubtractedCylinderSurface>(*cli, std::move(volEx), m_intersection));
294  }
295  else if (dli) {
296  const DiscBounds* db = dynamic_cast<const DiscBounds*>(&(dli->bounds()));
297  if (!db){
298  throw std::logic_error("Not DiscBounds");
299  }
300  auto eb = std::make_shared<EllipseBounds>(db->rMin(), db->rMin(), db->rMax(), db->rMax(), db->halfPhiSector());
301  auto pliN = PlaneSurface(Amg::Transform3D(dli->transform()), eb);
302  retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(pliN, std::move(volEx), m_intersection));
303  }
304  } else {
305  throw std::runtime_error(
306  "Unhandled surface in CombinedVolumeBounds::decomposeToSurfaces.");
307  }
308  }
309  return retsf;
310 }

◆ dump() [1/2]

MsgStream & Trk::CombinedVolumeBounds::dump ( MsgStream &  sl) const
finaloverridevirtual

Output Method for MsgStream.

Implements Trk::VolumeBounds.

Definition at line 315 of file CombinedVolumeBounds.cxx.

316 {
317  std::stringstream temp_sl;
318  temp_sl << std::setiosflags(std::ios::fixed);
319  temp_sl << std::setprecision(7);
320  temp_sl << "Trk::CombinedVolumeBounds: first,second ";
321  sl << temp_sl.str();
322  std::as_const(*m_first).volumeBounds().dump(sl);
323  std::as_const(*m_second).volumeBounds().dump(sl);
324  return sl;
325 }

◆ dump() [2/2]

std::ostream & Trk::CombinedVolumeBounds::dump ( std::ostream &  sl) const
finaloverridevirtual

Output Method for std::ostream.

Implements Trk::VolumeBounds.

Definition at line 328 of file CombinedVolumeBounds.cxx.

329 {
330  std::stringstream temp_sl;
331  temp_sl << std::setiosflags(std::ios::fixed);
332  temp_sl << std::setprecision(7);
333  temp_sl << "Trk::CombinedVolumeBounds: first,second ";
334  sl << temp_sl.str();
335  std::as_const(*m_first).volumeBounds().dump(sl);
336  std::as_const(*m_second).volumeBounds().dump(sl);
337  return sl;
338 }

◆ first()

const Volume * Trk::CombinedVolumeBounds::first ( ) const
inline

This method returns the first VolumeBounds.

Definition at line 119 of file CombinedVolumeBounds.h.

119  {
120  return m_first.get();
121 }

◆ inside()

bool Trk::CombinedVolumeBounds::inside ( const Amg::Vector3D &  pos,
double  tol = 0. 
) const
inlinefinaloverridevirtual

This method checks if position in the 3D volume frame is inside the volume.

Implements Trk::VolumeBounds.

Definition at line 112 of file CombinedVolumeBounds.h.

112  {
113  if (m_intersection) {
114  return (m_first->inside(pos, tol) && m_second->inside(pos, tol));
115  }
116  return (m_first->inside(pos, tol) || m_second->inside(pos, tol));
117 }

◆ intersection()

bool Trk::CombinedVolumeBounds::intersection ( ) const
inline

This method distinguishes between Union(0) and Intersection(1)

Definition at line 127 of file CombinedVolumeBounds.h.

127  {
128  return m_intersection;
129 }

◆ operator=()

Trk::CombinedVolumeBounds & Trk::CombinedVolumeBounds::operator= ( const CombinedVolumeBounds &  bobo)

Assignment operator.

Definition at line 61 of file CombinedVolumeBounds.cxx.

62 {
63  if (this != &bobo) {
64  m_first.reset(bobo.m_first->clone());
65  m_second.reset(bobo.m_second->clone());
66  m_intersection = bobo.m_intersection;
67  m_objectAccessor = bobo.m_objectAccessor;
68  m_boundsOrientation = bobo.m_boundsOrientation;
69  }
70  return *this;
71 }

◆ second()

const Volume * Trk::CombinedVolumeBounds::second ( ) const
inline

This method returns the second VolumeBounds.

Definition at line 123 of file CombinedVolumeBounds.h.

123  {
124  return m_second.get();
125 }

Member Data Documentation

◆ m_boundsOrientation

std::vector<bool> Trk::CombinedVolumeBounds::m_boundsOrientation {}
private

Definition at line 105 of file CombinedVolumeBounds.h.

◆ m_first

std::unique_ptr<Volume> Trk::CombinedVolumeBounds::m_first {}
private

Definition at line 101 of file CombinedVolumeBounds.h.

◆ m_intersection

bool Trk::CombinedVolumeBounds::m_intersection {}
private

Definition at line 103 of file CombinedVolumeBounds.h.

◆ m_objectAccessor

EightObjectsAccessor Trk::CombinedVolumeBounds::m_objectAccessor {}
private

Definition at line 104 of file CombinedVolumeBounds.h.

◆ m_second

std::unique_ptr<Volume> Trk::CombinedVolumeBounds::m_second {}
private

Definition at line 102 of file CombinedVolumeBounds.h.

The documentation for this class was generated from the following files:
Trk::CombinedVolumeBounds::intersection
bool intersection() const
This method distinguishes between Union(0) and Intersection(1)
Definition: CombinedVolumeBounds.h:127
Trk::CombinedVolumeBounds::createSubtractedVolume
static Trk::Volume * createSubtractedVolume(const Amg::Transform3D &transf, const Trk::Volume *subtrVol)
Definition: CombinedVolumeBounds.cxx:341
Trk::SubtractedVolumeBounds::boundsOrientation
const std::vector< bool > & boundsOrientation() const
This method returns bounds orientation.
Definition: SubtractedVolumeBounds.h:122
Trk::CombinedVolumeBounds::m_boundsOrientation
std::vector< bool > m_boundsOrientation
Definition: CombinedVolumeBounds.h:105
Trk::SimplePolygonBrepVolumeBounds
Definition: SimplePolygonBrepVolumeBounds.h:44
CaloCondBlobAlgs_fillNoiseFromASCII.db
db
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:42
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
Trk::CombinedVolumeBounds::m_intersection
bool m_intersection
Definition: CombinedVolumeBounds.h:103
Trk::CombinedVolumeBounds::boundsOrientation
const std::vector< bool > & boundsOrientation() const
This method returns bounds orientation.
Definition: CombinedVolumeBounds.h:136
Trk::CombinedVolumeBounds::m_second
std::unique_ptr< Volume > m_second
Definition: CombinedVolumeBounds.h:102
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
Trk::AreaExcluder
Definition: AreaExcluder.h:26
Trk::CombinedVolumeBounds::m_objectAccessor
EightObjectsAccessor m_objectAccessor
Definition: CombinedVolumeBounds.h:104
Trk::CombinedVolumeBounds::CombinedVolumeBounds
CombinedVolumeBounds()
Default Constructor.
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
Trk::VolumeExcluder::volume
const Volume * volume() const
Acces the subtracted volume.
Definition: VolumeExcluder.h:68
Trk::ObjectAccessor
Definition: ObjectAccessor.h:15
Trk::SubtractedVolumeBounds
Definition: SubtractedVolumeBounds.h:40
Trk::VolumeExcluder
Definition: VolumeExcluder.h:30
Trk::CombinedVolumeBounds::m_first
std::unique_ptr< Volume > m_first
Definition: CombinedVolumeBounds.h:101
Trk::CombinedVolumeBounds
Definition: CombinedVolumeBounds.h:44
Trk::Volume
Definition: Volume.h:36
Trk::VolumeBounds::VolumeBounds
VolumeBounds()
Default Constructor.
Definition: VolumeBounds.h:49
Generated on Sat Oct 25 2025 22:04:26 for ATLAS Offline Software by   doxygen 1.8.18