ATLAS Offline Software
SimplePolygonBrepVolumeBounds.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // SimplePolygonBrepVolumeBounds.cxx, (c) ATLAS Detector software
8 
9 // Trk
10 #include "TrkVolumes/SimplePolygonBrepVolumeBounds.h"
11 #include "TrkVolumes/CombinedVolumeBounds.h"
12 #include "TrkVolumes/CuboidVolumeBounds.h"
13 #include "TrkVolumes/PrismVolumeBounds.h"
14 #include "TrkVolumes/Volume.h"
15 #include "TrkVolumes/VolumeExcluder.h"
16 // TrkSurfaces
17 #include "TrkGeometrySurfaces/SubtractedPlaneSurface.h"
18 #include "TrkSurfaces/PlaneSurface.h"
19 #include "TrkSurfaces/RectangleBounds.h"
20 // Gaudi
21 #include "GaudiKernel/MsgStream.h"
22 #include "GaudiKernel/SystemOfUnits.h"
23 // STD
24 #include <cmath>
25 #include <iomanip>
26 #include <iostream>
27 
28 Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds()
29  : VolumeBounds()
30  , m_halfX(0.)
31  , m_halfY(0.)
32  , m_halfZ(0.)
33  , m_ordering(-1)
34  , m_combinedVolume(nullptr)
35  , m_envelope(nullptr)
36  , m_objectAccessor()
37 {
38  //@TODO an object created by the default constructor cannot be copied or
39  //assigned.
40 }
41 
42 Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds(
43  std::vector<std::pair<float, float>> xyVtx,
44  float halez)
45  : VolumeBounds()
46  , m_halfX(0.)
47  , m_halfY(0.)
48  , m_halfZ(halez)
49  , m_ordering(-1)
50  , m_combinedVolume(nullptr)
51  , m_envelope(nullptr)
52  , m_objectAccessor()
53 {
54  m_xyVtx.resize(xyVtx.size());
55  double xmin = xyVtx[0].first;
56  double xmax = xmin;
57  double ymin = xyVtx[0].second;
58  double ymax = ymin;
59  for (unsigned int i = 0; i < xyVtx.size(); i++) {
60  m_xyVtx[i] = xyVtx[i];
61  if (xyVtx[i].first < xmin)
62  xmin = xyVtx[i].first;
63  if (xyVtx[i].first > xmax)
64  xmax = xyVtx[i].first;
65  if (xyVtx[i].second < ymin)
66  ymin = xyVtx[i].second;
67  if (xyVtx[i].second > ymax)
68  ymax = xyVtx[i].second;
69  }
70  double ehalfX = 0.5 * (xmax - xmin);
71  double ehalfY = 0.5 * (ymax - ymin);
72  m_halfX = fmax(std::abs(xmax), fabs(xmin));
73  m_halfY = fmax(std::abs(ymax), fabs(ymin));
74  Amg::Transform3D transXY(
75  Amg::Translation3D(Amg::Vector3D(0.5 * (xmin + xmax), 0., 0.)) *
76  Amg::Translation3D(Amg::Vector3D(0., 0.5 * (ymin + ymax), 0.)));
77  m_envelope = new Trk::Volume(
78  new Amg::Transform3D(transXY),
79  new Trk::CuboidVolumeBounds(ehalfX, ehalfY, m_halfZ));
80 
81  processSubVols();
82 }
83 
84 Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds(
85  std::vector<std::pair<double, double>> xyVtx,
86  double halez)
87  : VolumeBounds()
88  , m_halfX(0.)
89  , m_halfY(0.)
90  , m_halfZ(halez)
91  , m_ordering(-1)
92  , m_combinedVolume(nullptr)
93  , m_envelope(nullptr)
94  , m_objectAccessor()
95 {
96  m_xyVtx.resize(xyVtx.size());
97  double xmin = xyVtx[0].first;
98  double xmax = xmin;
99  double ymin = xyVtx[0].second;
100  double ymax = ymin;
101  for (unsigned int i = 0; i < xyVtx.size(); i++) {
102  m_xyVtx[i] = xyVtx[i];
103  if (xyVtx[i].first < xmin)
104  xmin = xyVtx[i].first;
105  if (xyVtx[i].first > xmax)
106  xmax = xyVtx[i].first;
107  if (xyVtx[i].second < ymin)
108  ymin = xyVtx[i].second;
109  if (xyVtx[i].second > ymax)
110  ymax = xyVtx[i].second;
111  }
112  double ehalfX = 0.5 * (xmax - xmin);
113  double ehalfY = 0.5 * (ymax - ymin);
114  m_halfX = fmax(std::abs(xmax), fabs(xmin));
115  m_halfY = fmax(std::abs(ymax), fabs(ymin));
116  Amg::Transform3D transXY(
117  Amg::Translation3D(Amg::Vector3D(0.5 * (xmin + xmax), 0., 0.)) *
118  Amg::Translation3D(Amg::Vector3D(0., 0.5 * (ymin + ymax), 0.)));
119  m_envelope = new Trk::Volume(
120  new Amg::Transform3D(transXY),
121  new Trk::CuboidVolumeBounds(ehalfX, ehalfY, m_halfZ));
122 
123  processSubVols();
124 }
125 
126 Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds(
127  const Trk::SimplePolygonBrepVolumeBounds& trabo)
128  : VolumeBounds()
129  , m_halfX(trabo.m_halfX)
130  , m_halfY(trabo.m_halfY)
131  , m_halfZ(trabo.m_halfZ)
132  , m_ordering(trabo.m_ordering)
133  , m_combinedVolume(trabo.m_combinedVolume->clone())
134  , m_envelope(trabo.m_envelope->clone())
135  , m_objectAccessor(trabo.m_objectAccessor)
136 {
137  m_xyVtx.resize(trabo.m_xyVtx.size());
138  for (unsigned int i = 0; i < m_xyVtx.size(); i++)
139  m_xyVtx[i] = trabo.m_xyVtx[i];
140 }
141 
142 Trk::SimplePolygonBrepVolumeBounds::~SimplePolygonBrepVolumeBounds()
143 {
144  delete m_combinedVolume;
145  delete m_envelope;
146 }
147 
148 Trk::SimplePolygonBrepVolumeBounds&
149 Trk::SimplePolygonBrepVolumeBounds::operator=(
150  const Trk::SimplePolygonBrepVolumeBounds& trabo)
151 {
152  if (this != &trabo) {
153  m_halfX = trabo.m_halfX;
154  m_halfY = trabo.m_halfY;
155  m_halfZ = trabo.m_halfZ;
156  m_objectAccessor = trabo.m_objectAccessor;
157  m_xyVtx.resize(trabo.m_xyVtx.size());
158  for (unsigned int i = 0; i < m_xyVtx.size(); i++)
159  m_xyVtx[i] = trabo.m_xyVtx[i];
160  delete m_combinedVolume;
161  delete m_envelope;
162  m_combinedVolume = trabo.m_combinedVolume->clone();
163  m_envelope = trabo.m_envelope->clone();
164  m_ordering = trabo.m_ordering;
165  }
166  return *this;
167 }
168 
169 const std::vector<const Trk::Surface*>*
170  Trk::SimplePolygonBrepVolumeBounds::decomposeToSurfaces
171  (const Amg::Transform3D& transform)
172 {
173  std::vector<const Trk::Surface*>* retsf =
174  new std::vector<const Trk::Surface*>;
175 
176  // face surfaces xy
177  // (1) - at negative local z
178  Trk::PlaneSurface xymPlane(
179  Amg::Transform3D(
180  transform * Amg::Translation3D(Amg::Vector3D(0., 0., -m_halfZ))),
181  new Trk::RectangleBounds(m_halfX, m_halfY));
182  Trk::VolumeExcluder* volExcl = new Trk::VolumeExcluder(new Trk::Volume(
183  *m_combinedVolume,
184  Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -m_halfZ)))));
185  retsf->push_back(new Trk::SubtractedPlaneSurface(xymPlane, volExcl, true));
186  // (2) - at positive local z
187  Trk::PlaneSurface xyPlane(
188  Amg::Transform3D(
189  transform * Amg::Translation3D(Amg::Vector3D(0., 0., m_halfZ))),
190  new Trk::RectangleBounds(m_halfX, m_halfY));
191  volExcl = new Trk::VolumeExcluder(new Trk::Volume(
192  *m_combinedVolume,
193  Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., m_halfZ)))));
194  retsf->push_back(new Trk::SubtractedPlaneSurface(xyPlane, volExcl, true));
195  // loop over xy vertices
196  // (3)
197  for (unsigned int iv = 0; iv < m_xyVtx.size(); iv++) {
198  if (iv != m_xyVtx.size() - 1)
199  retsf->push_back(sideSurf(transform, iv, iv + 1));
200  else
201  retsf->push_back(sideSurf(transform, iv, 0));
202  }
203 
204  return retsf;
205 }
206 
207 // faces in xy
208 Trk::PlaneSurface*
209 Trk::SimplePolygonBrepVolumeBounds::sideSurf(
210  const Amg::Transform3D& transform,
211  unsigned int iv1,
212  unsigned int iv2) const
213 {
214  Trk::PlaneSurface* plane = nullptr;
215 
216  double xdif = m_xyVtx[iv2].first - m_xyVtx[iv1].first;
217  double ydif = m_xyVtx[iv2].second - m_xyVtx[iv1].second;
218  double xsize = sqrt(xdif * xdif + ydif * ydif);
219 
220  double ori = m_ordering > 0 ? -1. : 1.;
221 
222  Amg::Vector3D pos(
223  0.5 * (m_xyVtx[iv1].first + m_xyVtx[iv2].first),
224  0.5 * (m_xyVtx[iv1].second + m_xyVtx[iv2].second),
225  0.);
226  double phi = ori * ydif < 0 ? M_PI / 2 : -M_PI / 2;
227  if (ori > 0 && ydif > 0)
228  phi = M_PI / 2;
229  if (std::abs(xdif) > 1e-6) {
230  phi = std::atan(ydif / xdif);
231  if (xdif < 0)
232  phi += M_PI;
233  }
234 
235  Amg::Transform3D tr(
236  transform * Amg::Translation3D(pos) *
237  Amg::AngleAxis3D(phi, Amg::Vector3D(0., 0., 1.)) *
238  Amg::AngleAxis3D(-ori * 90 * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.)));
239  plane =
240  new Trk::PlaneSurface(tr, new Trk::RectangleBounds(0.5 * xsize, m_halfZ));
241 
242  // verify position of vertices - uncomment for debugging
243  // if
244  // (!plane->isOnSurface(Trk::GlobalPosition(m_xyVtx[iv1].first,m_xyVtx[iv1].second,m_halfZ),true,0.001,0.001)
245  // ||
246  // !plane->isOnSurface(Trk::GlobalPosition(m_xyVtx[iv2].first,m_xyVtx[iv2].second,-m_halfZ),true,0.001,0.001)
247  // )
248  // std::cout << "ERROR in SIMPLEPGONBREP side boundary:vertices out of
249  // plane"<< std::endl;
250 
251  return plane;
252 }
253 
254 bool
255 Trk::SimplePolygonBrepVolumeBounds::inside(const Amg::Vector3D& pos, double tol)
256  const
257 {
258  return (m_combinedVolume->inside(pos, tol));
259 }
260 
261 void
262 Trk::SimplePolygonBrepVolumeBounds::processSubVols()
263 {
264  // translate into prisms (triangulate)
265  Trk::Volume* cVol = nullptr;
266 #ifdef TRKDETDESCR_USEFLOATPRECISON
267 #define double float
268 #endif
269  std::vector<std::pair<double, double>> triangles = TriangulatePolygonCheck(
270  m_xyVtx); //@TODO change argument to const vector<pair< > >
271  std::vector<std::pair<double, double>> vertices;
272 #ifdef TRKDETDESCR_USEFLOATPRECISON
273 #undef double
274 #endif
275  for (unsigned int i = 0; i < triangles.size(); i = i + 3) {
276  vertices.push_back(triangles[i]);
277  vertices.push_back(triangles[i + 1]);
278  vertices.push_back(triangles[i + 2]);
279  Trk::Volume* newVol =
280  new Trk::Volume(nullptr, new Trk::PrismVolumeBounds(vertices, m_halfZ));
281  if (cVol)
282  cVol = new Trk::Volume(
283  nullptr, new Trk::CombinedVolumeBounds(cVol, newVol, false));
284  else
285  cVol = newVol;
286  vertices.clear();
287  }
288  m_combinedVolume = cVol;
289 }
290 
291 // ostream operator overload
292 MsgStream&
293 Trk::SimplePolygonBrepVolumeBounds::dump(MsgStream& sl) const
294 {
295  std::stringstream temp_sl;
296  temp_sl << std::setiosflags(std::ios::fixed);
297  temp_sl << std::setprecision(7);
298  temp_sl << "Trk::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
299  temp_sl << "( " << m_halfZ << ")";
300  for (const auto & xyVtx : m_xyVtx)
301  temp_sl << "(" << xyVtx.first << "," << xyVtx.second << ")";
302  sl << temp_sl.str();
303  return sl;
304 }
305 
306 std::ostream&
307 Trk::SimplePolygonBrepVolumeBounds::dump(std::ostream& sl) const
308 {
309  std::stringstream temp_sl;
310  temp_sl << std::setiosflags(std::ios::fixed);
311  temp_sl << std::setprecision(7);
312  temp_sl << "Trk::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
313  temp_sl << "( " << m_halfZ << ")";
314  for (const auto & myVtx : m_xyVtx)
315  temp_sl << "(" << myVtx.first << "," << myVtx.second << ")";
316  sl << temp_sl.str();
317  return sl;
318 }
319 
321 // Triangulate Polygon
322 // M. Wolter
324 
325 bool
326 Trk::SimplePolygonBrepVolumeBounds::Xor(bool x, bool y)
327 // XOR: Arguments are negated to ensure that they are 0/1. Then the bitwise Xor
328 // operator may apply.
329 {
330  return !x ^ !y;
331 }
332 
333 #ifdef TRKDETDESCR_USEFLOATPRECISON
334 #define double float
335 #endif
336 
337 bool
338 Trk::SimplePolygonBrepVolumeBounds::Left(
339  std::pair<double, double> a,
340  std::pair<double, double> b,
341  std::pair<double, double> c) const
342 // Returns true iff c is strictly to the left of the directed line through a to
343 // b.
344 {
345  double CrossZ = (b.first - a.first) * (c.second - a.second) -
346  (c.first - a.first) * (b.second - a.second);
347  if (m_ordering == 1)
348  return (CrossZ >= 0.);
349  if (m_ordering == 0)
350  return (CrossZ < 0.);
351  return false;
352 }
353 
354 bool
355 Trk::SimplePolygonBrepVolumeBounds::Intersect(
356  std::pair<double, double> a,
357  std::pair<double, double> b,
358  std::pair<double, double> c,
359  std::pair<double, double> d) const
360 // Returns true iff segments ab and cd intersect
361 {
362 
363  return Xor(Left(a, b, c), Left(a, b, d)) && Xor(Left(c, d, a), Left(c, d, b));
364 }
365 
366 bool
367 Trk::SimplePolygonBrepVolumeBounds::InCone(
368  int i,
369  int j,
370  const std::vector<std::pair<double, double>>& inputVertices) const
371 // Returns true iff the diagonal (i,j) is internal to the polygon in
372 // the neighborhood of the i endpoint.
373 {
374  int iPlus1 = (i + 1) % inputVertices.size();
375  int iMinus1 = (i + inputVertices.size() - 1) % inputVertices.size();
376 
377  /* If P[i] is a convex vertex [ i+1 left or on (i-1,i) ]. */
378  if (Left(inputVertices[iMinus1], inputVertices[i], inputVertices[iPlus1]))
379  return Left(inputVertices[i], inputVertices[j], inputVertices[iMinus1]) &&
380  Left(inputVertices[j], inputVertices[i], inputVertices[iPlus1]);
381 
382  /* Assume (i-1,i,i+1) not collinear. */
383  /* else v_i is reflex. */
384  else
385  return !(
386  Left(inputVertices[i], inputVertices[j], inputVertices[iPlus1]) &&
387  Left(inputVertices[j], inputVertices[i], inputVertices[iMinus1]));
388 }
389 
390 bool
391 Trk::SimplePolygonBrepVolumeBounds::Diagonalie(
392  int i,
393  int j,
394  const std::vector<std::pair<double, double>>& inputVertices) const
395 {
396  // Returns TRUE iff (v_i, v_j) is a proper internal *or* external diagonal of
397  // this polygon, *ignoring edges incident to v_i and v_j*.
398 
399  /* For each edge (k,k+1) of P */
400  for (int k = 0; k < (int)inputVertices.size(); k++) {
401 
402  int kPlus1 = (k + 1) % inputVertices.size();
403 
404  /* Skip edges incident to i or j */
405  if ((k != i) && (kPlus1 != i) && (k != j) && (kPlus1 != j))
406  if (Intersect(
407  inputVertices[i],
408  inputVertices[j],
409  inputVertices[k],
410  inputVertices[kPlus1]))
411  return false;
412  }
413  return true;
414 }
415 
416 bool
417 Trk::SimplePolygonBrepVolumeBounds::Diagonal(
418  int i,
419  int j,
420  const std::vector<std::pair<double, double>>& inputVertices) const
421 // Returns TRUE iff (v_i, v_j) is a proper internal diagonal of P.
422 {
423  // std::cout<<"MW Diagonal "<<i<<" "<<j<<" "<<InCone(i,j, inputVertices)<<"
424  // "<<Diagonalie(i,j, inputVertices)<<std::endl;
425  return InCone(i, j, inputVertices) && Diagonalie(i, j, inputVertices);
426 }
427 
428 std::vector<std::pair<double, double>>
429 Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygon(
430  const std::vector<std::pair<double, double>>& Vertices) const
431 {
432  // Subtracting ears method
433  //
434  // One way to triangulate a simple polygon is by using the assertion that any
435  // simple polygon without holes
436  // has at least two so called 'ears'. An ear is a triangle with two sides on
437  // the edge of the polygon and the other one completely inside it. The
438  // algorithm then consists of finding such an ear, removing it from the
439  // polygon (which results in a new polygon that still meets the conditions)
440  // and repeating until there is only one triangle left.
441  //
442 
443  int NSize = Vertices.size();
444  std::vector<std::pair<double, double>> outTriangles;
445  std::vector<std::pair<double, double>> inputVertices;
446  inputVertices.reserve(NSize);
447  for (int i = 0; i < NSize; i++)
448  inputVertices.push_back((Vertices)[i]);
449 
450  // for (int i; i<NSize;i++) std::cout<<"MW input vertices:
451  // "<<inputVertices[i].first<<" "<<inputVertices[i].second<<std::endl;
452  // Triangulates this polygon and saves triangle edges in TriPoly.
453  // Triangles are stored CCW, with each set of 3 consecutive points in TriPoly
454  // representing 1 triangle.
455  // Assumes this polygon is closed.
456 
457  if (NSize < 4)
458  return inputVertices;
459 
460  // Start triangulating
461  int VerticesLeft = NSize;
462  while (VerticesLeft > 3) {
463  // std::cout<<"MW vertices left "<<VerticesLeft<<std::endl;
464  bool bCornerCut = false;
465  for (int i = 0; i < VerticesLeft; i++) {
466 
467  int iPlus1 = i + 1;
468  if (iPlus1 == VerticesLeft)
469  iPlus1 = 0;
470  int iPlus2 = (iPlus1 + 1);
471  if (iPlus2 == VerticesLeft)
472  iPlus2 = 0;
473 
474  if (Diagonal(i, iPlus2, inputVertices)) {
475 
476  outTriangles.push_back(inputVertices[i]);
477  outTriangles.push_back(inputVertices[iPlus1]);
478  outTriangles.push_back(inputVertices[iPlus2]);
479 
480  inputVertices.erase(inputVertices.begin() + iPlus1);
481  VerticesLeft--;
482  bCornerCut = true;
483  break;
484  }
485  }
486  if (!bCornerCut) { // Error - bad poly
487  // std::cout<<"MW Error - bad poly"<<std::endl;
488  std::vector<std::pair<double, double>> out;
489  return out;
490  }
491  }
492 
493  if (VerticesLeft == 3) {
494  outTriangles.push_back(inputVertices[0]);
495  outTriangles.push_back(inputVertices[1]);
496  outTriangles.push_back(inputVertices[2]);
497  inputVertices.erase(inputVertices.begin() + 1);
498  VerticesLeft--;
499  }
500 
501  return outTriangles;
502 }
503 
504 std::vector<std::pair<double, double>>
505 Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygonCheck(
506  const std::vector<std::pair<double, double>>& Vertices)
507 {
508  // Perform triangulation. Check the orientation of the verices in the polygon
509  // m_ordering = -1 not set
510  // m_ordering = 1 anticlockwise
511  // m_ordering = 0 clockwise
512 
513  if (m_ordering == -1)
514  m_ordering = 1;
515  std::vector<std::pair<double, double>> outTriangles =
516  TriangulatePolygon(Vertices);
517  if (outTriangles.empty()) {
518  m_ordering = -m_ordering + 1;
519  outTriangles = TriangulatePolygon(Vertices);
520  }
521 
522  return outTriangles;
523 }
524 #ifdef TRKDETDESCR_USEFLOATPRECISON
525 #undef double
526 #endif
527 
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
Trk::y
@ y
Definition: ParamDefs.h:56
Trk::RectangleBounds
Definition: RectangleBounds.h:38
python.SystemOfUnits.second
int second
Definition: SystemOfUnits.py:120
ymin
double ymin
Definition: listroot.cxx:63
Trk::SimplePolygonBrepVolumeBounds::operator=
SimplePolygonBrepVolumeBounds & operator=(const SimplePolygonBrepVolumeBounds &bobo)
Assignment operator.
Definition: SimplePolygonBrepVolumeBounds.cxx:149
RectangleBounds.h
Trk::SimplePolygonBrepVolumeBounds
Definition: SimplePolygonBrepVolumeBounds.h:44
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
Trk::SimplePolygonBrepVolumeBounds::m_ordering
int m_ordering
-1 not set/ 1 anticlockwise / 0 clockwise
Definition: SimplePolygonBrepVolumeBounds.h:133
Trk::CuboidVolumeBounds
Definition: CuboidVolumeBounds.h:52
hist_file_dump.d
d
Definition: hist_file_dump.py:137
Trk::SimplePolygonBrepVolumeBounds::Intersect
bool Intersect(std::pair< double, double > a, std::pair< double, double > b, std::pair< double, double > c, std::pair< double, double > d) const
Definition: SimplePolygonBrepVolumeBounds.cxx:355
Trk::SimplePolygonBrepVolumeBounds::InCone
bool InCone(int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const
Definition: SimplePolygonBrepVolumeBounds.cxx:367
Trk::SimplePolygonBrepVolumeBounds::Diagonal
bool Diagonal(int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const
Definition: SimplePolygonBrepVolumeBounds.cxx:417
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
Trk::SimplePolygonBrepVolumeBounds::m_halfX
double m_halfX
halflength in x - to define enclosing rectangle
Definition: SimplePolygonBrepVolumeBounds.h:129
M_PI
#define M_PI
Definition: ActiveFraction.h:11
deg
#define deg
Definition: SbPolyhedron.cxx:17
Trk::SimplePolygonBrepVolumeBounds::Xor
static bool Xor(bool x, bool y)
Definition: SimplePolygonBrepVolumeBounds.cxx:326
Trk::SimplePolygonBrepVolumeBounds::m_objectAccessor
Trk::EightObjectsAccessor m_objectAccessor
There's only one single object Acessor for the moment has to be implemented if Cuboids are used more ...
Definition: SimplePolygonBrepVolumeBounds.h:139
python.Utilities.clone
clone
Definition: Utilities.py:134
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygon
std::vector< std::pair< double, double > > TriangulatePolygon(const std::vector< std::pair< double, double > > &Vertices) const
Definition: SimplePolygonBrepVolumeBounds.cxx:429
Trk::SimplePolygonBrepVolumeBounds::sideSurf
Trk::PlaneSurface * sideSurf(const Amg::Transform3D &, unsigned int, unsigned int) const
Definition: SimplePolygonBrepVolumeBounds.cxx:209
PrismVolumeBounds.h
VolumeExcluder.h
Trk::VolumeBounds
Definition: VolumeBounds.h:45
Volume.h
Trk::SimplePolygonBrepVolumeBounds::inside
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.
Definition: SimplePolygonBrepVolumeBounds.cxx:255
SubtractedPlaneSurface.h
Trk::SubtractedPlaneSurface
Definition: SubtractedPlaneSurface.h:32
lumiFormat.i
int i
Definition: lumiFormat.py:85
xmin
double xmin
Definition: listroot.cxx:60
Trk::SimplePolygonBrepVolumeBounds::Diagonalie
bool Diagonalie(int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const
Definition: SimplePolygonBrepVolumeBounds.cxx:391
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::SimplePolygonBrepVolumeBounds::dump
MsgStream & dump(MsgStream &sl) const override
Output Method for MsgStream.
Definition: SimplePolygonBrepVolumeBounds.cxx:293
Trk::Volume::clone
virtual Volume * clone() const
Pseudo-constructor.
Definition: Volume.cxx:78
Trk::SimplePolygonBrepVolumeBounds::decomposeToSurfaces
const std::vector< const Trk::Surface * > * decomposeToSurfaces(const Amg::Transform3D &transform) override final
Method to decompose the Bounds into Surfaces.
Definition: SimplePolygonBrepVolumeBounds.cxx:171
Trk::PrismVolumeBounds
Definition: PrismVolumeBounds.h:44
Trk::SimplePolygonBrepVolumeBounds::m_combinedVolume
const Trk::Volume * m_combinedVolume
triangulated polygon
Definition: SimplePolygonBrepVolumeBounds.h:134
Trk::SimplePolygonBrepVolumeBounds::m_xyVtx
std::vector< std::pair< double, double > > m_xyVtx
generating xy vertices
Definition: SimplePolygonBrepVolumeBounds.h:128
SimplePolygonBrepVolumeBounds.h
Trk::SimplePolygonBrepVolumeBounds::m_halfZ
double m_halfZ
halflength in z
Definition: SimplePolygonBrepVolumeBounds.h:131
Trk::SimplePolygonBrepVolumeBounds::~SimplePolygonBrepVolumeBounds
virtual ~SimplePolygonBrepVolumeBounds()
Destructor.
Definition: SimplePolygonBrepVolumeBounds.cxx:142
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds
SimplePolygonBrepVolumeBounds()
Default Constructor.
Definition: SimplePolygonBrepVolumeBounds.cxx:28
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
a
TList * a
Definition: liststreamerinfos.cxx:10
Trk::PlaneSurface
Definition: PlaneSurface.h:64
PlaneSurface.h
Trk::SimplePolygonBrepVolumeBounds::m_halfY
double m_halfY
halflength in y - to define enclosing rectangle
Definition: SimplePolygonBrepVolumeBounds.h:130
DeMoScan.first
bool first
Definition: DeMoScan.py:536
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygonCheck
std::vector< std::pair< double, double > > TriangulatePolygonCheck(const std::vector< std::pair< double, double > > &Vertices)
Definition: SimplePolygonBrepVolumeBounds.cxx:505
xmax
double xmax
Definition: listroot.cxx:61
Trk::SimplePolygonBrepVolumeBounds::processSubVols
void processSubVols()
Definition: SimplePolygonBrepVolumeBounds.cxx:262
CombinedVolumeBounds.h
Amg::AngleAxis3D
Eigen::AngleAxisd AngleAxis3D
Definition: GeoPrimitives.h:45
Trk::VolumeExcluder
Definition: VolumeExcluder.h:29
Trk::phi
@ phi
Definition: ParamDefs.h:75
Trk::SimplePolygonBrepVolumeBounds::Left
bool Left(std::pair< double, double > a, std::pair< double, double > b, std::pair< double, double > c) const
Definition: SimplePolygonBrepVolumeBounds.cxx:338
Trk::x
@ x
Definition: ParamDefs.h:55
Trk::CombinedVolumeBounds
Definition: CombinedVolumeBounds.h:42
Trk::Volume
Definition: Volume.h:35
python.compressB64.c
def c
Definition: compressB64.py:93
NSWL1::Vertices
std::vector< Vertex > Vertices
Definition: GeoUtils.h:19
CuboidVolumeBounds.h
fitman.k
k
Definition: fitman.py:528
ymax
double ymax
Definition: listroot.cxx:64
Trk::SimplePolygonBrepVolumeBounds::m_envelope
const Trk::Volume * m_envelope
simplified envelope
Definition: SimplePolygonBrepVolumeBounds.h:135
Generated on Thu Nov 7 2024 21:26:09 for ATLAS Offline Software by   doxygen 1.8.18