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  }
165  return *this;
166 }
167 
168 const std::vector<const Trk::Surface*>*
169  Trk::SimplePolygonBrepVolumeBounds::decomposeToSurfaces
170  (const Amg::Transform3D& transform)
171 {
172  std::vector<const Trk::Surface*>* retsf =
173  new std::vector<const Trk::Surface*>;
174 
175  // face surfaces xy
176  // (1) - at negative local z
177  Trk::PlaneSurface xymPlane(
178  Amg::Transform3D(
179  transform * Amg::Translation3D(Amg::Vector3D(0., 0., -m_halfZ))),
180  new Trk::RectangleBounds(m_halfX, m_halfY));
181  Trk::VolumeExcluder* volExcl = new Trk::VolumeExcluder(new Trk::Volume(
182  *m_combinedVolume,
183  Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -m_halfZ)))));
184  retsf->push_back(new Trk::SubtractedPlaneSurface(xymPlane, volExcl, true));
185  // (2) - at positive local z
186  Trk::PlaneSurface xyPlane(
187  Amg::Transform3D(
188  transform * Amg::Translation3D(Amg::Vector3D(0., 0., m_halfZ))),
189  new Trk::RectangleBounds(m_halfX, m_halfY));
190  volExcl = new Trk::VolumeExcluder(new Trk::Volume(
191  *m_combinedVolume,
192  Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., m_halfZ)))));
193  retsf->push_back(new Trk::SubtractedPlaneSurface(xyPlane, volExcl, true));
194  // loop over xy vertices
195  // (3)
196  for (unsigned int iv = 0; iv < m_xyVtx.size(); iv++) {
197  if (iv != m_xyVtx.size() - 1)
198  retsf->push_back(sideSurf(transform, iv, iv + 1));
199  else
200  retsf->push_back(sideSurf(transform, iv, 0));
201  }
202 
203  return retsf;
204 }
205 
206 // faces in xy
207 Trk::PlaneSurface*
208 Trk::SimplePolygonBrepVolumeBounds::sideSurf(
209  const Amg::Transform3D& transform,
210  unsigned int iv1,
211  unsigned int iv2) const
212 {
213  Trk::PlaneSurface* plane = nullptr;
214 
215  double xdif = m_xyVtx[iv2].first - m_xyVtx[iv1].first;
216  double ydif = m_xyVtx[iv2].second - m_xyVtx[iv1].second;
217  double xsize = sqrt(xdif * xdif + ydif * ydif);
218 
219  double ori = m_ordering > 0 ? -1. : 1.;
220 
221  Amg::Vector3D pos(
222  0.5 * (m_xyVtx[iv1].first + m_xyVtx[iv2].first),
223  0.5 * (m_xyVtx[iv1].second + m_xyVtx[iv2].second),
224  0.);
225  double phi = ori * ydif < 0 ? M_PI / 2 : -M_PI / 2;
226  if (ori > 0 && ydif > 0)
227  phi = M_PI / 2;
228  if (std::abs(xdif) > 1e-6) {
229  phi = std::atan(ydif / xdif);
230  if (xdif < 0)
231  phi += M_PI;
232  }
233 
234  Amg::Transform3D tr(
235  transform * Amg::Translation3D(pos) *
236  Amg::AngleAxis3D(phi, Amg::Vector3D(0., 0., 1.)) *
237  Amg::AngleAxis3D(-ori * 90 * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.)));
238  plane =
239  new Trk::PlaneSurface(tr, new Trk::RectangleBounds(0.5 * xsize, m_halfZ));
240 
241  // verify position of vertices - uncomment for debugging
242  // if
243  // (!plane->isOnSurface(Trk::GlobalPosition(m_xyVtx[iv1].first,m_xyVtx[iv1].second,m_halfZ),true,0.001,0.001)
244  // ||
245  // !plane->isOnSurface(Trk::GlobalPosition(m_xyVtx[iv2].first,m_xyVtx[iv2].second,-m_halfZ),true,0.001,0.001)
246  // )
247  // std::cout << "ERROR in SIMPLEPGONBREP side boundary:vertices out of
248  // plane"<< std::endl;
249 
250  return plane;
251 }
252 
253 bool
254 Trk::SimplePolygonBrepVolumeBounds::inside(const Amg::Vector3D& pos, double tol)
255  const
256 {
257  return (m_combinedVolume->inside(pos, tol));
258 }
259 
260 void
261 Trk::SimplePolygonBrepVolumeBounds::processSubVols()
262 {
263  // translate into prisms (triangulate)
264  Trk::Volume* cVol = nullptr;
265 #ifdef TRKDETDESCR_USEFLOATPRECISON
266 #define double float
267 #endif
268  std::vector<std::pair<double, double>> triangles = TriangulatePolygonCheck(
269  m_xyVtx); //@TODO change argument to const vector<pair< > >
270  std::vector<std::pair<double, double>> vertices;
271 #ifdef TRKDETDESCR_USEFLOATPRECISON
272 #undef double
273 #endif
274  for (unsigned int i = 0; i < triangles.size(); i = i + 3) {
275  vertices.push_back(triangles[i]);
276  vertices.push_back(triangles[i + 1]);
277  vertices.push_back(triangles[i + 2]);
278  Trk::Volume* newVol =
279  new Trk::Volume(nullptr, new Trk::PrismVolumeBounds(vertices, m_halfZ));
280  if (cVol)
281  cVol = new Trk::Volume(
282  nullptr, new Trk::CombinedVolumeBounds(cVol, newVol, false));
283  else
284  cVol = newVol;
285  vertices.clear();
286  }
287  m_combinedVolume = cVol;
288 }
289 
290 // ostream operator overload
291 MsgStream&
292 Trk::SimplePolygonBrepVolumeBounds::dump(MsgStream& sl) const
293 {
294  std::stringstream temp_sl;
295  temp_sl << std::setiosflags(std::ios::fixed);
296  temp_sl << std::setprecision(7);
297  temp_sl << "Trk::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
298  temp_sl << "( " << m_halfZ << ")";
299  for (const auto & xyVtx : m_xyVtx)
300  temp_sl << "(" << xyVtx.first << "," << xyVtx.second << ")";
301  sl << temp_sl.str();
302  return sl;
303 }
304 
305 std::ostream&
306 Trk::SimplePolygonBrepVolumeBounds::dump(std::ostream& sl) const
307 {
308  std::stringstream temp_sl;
309  temp_sl << std::setiosflags(std::ios::fixed);
310  temp_sl << std::setprecision(7);
311  temp_sl << "Trk::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
312  temp_sl << "( " << m_halfZ << ")";
313  for (const auto & myVtx : m_xyVtx)
314  temp_sl << "(" << myVtx.first << "," << myVtx.second << ")";
315  sl << temp_sl.str();
316  return sl;
317 }
318 
320 // Triangulate Polygon
321 // M. Wolter
323 
324 bool
325 Trk::SimplePolygonBrepVolumeBounds::Xor(bool x, bool y)
326 // XOR: Arguments are negated to ensure that they are 0/1. Then the bitwise Xor
327 // operator may apply.
328 {
329  return !x ^ !y;
330 }
331 
332 #ifdef TRKDETDESCR_USEFLOATPRECISON
333 #define double float
334 #endif
335 
336 bool
337 Trk::SimplePolygonBrepVolumeBounds::Left(
338  std::pair<double, double> a,
339  std::pair<double, double> b,
340  std::pair<double, double> c) const
341 // Returns true iff c is strictly to the left of the directed line through a to
342 // b.
343 {
344  double CrossZ = (b.first - a.first) * (c.second - a.second) -
345  (c.first - a.first) * (b.second - a.second);
346  if (m_ordering == 1)
347  return (CrossZ >= 0.);
348  if (m_ordering == 0)
349  return (CrossZ < 0.);
350  return false;
351 }
352 
353 bool
354 Trk::SimplePolygonBrepVolumeBounds::Intersect(
355  std::pair<double, double> a,
356  std::pair<double, double> b,
357  std::pair<double, double> c,
358  std::pair<double, double> d) const
359 // Returns true iff segments ab and cd intersect
360 {
361 
362  return Xor(Left(a, b, c), Left(a, b, d)) && Xor(Left(c, d, a), Left(c, d, b));
363 }
364 
365 bool
366 Trk::SimplePolygonBrepVolumeBounds::InCone(
367  int i,
368  int j,
369  const std::vector<std::pair<double, double>>& inputVertices) const
370 // Returns true iff the diagonal (i,j) is internal to the polygon in
371 // the neighborhood of the i endpoint.
372 {
373  int iPlus1 = (i + 1) % inputVertices.size();
374  int iMinus1 = (i + inputVertices.size() - 1) % inputVertices.size();
375 
376  /* If P[i] is a convex vertex [ i+1 left or on (i-1,i) ]. */
377  if (Left(inputVertices[iMinus1], inputVertices[i], inputVertices[iPlus1]))
378  return Left(inputVertices[i], inputVertices[j], inputVertices[iMinus1]) &&
379  Left(inputVertices[j], inputVertices[i], inputVertices[iPlus1]);
380 
381  /* Assume (i-1,i,i+1) not collinear. */
382  /* else v_i is reflex. */
383  else
384  return !(
385  Left(inputVertices[i], inputVertices[j], inputVertices[iPlus1]) &&
386  Left(inputVertices[j], inputVertices[i], inputVertices[iMinus1]));
387 }
388 
389 bool
390 Trk::SimplePolygonBrepVolumeBounds::Diagonalie(
391  int i,
392  int j,
393  const std::vector<std::pair<double, double>>& inputVertices) const
394 {
395  // Returns TRUE iff (v_i, v_j) is a proper internal *or* external diagonal of
396  // this polygon, *ignoring edges incident to v_i and v_j*.
397 
398  /* For each edge (k,k+1) of P */
399  for (int k = 0; k < (int)inputVertices.size(); k++) {
400 
401  int kPlus1 = (k + 1) % inputVertices.size();
402 
403  /* Skip edges incident to i or j */
404  if ((k != i) && (kPlus1 != i) && (k != j) && (kPlus1 != j))
405  if (Intersect(
406  inputVertices[i],
407  inputVertices[j],
408  inputVertices[k],
409  inputVertices[kPlus1]))
410  return false;
411  }
412  return true;
413 }
414 
415 bool
416 Trk::SimplePolygonBrepVolumeBounds::Diagonal(
417  int i,
418  int j,
419  const std::vector<std::pair<double, double>>& inputVertices) const
420 // Returns TRUE iff (v_i, v_j) is a proper internal diagonal of P.
421 {
422  // std::cout<<"MW Diagonal "<<i<<" "<<j<<" "<<InCone(i,j, inputVertices)<<"
423  // "<<Diagonalie(i,j, inputVertices)<<std::endl;
424  return InCone(i, j, inputVertices) && Diagonalie(i, j, inputVertices);
425 }
426 
427 std::vector<std::pair<double, double>>
428 Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygon(
429  const std::vector<std::pair<double, double>>& Vertices) const
430 {
431  // Subtracting ears method
432  //
433  // One way to triangulate a simple polygon is by using the assertion that any
434  // simple polygon without holes
435  // has at least two so called 'ears'. An ear is a triangle with two sides on
436  // the edge of the polygon and the other one completely inside it. The
437  // algorithm then consists of finding such an ear, removing it from the
438  // polygon (which results in a new polygon that still meets the conditions)
439  // and repeating until there is only one triangle left.
440  //
441 
442  int NSize = Vertices.size();
443  std::vector<std::pair<double, double>> outTriangles;
444  std::vector<std::pair<double, double>> inputVertices;
445  inputVertices.reserve(NSize);
446  for (int i = 0; i < NSize; i++)
447  inputVertices.push_back((Vertices)[i]);
448 
449  // for (int i; i<NSize;i++) std::cout<<"MW input vertices:
450  // "<<inputVertices[i].first<<" "<<inputVertices[i].second<<std::endl;
451  // Triangulates this polygon and saves triangle edges in TriPoly.
452  // Triangles are stored CCW, with each set of 3 consecutive points in TriPoly
453  // representing 1 triangle.
454  // Assumes this polygon is closed.
455 
456  if (NSize < 4)
457  return inputVertices;
458 
459  // Start triangulating
460  int VerticesLeft = NSize;
461  while (VerticesLeft > 3) {
462  // std::cout<<"MW vertices left "<<VerticesLeft<<std::endl;
463  bool bCornerCut = false;
464  for (int i = 0; i < VerticesLeft; i++) {
465 
466  int iPlus1 = i + 1;
467  if (iPlus1 == VerticesLeft)
468  iPlus1 = 0;
469  int iPlus2 = (iPlus1 + 1);
470  if (iPlus2 == VerticesLeft)
471  iPlus2 = 0;
472 
473  if (Diagonal(i, iPlus2, inputVertices)) {
474 
475  outTriangles.push_back(inputVertices[i]);
476  outTriangles.push_back(inputVertices[iPlus1]);
477  outTriangles.push_back(inputVertices[iPlus2]);
478 
479  inputVertices.erase(inputVertices.begin() + iPlus1);
480  VerticesLeft--;
481  bCornerCut = true;
482  break;
483  }
484  }
485  if (!bCornerCut) { // Error - bad poly
486  // std::cout<<"MW Error - bad poly"<<std::endl;
487  std::vector<std::pair<double, double>> out;
488  return out;
489  }
490  }
491 
492  if (VerticesLeft == 3) {
493  outTriangles.push_back(inputVertices[0]);
494  outTriangles.push_back(inputVertices[1]);
495  outTriangles.push_back(inputVertices[2]);
496  inputVertices.erase(inputVertices.begin() + 1);
497  VerticesLeft--;
498  }
499 
500  return outTriangles;
501 }
502 
503 std::vector<std::pair<double, double>>
504 Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygonCheck(
505  const std::vector<std::pair<double, double>>& Vertices)
506 {
507  // Perform triangulation. Check the orientation of the verices in the polygon
508  // m_ordering = -1 not set
509  // m_ordering = 1 anticlockwise
510  // m_ordering = 0 clockwise
511 
512  if (m_ordering == -1)
513  m_ordering = 1;
514  std::vector<std::pair<double, double>> outTriangles =
515  TriangulatePolygon(Vertices);
516  if (outTriangles.empty()) {
517  m_ordering = -m_ordering + 1;
518  outTriangles = TriangulatePolygon(Vertices);
519  }
520 
521  return outTriangles;
522 }
523 #ifdef TRKDETDESCR_USEFLOATPRECISON
524 #undef double
525 #endif
526 
Trk::y
@ y
Definition: ParamDefs.h:62
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::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:354
Trk::SimplePolygonBrepVolumeBounds::InCone
bool InCone(int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const
Definition: SimplePolygonBrepVolumeBounds.cxx:366
Trk::SimplePolygonBrepVolumeBounds::Diagonal
bool Diagonal(int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const
Definition: SimplePolygonBrepVolumeBounds.cxx:416
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:325
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:428
Trk::SimplePolygonBrepVolumeBounds::sideSurf
Trk::PlaneSurface * sideSurf(const Amg::Transform3D &, unsigned int, unsigned int) const
Definition: SimplePolygonBrepVolumeBounds.cxx:208
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:254
SubtractedPlaneSurface.h
Trk::SubtractedPlaneSurface
Definition: SubtractedPlaneSurface.h:32
lumiFormat.i
int i
Definition: lumiFormat.py:92
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:390
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:292
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:170
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
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
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:534
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:504
xmax
double xmax
Definition: listroot.cxx:61
Trk::SimplePolygonBrepVolumeBounds::processSubVols
void processSubVols()
Definition: SimplePolygonBrepVolumeBounds.cxx:261
CombinedVolumeBounds.h
Amg::AngleAxis3D
Eigen::AngleAxisd AngleAxis3D
Definition: GeoPrimitives.h:45
Trk::VolumeExcluder
Definition: VolumeExcluder.h:29
Trk::phi
@ phi
Definition: ParamDefs.h:81
Trk::SimplePolygonBrepVolumeBounds::Left
bool Left(std::pair< double, double > a, std::pair< double, double > b, std::pair< double, double > c) const
Definition: SimplePolygonBrepVolumeBounds.cxx:337
Trk::x
@ x
Definition: ParamDefs.h:61
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 Tue Jul 2 2024 21:26:53 for ATLAS Offline Software by   doxygen 1.8.18