ATLAS Offline Software
Loading...
Searching...
No Matches
BevelledCylinderVolumeBounds.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3*/
4
6// BevelledCylinderVolumeBounds.cxx, (c) ATLAS Detector software
8
9// Trk
10#include "TrkVolumes/BevelledCylinderVolumeBounds.h"
11// TrkSurfaces
12#include "TrkSurfaces/CylinderSurface.h"
13#include "TrkSurfaces/DiscSurface.h"
14#include "TrkSurfaces/PlaneSurface.h"
15//#include "TrkGeometrySurfaces/BevelledCylinderBounds.h"
16#include "TrkGeometrySurfaces/SubtractedDiscSurface.h"
17#include "TrkSurfaces/DiscBounds.h"
18#include "TrkSurfaces/EllipseBounds.h"
19#include "TrkSurfaces/RectangleBounds.h"
20#include "TrkSurfaces/TrapezoidBounds.h"
21#include "TrkVolumes/CombinedVolumeBounds.h"
22#include "TrkVolumes/CuboidVolumeBounds.h"
23#include "TrkVolumes/VolumeExcluder.h"
24// Gaudi
25#include "GaudiKernel/MsgStream.h"
26#include "GaudiKernel/SystemOfUnits.h"
27// STD
28#include <cmath>
29#include <iostream>
30
31const double Trk::BevelledCylinderVolumeBounds::s_numericalStable =
32 10e-2 * Gaudi::Units::millimeter;
33
46
47Trk::BevelledCylinderVolumeBounds::BevelledCylinderVolumeBounds(
48 double rinner,
49 double router,
50 double haphi,
51 double halez,
52 int type)
53 : VolumeBounds()
54 , m_innerRadius(std::abs(rinner))
55 , m_outerRadius(std::abs(router))
56 , m_halfPhiSector(haphi)
57 , m_halfZ(std::abs(halez))
58 , m_thetaMinus(0.)
59 , m_thetaPlus(0.)
60 , m_type(type)
61 , m_boundaryAccessors()
62 , m_subtractedVolume(nullptr)
63{}
64
78
79Trk::BevelledCylinderVolumeBounds::~BevelledCylinderVolumeBounds() = default;
80
81Trk::BevelledCylinderVolumeBounds&
82Trk::BevelledCylinderVolumeBounds::operator=(
83 const Trk::BevelledCylinderVolumeBounds& cylbo)
84{
85 if (this != &cylbo) {
86 m_innerRadius = cylbo.m_innerRadius;
87 m_outerRadius = cylbo.m_outerRadius;
88 m_halfPhiSector = cylbo.m_halfPhiSector;
89 m_halfZ = cylbo.m_halfZ;
90 m_thetaMinus = cylbo.m_thetaMinus;
91 m_thetaPlus = cylbo.m_thetaPlus;
92 m_type = cylbo.m_type;
93 m_subtractedVolume.store(nullptr);
94 }
95 return *this;
96}
97
98std::vector<std::unique_ptr<Trk::Surface>>
99 Trk::BevelledCylinderVolumeBounds::decomposeToSurfaces
100 (const Amg::Transform3D& transform)
101{
102 auto retsf = std::vector<std::unique_ptr<Trk::Surface>>();
103 // memory optimisation (reserve a save number of 20)
104 retsf.reserve(6);
105
106 Amg::RotationMatrix3D discRot(transform.rotation());
107 Amg::Vector3D cylCenter(transform.translation());
108
109 // Lazy init m_m_subtractedVolume
110 if (m_type > -1 && !m_subtractedVolume) {
111 m_subtractedVolume.set(std::unique_ptr<Trk::Volume>(subtractedVolume()));
112 }
113
114 // bottom Ellipse/Disc (negative z)
115 if (m_type < 0)
116 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
117 Amg::Transform3D(
118 (discRot *
119 Amg::AngleAxis3D(-m_thetaMinus + M_PI, Amg::Vector3D(0., 1., 0.))) *
120 Amg::Translation3D(
121 cylCenter - (halflengthZ() - m_outerRadius * tan(m_thetaMinus)) *
122 discRot.col(2))),
123 bottomEllipseBounds()));
124 else {
125 if (m_subtractedVolume) {
126 auto subtrVol = std::make_unique<Trk::Volume>(*m_subtractedVolume);
127 Trk::DiscSurface bottomDisc(
128 Amg::Transform3D(
129 transform * Amg::AngleAxis3D(M_PI, Amg::Vector3D(1., 0., 0.)) *
130 Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
131 discBounds());
132 retsf.push_back(std::make_unique<Trk::SubtractedDiscSurface>(
133 bottomDisc, std::make_shared<Trk::VolumeExcluder>(std::move(subtrVol)), false));
134 } else
135 retsf.push_back(std::make_unique<Trk::DiscSurface>(
136 Amg::Transform3D(
137 transform * Amg::AngleAxis3D(M_PI, Amg::Vector3D(1., 0., 0.)) *
138 Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
139 discBounds()));
140 }
141
142 // top Ellipse/Disc (positive z)
143 if (m_type < 0)
144 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
145 Amg::Transform3D(
146 discRot * Amg::AngleAxis3D(m_thetaPlus, Amg::Vector3D(0., 1., 0.)) *
147 Amg::Translation3D(
148 cylCenter +
149 (halflengthZ() - m_outerRadius * tan(m_thetaPlus)) * discRot.col(2))),
150 topEllipseBounds()));
151 else {
152 if (m_subtractedVolume) {
153 auto subtrVol = std::make_unique<Trk::Volume>(*m_subtractedVolume);
154 Trk::DiscSurface topDisc(
155 Amg::Transform3D(
156 transform * Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
157 discBounds());
158 retsf.push_back(std::make_unique<Trk::SubtractedDiscSurface>(
159 topDisc, std::make_shared<Trk::VolumeExcluder>(std::move(subtrVol)), false));
160 } else
161 retsf.push_back(std::make_unique<Trk::DiscSurface>(
162 Amg::Transform3D(
163 transform * Amg::Translation3D(Amg::Vector3D(0., 0., halflengthZ()))),
164 discBounds()));
165 }
166
167 // outer BevelledCylinder/Plane
168 if (m_type < 0)
169 retsf.push_back(std::make_unique<Trk::CylinderSurface>(
170 Amg::Transform3D(transform), outerBevelledCylinderBounds()));
171 else if (m_type < 2)
172 retsf.push_back(std::make_unique<Trk::CylinderSurface>(
173 Amg::Transform3D(transform), outerCylinderBounds()));
174 else
175 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
176 Amg::Transform3D(
177 transform *
178 Amg::Translation3D(Amg::Vector3D(this->outerRadius(), 0., 0.)) *
179 Amg::AngleAxis3D(-90 * Gaudi::Units::deg, Amg::Vector3D(0., 0., 1.)) *
180 Amg::AngleAxis3D(-90. * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.))),
181 outerBevelledPlaneBounds()));
182
183 // inner BevelledCylinder/Plane
184 if (innerRadius() > s_numericalStable) {
185 if (m_type < 1)
186 retsf.push_back(std::make_unique<Trk::CylinderSurface>(
187 Amg::Transform3D(transform), innerBevelledCylinderBounds()));
188 else if (m_type == 2)
189 retsf.push_back(std::make_unique<Trk::CylinderSurface>(
190 Amg::Transform3D(transform), innerCylinderBounds()));
191 else
192 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
193 Amg::Transform3D(
194 transform *
195 Amg::Translation3D(Amg::Vector3D(this->innerRadius(), 0., 0.)) *
196 Amg::AngleAxis3D(+90 * Gaudi::Units::deg, Amg::Vector3D(0., 0., 1.)) *
197 Amg::AngleAxis3D(
198 -90. * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.))),
199 innerBevelledPlaneBounds()));
200 }
201
202 if (std::abs(halfPhiSector() - M_PI) > s_numericalStable) {
203 if (m_type < 0) {
204 // sectorPlane 1 (negative phi)
205 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
206 Amg::Transform3D(
207 transform *
208 Amg::AngleAxis3D(-halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
209 Amg::Translation3D(Amg::Vector3D(mediumRadius(), 0., 0.)) *
210 Amg::AngleAxis3D(M_PI / 2, Amg::Vector3D(1., 0., 0.))),
211 sectorTrdBounds()));
212 // sectorPlane 2 (positive phi)
213 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
214 Amg::Transform3D(
215 transform *
216 Amg::AngleAxis3D(halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
217 Amg::Translation3D(Amg::Vector3D(mediumRadius(), 0., 0.)) *
218 Amg::AngleAxis3D(-M_PI / 2, Amg::Vector3D(1., 0., 0.))),
219 sectorTrdBounds()));
220 } else {
221 // sectorPlane 1 (negative phi)
222 double ri = innerRadius();
223 double ro = outerRadius();
224 if (m_type == 1 || m_type == 3)
225 ri *= 1. / cos(halfPhiSector());
226 if (m_type > 1)
227 ro *= 1. / cos(halfPhiSector());
228 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
229 Amg::Transform3D(
230 transform *
231 Amg::AngleAxis3D(-halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
232 Amg::Translation3D(Amg::Vector3D(0.5 * (ri + ro), 0., 0.)) *
233 Amg::AngleAxis3D(M_PI / 2, Amg::Vector3D(1., 0., 0.))),
234 sectorPlaneBounds()));
235 // sectorPlane 2 (positive phi)
236 retsf.push_back(std::make_unique<Trk::PlaneSurface>(
237 Amg::Transform3D(
238 transform *
239 Amg::AngleAxis3D(halfPhiSector(), Amg::Vector3D(0., 0., 1.)) *
240 Amg::Translation3D(Amg::Vector3D(0.5 * (ri + ro), 0., 0.)) *
241 Amg::AngleAxis3D(-M_PI / 2, Amg::Vector3D(1., 0., 0.))),
242 sectorPlaneBounds()));
243 }
244 }
245 return retsf;
246}
247
248Trk::ObjectAccessor
249Trk::BevelledCylinderVolumeBounds::boundarySurfaceAccessor(
250 const Amg::Vector3D& gp,
251 const Amg::Vector3D& dir,
252 bool) const
253{
254 // the tube case - most likely
255 if (m_innerRadius != 0. && std::abs(m_halfPhiSector - M_PI) < s_numericalStable) {
256 // prepare the data
257 double posZ = gp.z();
258 double posR = gp.perp();
259 // difference Vector
260 Amg::Vector3D diff(gp + dir);
261 // differences
262 double deltaZ = diff.z() - posZ;
263 double deltaR = diff.perp() - posR;
264
265 // the isOnSurface cases + switchers (that change with the cases)
266 bool isOnFace = false;
267 bool intersectionIndicator = (deltaR > 0.);
268 bool choiceIndicator = false;
269
270 // on surface or look-a-likes
271 // on zMin or slightly outside
272 if (
273 std::abs(posZ + m_halfZ) < s_numericalStable ||
274 (posZ < (-m_halfZ) && deltaZ > 0.)) {
275 isOnFace = true;
276 } else if (
277 std::abs(posZ - m_halfZ) < s_numericalStable ||
278 (posZ > m_halfZ && deltaZ < 0.)) {
279 // on zMax or slighly outside
280 isOnFace = true;
281 } else if (
282 std::abs(posR - m_innerRadius) < s_numericalStable ||
283 (posR < m_innerRadius && deltaR > 0.)) {
284 // on innerRadius or slightly outside
285 isOnFace = true;
286 choiceIndicator =
287 (deltaZ > 0.); // the side choice indicator <========== WRONG ==========
288 } else if (
289 std::abs(posR - m_outerRadius) < s_numericalStable ||
290 (posR > m_outerRadius && deltaR < 0.)) {
291 // on outRadius or slightly outside
292 isOnFace = true;
293 choiceIndicator =
294 (deltaZ > 0.); // the side choice indicator <========== WRONG ==========
295 }
296
297 // the onSurface case
298 // =================================================================================
299 if (isOnFace) {
300 if (intersectionIndicator) {
301 // intersect the Rmax
302 Trk::BevelledBoundaryIntersector intersectRmax(
303 posR, posZ, deltaZ / deltaR, m_outerRadius);
304 double zOfIntersect = intersectRmax.yOfX;
305 // now check if the intersect is inside m_halfZ
306 if (std::abs(zOfIntersect) <= m_halfZ)
307 return {(choiceIndicator || zOfIntersect > 0.)
308 ? m_boundaryAccessors.bevelledtubeAccessor(
309 Trk::BevelledTubeRincreaseZincrease)
310 : m_boundaryAccessors.bevelledtubeAccessor(
311 Trk::BevelledTubeRincreaseZdecrease)};
312 // if the intersect is outside
313 return {(choiceIndicator || zOfIntersect > 0.)
314 ? m_boundaryAccessors.bevelledtubeAccessor(
315 Trk::BevelledTubeZincreaseRincrease)
316 : m_boundaryAccessors.bevelledtubeAccessor(
317 Trk::BevelledTubeZdecreaseRincrease)};
318 }
319 // intersect the Rmin
320 Trk::BevelledBoundaryIntersector intersectRmin(
321 posR, posZ, deltaZ / deltaR, m_innerRadius);
322 double zOfIntersect = intersectRmin.yOfX;
323 // now check if the intersect is inside m_halfZ
324 if (std::abs(zOfIntersect) <= m_halfZ)
325 return {(choiceIndicator || zOfIntersect > 0.)
326 ? m_boundaryAccessors.bevelledtubeAccessor(
327 Trk::BevelledTubeRdecreaseZincrease)
328 : m_boundaryAccessors.bevelledtubeAccessor(
329 Trk::BevelledTubeRdecreaseZdecrease)};
330 // if the intersect is outside
331 return {(choiceIndicator || zOfIntersect > 0.)
332 ? m_boundaryAccessors.bevelledtubeAccessor(
333 Trk::BevelledTubeZincreaseRdecrease)
334 : m_boundaryAccessors.bevelledtubeAccessor(
335 Trk::BevelledTubeZdecreaseRdecrease)};
336 }
337 // =================================================================================================
338
339 // ======================= the inside/outside part remains
340 // =========================================
341 // (a) outside cases
342 if (posR < m_innerRadius && deltaR < 0.)
343 return {m_boundaryAccessors.bevelledtubeAccessor(
344 Trk::BevelledTubeOutsideRminRdecrease)};
345 if (posR > m_outerRadius && deltaR > 0.)
346 return {m_boundaryAccessors.bevelledtubeAccessor(
347 Trk::BevelledTubeOutsideRmaxRincrease)};
348 if (posZ < -m_halfZ && deltaZ < 0.)
349 return {m_boundaryAccessors.bevelledtubeAccessor(
350 Trk::BevelledTubeOutsideZminZdecrease)};
351 if (posZ > m_halfZ && deltaZ > 0.)
352 return {m_boundaryAccessors.bevelledtubeAccessor(
353 Trk::BevelledTubeOutsideZmaxZincrease)};
354 // (b) inside cases
355 // the increase R case
356 if (deltaR > 0.) {
357 // solve the linear equation for the outer Radius
358 Trk::BevelledBoundaryIntersector intersectRmax(
359 posR, posZ, deltaZ / deltaR, m_outerRadius);
360 double zOfIntersect = intersectRmax.yOfX;
361
362 if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect > 0.)
363 return {m_boundaryAccessors.bevelledtubeAccessor(
364 Trk::BevelledTubeRincreaseZincrease)};
365 if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect < 0.)
366 return {m_boundaryAccessors.bevelledtubeAccessor(
367 Trk::BevelledTubeRincreaseZdecrease)};
368 if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect < 0.)
369 return {m_boundaryAccessors.bevelledtubeAccessor(
370 Trk::BevelledTubeZdecreaseRincrease)};
371 if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect > 0.)
372 return {m_boundaryAccessors.bevelledtubeAccessor(
373 Trk::BevelledTubeZincreaseRincrease)};
374
375 } else {
376 if (deltaR == 0.)[[unlikely]]{
377 throw std::runtime_error("deltaR is zero in BevelledCylinderVolumeBounds::boundarySurfaceAccessor");
378 }
379 // solve the linear equation for the inner Radius
380 Trk::BevelledBoundaryIntersector intersectRmin(
381 posR, posZ, deltaZ / deltaR, m_innerRadius);
382 double zOfIntersect = intersectRmin.yOfX;
383
384 if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect > 0.)
385 return {m_boundaryAccessors.bevelledtubeAccessor(
386 Trk::BevelledTubeRdecreaseZincrease)};
387 if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect < 0.)
388 return {m_boundaryAccessors.bevelledtubeAccessor(
389 Trk::BevelledTubeRdecreaseZdecrease)};
390 if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect > 0.)
391 return {m_boundaryAccessors.bevelledtubeAccessor(
392 Trk::BevelledTubeZincreaseRdecrease)};
393 return {m_boundaryAccessors.bevelledtubeAccessor(
394 Trk::BevelledTubeZdecreaseRdecrease)};
395 }
396 }
397 // the cylinder case
398 if (m_innerRadius == 0. && std::abs(m_halfPhiSector - M_PI) < 10e-3) {
399
400 double posZ = gp.z();
401 double posR = gp.perp();
402 // difference Vector
403 Amg::Vector3D diff(gp + dir);
404 // differences
405 double deltaZ = diff.z() - posZ;
406 double deltaR = diff.perp() - posR;
407
408 // solve the linear equation for the cylinder Radius
409 Trk::BevelledBoundaryIntersector intersectR(
410 posR, posZ, deltaZ / deltaR, m_outerRadius);
411 // the intersection point
412 double zOfIntersect = intersectR.yOfX;
413
414 if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect > 0.)
415 return {m_boundaryAccessors.bevelledcylinderAccessor(
416 Trk::BevelledCylinderZincrease)};
417 if (std::abs(zOfIntersect) <= m_halfZ && zOfIntersect < 0.)
418 return {m_boundaryAccessors.bevelledcylinderAccessor(
419 Trk::BevelledCylinderZdecrease)};
420 if (std::abs(zOfIntersect) > m_halfZ && zOfIntersect > 0.)
421 return {m_boundaryAccessors.bevelledcylinderAccessor(
422 Trk::BevelledCylinderPositiveFace)};
423 return {m_boundaryAccessors.bevelledcylinderAccessor(
424 Trk::BevelledCylinderNegativeFace)};
425 }
426 // the sectoral cylinder case
427 if (m_innerRadius != 0. && std::abs(m_halfPhiSector - M_PI) > 10e-3)
428 return {m_boundaryAccessors.sectoralBevelledCylinderAccessor(
429 Trk::StandardSectoralBevelledCylinder)};
430 // it remains the sectoral tube case
431 return {m_boundaryAccessors.sectoralBevelledTubeAccessor(
432 Trk::StandardSectoralBevelledTube)};
433}
434
435std::shared_ptr<Trk::CylinderBounds>
436Trk::BevelledCylinderVolumeBounds::innerBevelledCylinderBounds() const
437{
438 return std::make_shared<Trk::CylinderBounds>(m_innerRadius, m_halfPhiSector, m_halfZ);
439}
440
441std::shared_ptr<Trk::CylinderBounds>
442Trk::BevelledCylinderVolumeBounds::outerBevelledCylinderBounds() const
443{
444 return std::make_shared<Trk::CylinderBounds>(m_outerRadius, m_halfPhiSector, m_halfZ);
445}
446
447std::shared_ptr<Trk::RectangleBounds>
448Trk::BevelledCylinderVolumeBounds::outerBevelledPlaneBounds() const
449{
450 return std::make_shared<Trk::RectangleBounds>(m_outerRadius * tan(m_halfPhiSector), m_halfZ);
451}
452
453std::shared_ptr<Trk::RectangleBounds>
454Trk::BevelledCylinderVolumeBounds::innerBevelledPlaneBounds() const
455{
456 return std::make_shared<Trk::RectangleBounds>(m_innerRadius * tan(m_halfPhiSector), m_halfZ);
457}
458
459std::shared_ptr<Trk::EllipseBounds>
460Trk::BevelledCylinderVolumeBounds::bottomEllipseBounds() const
461{
462 return std::make_shared<Trk::EllipseBounds>(
463 m_innerRadius / cos(m_thetaMinus),
464 m_innerRadius,
465 m_outerRadius / cos(m_thetaMinus),
466 m_outerRadius,
467 m_halfPhiSector);
468}
469
470std::shared_ptr<Trk::EllipseBounds>
471Trk::BevelledCylinderVolumeBounds::topEllipseBounds() const
472{
473 return std::make_shared<Trk::EllipseBounds>(
474 m_innerRadius / cos(m_thetaPlus),
475 m_innerRadius,
476 m_outerRadius / cos(m_thetaPlus),
477 m_outerRadius,
478 m_halfPhiSector);
479}
480
481std::shared_ptr<Trk::CylinderBounds>
482Trk::BevelledCylinderVolumeBounds::innerCylinderBounds() const
483{
484 return std::make_shared<Trk::CylinderBounds>(m_innerRadius, m_halfPhiSector, m_halfZ);
485}
486
487std::shared_ptr<Trk::CylinderBounds>
488Trk::BevelledCylinderVolumeBounds::outerCylinderBounds() const
489{
490 return std::make_shared<Trk::CylinderBounds>(m_outerRadius, m_halfPhiSector, m_halfZ);
491}
492
493std::shared_ptr<Trk::DiscBounds>
494Trk::BevelledCylinderVolumeBounds::discBounds() const
495{
496 // adjust radius to make sure all surface covered
497 double outerRadius =
498 (m_type > 1) ? m_outerRadius / cos(m_halfPhiSector) : m_outerRadius;
499 return std::make_shared<Trk::DiscBounds>(m_innerRadius, outerRadius, m_halfPhiSector);
500}
501
502std::shared_ptr<Trk::TrapezoidBounds>
503Trk::BevelledCylinderVolumeBounds::sectorTrdBounds() const
504{
505 return std::make_shared<Trk::TrapezoidBounds>(
506 0.5 * (outerRadius() - innerRadius()), m_halfZ, m_thetaMinus,
507 m_thetaPlus);
508}
509
510std::shared_ptr<Trk::RectangleBounds>
511Trk::BevelledCylinderVolumeBounds::sectorPlaneBounds() const
512{
513 double ri = innerRadius();
514 double ro = outerRadius();
515 if (m_type == 1 || m_type == 3)
516 ri *= 1. / cos(halfPhiSector());
517 if (m_type > 1)
518 ro *= 1. / cos(halfPhiSector());
519 return std::make_shared<Trk::RectangleBounds>(0.5 * (ro - ri), m_halfZ);
520}
521
522Trk::Volume*
523Trk::BevelledCylinderVolumeBounds::subtractedVolume() const
524{
525 if (m_type < 1)
526 return nullptr;
527
528 double tp = tan(m_halfPhiSector);
529 std::unique_ptr<Trk::Volume> volIn;
530 std::unique_ptr<Trk::Volume> volOut;
531 if (m_type == 1 || m_type == 3) { // cut inner cylinder
532 volIn = std::make_unique<Trk::Volume>(
533 nullptr,
534 std::make_shared<Trk::CuboidVolumeBounds>(m_innerRadius, m_innerRadius * tp + 0.1, m_halfZ + 0.1));
535 }
536 if (m_type > 1) {
537 double hz = m_outerRadius * (1. / cos(m_halfPhiSector) - 1.);
538 volOut = std::make_unique<Trk::Volume>(
539 std::make_unique<Amg::Transform3D>(Amg::Translation3D(Amg::Vector3D(m_outerRadius + hz, 0., 0.))),
540 std::make_shared<Trk::CuboidVolumeBounds>(hz, m_outerRadius * tp + 0.1, m_halfZ + 0.1));
541 }
542
543 if (!volIn){
544 return volOut.release();
545 }
546 else if (!volOut){
547 return volIn.release();
548 }
549 return new Trk::Volume(
550 nullptr, std::make_shared<Trk::CombinedVolumeBounds>(std::move(volIn), std::move(volOut), false));
551}
552
553// ostream operator overload
554
555MsgStream&
556Trk::BevelledCylinderVolumeBounds::dump(MsgStream& sl) const
557{
558 std::stringstream sl_temp;
559 sl_temp << std::setiosflags(std::ios::fixed);
560 sl_temp << std::setprecision(7);
561 sl_temp << "Trk::BevelledCylinderVolumeBounds: (innerR, outerR, "
562 "halfPhiSector, halflengthInZ, thetaMinus, thetaPlus) = ";
563 sl_temp << "(" << m_innerRadius << ", " << m_outerRadius << ", "
564 << m_halfPhiSector << ", " << m_halfZ << ", " << m_thetaMinus << ", "
565 << m_thetaPlus << ")";
566 sl << sl_temp.str();
567 return sl;
568}
569
570std::ostream&
571Trk::BevelledCylinderVolumeBounds::dump(std::ostream& sl) const
572{
573 std::stringstream sl_temp;
574 sl_temp << std::setiosflags(std::ios::fixed);
575 sl_temp << std::setprecision(7);
576 sl_temp << "Trk::BevelledCylinderVolumeBounds: (innerR, outerR, "
577 "halfPhiSector, halflengthInZ, thetaMinus, thetaPlus) = ";
578 sl_temp << "(" << m_innerRadius << ", " << m_outerRadius << ", "
579 << m_halfPhiSector << ", " << m_halfZ << m_thetaMinus << ", "
580 << m_thetaPlus << ")";
581 sl << sl_temp.str();
582 return sl;
583}
584
M_PI
#define M_PI
Definition ActiveFraction.h:14
deltaR
Scalar deltaR(const MatrixBase< Derived > &vec) const
Definition AmgMatrixBasePlugin.h:105
diff
void diff(const Jet &rJet1, const Jet &rJet2, std::map< std::string, double > varDiff)
Difference between jets - Non-Class function required by trigger.
Definition Jet.cxx:631
Trk::BevelledCylinderVolumeBounds
Bounds for a cylindrical Volume, the decomposeToSurfaces method creates a vector of up to 6 surfaces:
Definition BevelledCylinderVolumeBounds.h:100
Trk::BevelledCylinderVolumeBounds::outerBevelledPlaneBounds
std::shared_ptr< RectangleBounds > outerBevelledPlaneBounds() const
This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces.
Definition BevelledCylinderVolumeBounds.cxx:448
Trk::BevelledCylinderVolumeBounds::discBounds
std::shared_ptr< DiscBounds > discBounds() const
This method returns the associated DiscBounds for the bottom/top DiscSurface.
Definition BevelledCylinderVolumeBounds.cxx:494
Trk::BevelledCylinderVolumeBounds::decomposeToSurfaces
virtual std::vector< std::unique_ptr< Trk::Surface > > decomposeToSurfaces(const Amg::Transform3D &transform) override
Method to decompose the Bounds into boundarySurfaces.
Definition BevelledCylinderVolumeBounds.cxx:100
Trk::BevelledCylinderVolumeBounds::bottomEllipseBounds
std::shared_ptr< EllipseBounds > bottomEllipseBounds() const
This method returns the associated EllipseBounds for the bottom/top EllipseSurface.
Definition BevelledCylinderVolumeBounds.cxx:460
Trk::BevelledCylinderVolumeBounds::~BevelledCylinderVolumeBounds
virtual ~BevelledCylinderVolumeBounds()
Destructor.
Trk::BevelledCylinderVolumeBounds::subtractedVolume
Volume * subtractedVolume() const
This method returns the bevelled area volume.
Definition BevelledCylinderVolumeBounds.cxx:523
Trk::BevelledCylinderVolumeBounds::type
int type() const
This method returns the type.
Definition BevelledCylinderVolumeBounds.h:245
Trk::BevelledCylinderVolumeBounds::boundarySurfaceAccessor
ObjectAccessor boundarySurfaceAccessor(const Amg::Vector3D &gp, const Amg::Vector3D &dir, bool forceInside=false) const override
Provide accessor for BoundarySurfaces.
Definition BevelledCylinderVolumeBounds.cxx:249
Trk::BevelledCylinderVolumeBounds::innerBevelledPlaneBounds
std::shared_ptr< RectangleBounds > innerBevelledPlaneBounds() const
This method returns the associated plane surface bounds of the inner bevelled surface.
Definition BevelledCylinderVolumeBounds.cxx:454
Trk::BevelledCylinderVolumeBounds::s_numericalStable
static const double s_numericalStable
numerical stability
Definition BevelledCylinderVolumeBounds.h:212
Trk::BevelledCylinderVolumeBounds::m_subtractedVolume
CxxUtils::CachedUniquePtr< Trk::Volume > m_subtractedVolume
Definition BevelledCylinderVolumeBounds.h:214
Trk::BevelledCylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition BevelledCylinderVolumeBounds.h:242
Trk::BevelledCylinderVolumeBounds::mediumRadius
double mediumRadius() const
This method returns the medium radius.
Definition BevelledCylinderVolumeBounds.h:239
Trk::BevelledCylinderVolumeBounds::dump
MsgStream & dump(MsgStream &sl) const override
Output Method for MsgStream.
Definition BevelledCylinderVolumeBounds.cxx:556
Trk::BevelledCylinderVolumeBounds::innerRadius
double innerRadius() const
This method returns the inner radius.
Definition BevelledCylinderVolumeBounds.h:237
Trk::BevelledCylinderVolumeBounds::sectorTrdBounds
std::shared_ptr< TrapezoidBounds > sectorTrdBounds() const
This method returns the associated PlaneBounds limiting a sectoral BevelledCylinderVolume.
Definition BevelledCylinderVolumeBounds.cxx:503
Trk::BevelledCylinderVolumeBounds::operator=
BevelledCylinderVolumeBounds & operator=(const BevelledCylinderVolumeBounds &cylbo)
Assignment operator.
Definition BevelledCylinderVolumeBounds.cxx:82
Trk::BevelledCylinderVolumeBounds::outerBevelledCylinderBounds
std::shared_ptr< CylinderBounds > outerBevelledCylinderBounds() const
This method returns the associated BevelledCylinderBounds of the outer BevelledCylinderSurfaces.
Definition BevelledCylinderVolumeBounds.cxx:442
Trk::BevelledCylinderVolumeBounds::outerCylinderBounds
std::shared_ptr< CylinderBounds > outerCylinderBounds() const
This method returns the associated CylinderBounds of the outer CylinderSurfaces.
Definition BevelledCylinderVolumeBounds.cxx:488
Trk::BevelledCylinderVolumeBounds::sectorPlaneBounds
std::shared_ptr< RectangleBounds > sectorPlaneBounds() const
Definition BevelledCylinderVolumeBounds.cxx:511
Trk::BevelledCylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition BevelledCylinderVolumeBounds.h:238
Trk::BevelledCylinderVolumeBounds::topEllipseBounds
std::shared_ptr< EllipseBounds > topEllipseBounds() const
This method returns the associated EllipseBounds for the bottom/top EllipseSurface.
Definition BevelledCylinderVolumeBounds.cxx:471
Trk::BevelledCylinderVolumeBounds::halfPhiSector
double halfPhiSector() const
This method returns the halfPhiSector angle.
Definition BevelledCylinderVolumeBounds.h:241
Trk::BevelledCylinderVolumeBounds::innerBevelledCylinderBounds
std::shared_ptr< CylinderBounds > innerBevelledCylinderBounds() const
This method returns the associated BevelledCylinderBounds of the inner BevelledCylinderSurfaces.
Definition BevelledCylinderVolumeBounds.cxx:436
Trk::BevelledCylinderVolumeBounds::m_boundaryAccessors
BevelledCylinderVolumeBoundaryAccessors m_boundaryAccessors
Accessors for Boundary surface access - static is not possible due to mismatched delete() / free () w...
Definition BevelledCylinderVolumeBounds.h:209
Trk::BevelledCylinderVolumeBounds::innerCylinderBounds
std::shared_ptr< CylinderBounds > innerCylinderBounds() const
This method returns the associated CylinderBounds of the inner CylinderSurfaces.
Definition BevelledCylinderVolumeBounds.cxx:482
Trk::DiscSurface
Class for a DiscSurface in the ATLAS detector.
Definition DiscSurface.h:54
Trk::VolumeBounds::VolumeBounds
VolumeBounds()
Default Constructor.
Definition VolumeBounds.h:49
Trk::Volume
Base class for all volumes inside the tracking realm, it defines the interface for inherited Volume c...
Definition Volume.h:36
Amg::AngleAxis3D
Eigen::AngleAxisd AngleAxis3D
Definition GeoPrimitives.h:45
Amg::RotationMatrix3D
Eigen::Matrix< double, 3, 3 > RotationMatrix3D
Definition GeoPrimitives.h:49
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition GeoPrimitives.h:46
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition GeoPrimitives.h:44
Trk::BevelledCylinderZincrease
@ BevelledCylinderZincrease
Cylinder hit, then pos.
Definition BevelledCylinderVolumeBoundaryAccessors.h:19
Trk::BevelledCylinderZdecrease
@ BevelledCylinderZdecrease
Cylinder hit, the neg.
Definition BevelledCylinderVolumeBoundaryAccessors.h:20
Trk::BevelledTubeOutsideRminRdecrease
@ BevelledTubeOutsideRminRdecrease
Accessor type [ 3,1,0,2] - inverse case.
Definition BevelledCylinderVolumeBoundaryAccessors.h:37
Trk::BevelledTubeOutsideZmaxZincrease
@ BevelledTubeOutsideZmaxZincrease
Accessor type [ 1,3,2,0 ] - inverse case.
Definition BevelledCylinderVolumeBoundaryAccessors.h:40
Trk::BevelledTubeRincreaseZincrease
@ BevelledTubeRincreaseZincrease
Accessor type [ 2,1,0,3 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:29
Trk::BevelledTubeZincreaseRdecrease
@ BevelledTubeZincreaseRdecrease
Accessor type [ 1,3,0,2 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:35
Trk::BevelledTubeRdecreaseZincrease
@ BevelledTubeRdecreaseZincrease
Accessor type [ 3,1,0,2 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:33
Trk::BevelledTubeZdecreaseRdecrease
@ BevelledTubeZdecreaseRdecrease
Accessor type [ 0,3,1,2 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:36
Trk::BevelledTubeRdecreaseZdecrease
@ BevelledTubeRdecreaseZdecrease
Accessor type [ 3,0,1,2 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:34
Trk::BevelledTubeRincreaseZdecrease
@ BevelledTubeRincreaseZdecrease
Accessor type [ 2,0,1,3 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:30
Trk::BevelledTubeZincreaseRincrease
@ BevelledTubeZincreaseRincrease
Accessor type [ 1,2,0,3 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:31
Trk::BevelledTubeOutsideZminZdecrease
@ BevelledTubeOutsideZminZdecrease
Accessor type [ 0,3,2,1 ] - inverse case.
Definition BevelledCylinderVolumeBoundaryAccessors.h:39
Trk::BevelledTubeZdecreaseRincrease
@ BevelledTubeZdecreaseRincrease
Accessor type [ 0,2,1,3 ].
Definition BevelledCylinderVolumeBoundaryAccessors.h:32
Trk::BevelledTubeOutsideRmaxRincrease
@ BevelledTubeOutsideRmaxRincrease
Accessor type [ 2,1,0,3 ] - inverse case.
Definition BevelledCylinderVolumeBoundaryAccessors.h:38
std
STL namespace.
unlikely
#define unlikely(x)
Definition pythonic_coracool.cxx:9
Generated on for ATLAS Offline Software by doxygen 1.17.0