Logo ROOT  
Reference Guide
TGeoVGShape.cxx
Go to the documentation of this file.
1// Author: Mihaela Gheata 30/03/16
2/*************************************************************************
3 * Copyright (C) 1995-2016, Rene Brun and Fons Rademakers. *
4 * All rights reserved. *
5 * *
6 * For the licensing terms see $ROOTSYS/LICENSE. *
7 * For the list of contributors see $ROOTSYS/README/CREDITS. *
8 *************************************************************************/
9
10/** \class TGeoVGShape
11\ingroup Geometry_classes
12
13Bridge class for using a VecGeom solid as TGeoShape.
14*/
15
16#include "TGeoVGShape.h"
17
18#include "volumes/PlacedVolume.h"
19#include "volumes/UnplacedVolume.h"
20#include "volumes/UnplacedBox.h"
21#include "volumes/UnplacedTube.h"
22#include "volumes/UnplacedCone.h"
23#include "volumes/UnplacedParaboloid.h"
24#include "volumes/UnplacedParallelepiped.h"
25#include "volumes/UnplacedPolyhedron.h"
26#include "volumes/UnplacedTrd.h"
27#include "volumes/UnplacedOrb.h"
28#include "volumes/UnplacedSphere.h"
29#include "volumes/UnplacedBooleanVolume.h"
30#include "volumes/UnplacedTorus2.h"
31#include "volumes/UnplacedTrapezoid.h"
32#include "volumes/UnplacedPolycone.h"
33#include "volumes/UnplacedScaledShape.h"
34#include "volumes/UnplacedGenTrap.h"
35#include "volumes/UnplacedSExtruVolume.h"
36#include "TError.h"
37#include "TGeoManager.h"
38#include "TGeoMaterial.h"
39#include "TGeoMedium.h"
40#include "TGeoVolume.h"
41#include "TGeoArb8.h"
42#include "TGeoTube.h"
43#include "TGeoCone.h"
44#include "TGeoPara.h"
45#include "TGeoParaboloid.h"
46#include "TGeoTrd1.h"
47#include "TGeoTrd2.h"
48#include "TGeoPcon.h"
49#include "TGeoPgon.h"
50#include "TGeoSphere.h"
51#include "TGeoBoolNode.h"
52#include "TGeoCompositeShape.h"
53#include "TGeoScaledShape.h"
54#include "TGeoTorus.h"
55#include "TGeoEltu.h"
56#include "TGeoXtru.h"
57
58////////////////////////////////////////////////////////////////////////////////
59/// Default constructor
60
61TGeoVGShape::TGeoVGShape(TGeoShape *shape, vecgeom::cxx::VPlacedVolume *vgshape)
62 :TGeoBBox(shape->GetName(), 0, 0, 0), fVGShape(vgshape), fShape(shape)
63{
64 // Copy box parameters from the original ROOT shape
65 const TGeoBBox *box = (const TGeoBBox*)shape;
66 TGeoBBox::SetBoxDimensions(box->GetDX(), box->GetDY(), box->GetDZ());
67 memcpy(fOrigin, box->GetOrigin(), 3*sizeof(Double_t));
68}
69
70////////////////////////////////////////////////////////////////////////////////
71/// Destructor
72
74{
75 // Cleanup only the VecGeom solid, the ROOT shape is cleaned by TGeoManager
76 delete fVGShape;
77}
78
79////////////////////////////////////////////////////////////////////////////////
80/// Factory creating TGeoVGShape from a Root shape. Returns nullptr if the
81/// shape cannot be converted
82
84{
85 vecgeom::cxx::VPlacedVolume *vgshape = TGeoVGShape::CreateVecGeomSolid(shape);
86 if (!vgshape) return nullptr;
87 return ( new TGeoVGShape(shape, vgshape) );
88}
89
90////////////////////////////////////////////////////////////////////////////////
91/// Conversion method to create VecGeom solid corresponding to TGeoShape
92
93vecgeom::cxx::VPlacedVolume *TGeoVGShape::CreateVecGeomSolid(TGeoShape *shape)
94{
95 // Call VecGeom TGeoShape->UnplacedSolid converter
96 // VUnplacedVolume *unplaced = RootGeoManager::Instance().Convert(shape);
97 vecgeom::cxx::VUnplacedVolume *unplaced = Convert(shape);
98 if (!unplaced) return nullptr;
99 // We have to create a placed volume from the unplaced one to have access
100 // to the navigation interface
101 vecgeom::cxx::LogicalVolume *lvol = new vecgeom::cxx::LogicalVolume("", unplaced);
102 return ( lvol->Place() );
103}
104
105////////////////////////////////////////////////////////////////////////////////
106/// Convert a TGeoMatrix to a TRansformation3D
107
108vecgeom::cxx::Transformation3D *TGeoVGShape::Convert(TGeoMatrix const *const geomatrix) {
109 Double_t const *const t = geomatrix->GetTranslation();
110 Double_t const *const r = geomatrix->GetRotationMatrix();
111 vecgeom::cxx::Transformation3D *const transformation =
112 new vecgeom::cxx::Transformation3D(t[0], t[1], t[2], r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8]);
113 return transformation;
114}
115
116////////////////////////////////////////////////////////////////////////////////
117/// Convert a TGeo shape to VUnplacedVolume, then creates a VPlacedVolume
118
119vecgeom::cxx::VUnplacedVolume* TGeoVGShape::Convert(TGeoShape const *const shape)
120{
121 using namespace vecgeom::cxx;
122 VUnplacedVolume *unplaced_volume = nullptr;
123
124 // THE BOX
125 if (shape->IsA() == TGeoBBox::Class()) {
126 TGeoBBox const *const box = static_cast<TGeoBBox const *>(shape);
127 unplaced_volume = new UnplacedBox(box->GetDX(), box->GetDY(), box->GetDZ());
128 }
129
130 // THE TUBE
131 if (shape->IsA() == TGeoTube::Class()) {
132 TGeoTube const *const tube = static_cast<TGeoTube const *>(shape);
133 unplaced_volume = new GenericUnplacedTube(tube->GetRmin(), tube->GetRmax(), tube->GetDz(), 0., kTwoPi);
134 }
135
136 // THE TUBESEG
137 if (shape->IsA() == TGeoTubeSeg::Class()) {
138 TGeoTubeSeg const *const tube = static_cast<TGeoTubeSeg const *>(shape);
139 unplaced_volume =
140 new GenericUnplacedTube(tube->GetRmin(), tube->GetRmax(), tube->GetDz(), kDegToRad * tube->GetPhi1(),
141 kDegToRad * (tube->GetPhi2() - tube->GetPhi1()));
142 }
143
144 // THE CONESEG
145 if (shape->IsA() == TGeoConeSeg::Class()) {
146 TGeoConeSeg const *const cone = static_cast<TGeoConeSeg const *>(shape);
147 unplaced_volume =
148 new UnplacedCone(cone->GetRmin1(), cone->GetRmax1(), cone->GetRmin2(), cone->GetRmax2(), cone->GetDz(),
149 kDegToRad * cone->GetPhi1(), kDegToRad * (cone->GetPhi2() - cone->GetPhi1()));
150 }
151
152 // THE CONE
153 if (shape->IsA() == TGeoCone::Class()) {
154 TGeoCone const *const cone = static_cast<TGeoCone const *>(shape);
155 unplaced_volume = new UnplacedCone(cone->GetRmin1(), cone->GetRmax1(), cone->GetRmin2(), cone->GetRmax2(),
156 cone->GetDz(), 0., kTwoPi);
157 }
158
159 // THE PARABOLOID
160 if (shape->IsA() == TGeoParaboloid::Class()) {
161 TGeoParaboloid const *const p = static_cast<TGeoParaboloid const *>(shape);
162 unplaced_volume = new UnplacedParaboloid(p->GetRlo(), p->GetRhi(), p->GetDz());
163 }
164
165 // THE PARALLELEPIPED
166 if (shape->IsA() == TGeoPara::Class()) {
167 TGeoPara const *const p = static_cast<TGeoPara const *>(shape);
168 unplaced_volume =
169 new UnplacedParallelepiped(p->GetX(), p->GetY(), p->GetZ(), p->GetAlpha(), p->GetTheta(), p->GetPhi());
170 }
171
172 // Polyhedron/TGeoPgon
173 if (shape->IsA() == TGeoPgon::Class()) {
174 TGeoPgon const *pgon = static_cast<TGeoPgon const *>(shape);
175 unplaced_volume = new UnplacedPolyhedron(pgon->GetPhi1(), // phiStart
176 pgon->GetDphi(), // phiEnd
177 pgon->GetNedges(), // sideCount
178 pgon->GetNz(), // zPlaneCount
179 pgon->GetZ(), // zPlanes
180 pgon->GetRmin(), // rMin
181 pgon->GetRmax() // rMax
182 );
183 }
184
185 // TRD2
186 if (shape->IsA() == TGeoTrd2::Class()) {
187 TGeoTrd2 const *const p = static_cast<TGeoTrd2 const *>(shape);
188 unplaced_volume = new UnplacedTrd(p->GetDx1(), p->GetDx2(), p->GetDy1(), p->GetDy2(), p->GetDz());
189 }
190
191 // TRD1
192 if (shape->IsA() == TGeoTrd1::Class()) {
193 TGeoTrd1 const *const p = static_cast<TGeoTrd1 const *>(shape);
194 unplaced_volume = new UnplacedTrd(p->GetDx1(), p->GetDx2(), p->GetDy(), p->GetDz());
195 }
196
197 // TRAPEZOID
198 if (shape->IsA() == TGeoTrap::Class()) {
199 TGeoTrap const *const p = static_cast<TGeoTrap const *>(shape);
200 unplaced_volume = new UnplacedTrapezoid(p->GetDz(), p->GetTheta() * kDegToRad, p->GetPhi() * kDegToRad, p->GetH1(),
201 p->GetBl1(), p->GetTl1(), std::tan(p->GetAlpha1() * kDegToRad), p->GetH2(),
202 p->GetBl2(), p->GetTl2(), std::tan(p->GetAlpha2() * kDegToRad));
203 }
204
205 // THE SPHERE | ORB
206 if (shape->IsA() == TGeoSphere::Class()) {
207 // make distinction
208 TGeoSphere const *const p = static_cast<TGeoSphere const *>(shape);
209 if (p->GetRmin() == 0. && p->GetTheta2() - p->GetTheta1() == 180. && p->GetPhi2() - p->GetPhi1() == 360.) {
210 unplaced_volume = new UnplacedOrb(p->GetRmax());
211 } else {
212 unplaced_volume = new UnplacedSphere(p->GetRmin(), p->GetRmax(), p->GetPhi1() * kDegToRad,
213 (p->GetPhi2() - p->GetPhi1()) * kDegToRad, p->GetTheta1() * kDegToRad,
214 (p->GetTheta2() - p->GetTheta1()) * kDegToRad);
215 }
216 }
217
218 if (shape->IsA() == TGeoCompositeShape::Class()) {
219 TGeoCompositeShape const *const compshape = static_cast<TGeoCompositeShape const *>(shape);
220 TGeoBoolNode const *const boolnode = compshape->GetBoolNode();
221
222 // need the matrix;
223 Transformation3D const *lefttrans = Convert(boolnode->GetLeftMatrix());
224 Transformation3D const *righttrans = Convert(boolnode->GetRightMatrix());
225 // unplaced shapes
226 VUnplacedVolume const *leftunplaced = Convert(boolnode->GetLeftShape());
227 VUnplacedVolume const *rightunplaced = Convert(boolnode->GetRightShape());
228 if (!leftunplaced || !rightunplaced) {
229 // If one of the components cannot be converted, cleanup & return nullptr
230 delete lefttrans;
231 delete righttrans;
232 delete leftunplaced;
233 delete rightunplaced;
234 return nullptr;
235 }
236
237 assert(leftunplaced != nullptr);
238 assert(rightunplaced != nullptr);
239
240 // the problem is that I can only place logical volumes
241 VPlacedVolume *const leftplaced = (new LogicalVolume("inner_virtual", leftunplaced))->Place(lefttrans);
242
243 VPlacedVolume *const rightplaced = (new LogicalVolume("inner_virtual", rightunplaced))->Place(righttrans);
244
245 // now it depends on concrete type
247 unplaced_volume = new UnplacedBooleanVolume(kSubtraction, leftplaced, rightplaced);
248 } else if (boolnode->GetBooleanOperator() == TGeoBoolNode::kGeoIntersection) {
249 unplaced_volume = new UnplacedBooleanVolume(kIntersection, leftplaced, rightplaced);
250 } else if (boolnode->GetBooleanOperator() == TGeoBoolNode::kGeoUnion) {
251 unplaced_volume = new UnplacedBooleanVolume(kUnion, leftplaced, rightplaced);
252 }
253 }
254
255 // THE TORUS
256 if (shape->IsA() == TGeoTorus::Class()) {
257 // make distinction
258 TGeoTorus const *const p = static_cast<TGeoTorus const *>(shape);
259 unplaced_volume =
260 new UnplacedTorus2(p->GetRmin(), p->GetRmax(), p->GetR(), p->GetPhi1() * kDegToRad, p->GetDphi() * kDegToRad);
261 }
262
263 // THE POLYCONE
264 if (shape->IsA() == TGeoPcon::Class()) {
265 TGeoPcon const *const p = static_cast<TGeoPcon const *>(shape);
266 unplaced_volume = new UnplacedPolycone(p->GetPhi1() * kDegToRad, p->GetDphi() * kDegToRad, p->GetNz(), p->GetZ(),
267 p->GetRmin(), p->GetRmax());
268 }
269
270 // THE SCALED SHAPE
271 if (shape->IsA() == TGeoScaledShape::Class()) {
272 TGeoScaledShape const *const p = static_cast<TGeoScaledShape const *>(shape);
273 // First convert the referenced shape
274 VUnplacedVolume *referenced_shape = Convert(p->GetShape());
275 if (!referenced_shape) return nullptr;
276 const double *scale_root = p->GetScale()->GetScale();
277 unplaced_volume = new UnplacedScaledShape(referenced_shape, scale_root[0], scale_root[1], scale_root[2]);
278 }
279
280 // THE ELLIPTICAL TUBE AS SCALED TUBE
281 if (shape->IsA() == TGeoEltu::Class()) {
282 TGeoEltu const *const p = static_cast<TGeoEltu const *>(shape);
283 // Create the corresponding unplaced tube, with:
284 // rmin=0, rmax=A, dz=dz, which is scaled with (1., A/B, 1.)
285 GenericUnplacedTube *tubeUnplaced = new GenericUnplacedTube(0, p->GetA(), p->GetDZ(), 0, kTwoPi);
286 unplaced_volume = new UnplacedScaledShape(tubeUnplaced, 1., p->GetB() / p->GetA(), 1.);
287 }
288
289 // THE ARB8
290 if (shape->IsA() == TGeoArb8::Class() || shape->IsA() == TGeoGtra::Class()) {
291 TGeoArb8 *p = (TGeoArb8 *)(shape);
292 // Create the corresponding GenTrap
293 std::vector<Vector3D<Precision>> vertexlist;
294 const double *vertices = p->GetVertices();
295 Precision verticesx[8], verticesy[8];
296 for (auto ivert = 0; ivert < 8; ++ivert) {
297 verticesx[ivert] = vertices[2 * ivert];
298 verticesy[ivert] = vertices[2 * ivert + 1];
299 }
300 unplaced_volume = new UnplacedGenTrap(verticesx, verticesy, p->GetDz());
301 }
302
303 // THE SIMPLE XTRU
304 if (shape->IsA() == TGeoXtru::Class()) {
305 TGeoXtru *p = (TGeoXtru *)(shape);
306 // analyse convertibility
307 if (p->GetNz() == 2) {
308 // add check on scaling and distortions
309 size_t Nvert = (size_t)p->GetNvert();
310 double *x = new double[Nvert];
311 double *y = new double[Nvert];
312 for (size_t i = 0; i < Nvert; ++i) {
313 x[i] = p->GetX(i);
314 y[i] = p->GetY(i);
315 }
316 // check in which orientation the polygon in given
317 if (PlanarPolygon::GetOrientation(x, y, Nvert) > 0.) {
318 // std::cerr << "Points not given in clockwise order ... reordering \n";
319 for (size_t i = 0; i < Nvert; ++i) {
320 x[Nvert - 1 - i] = p->GetX(i);
321 y[Nvert - 1 - i] = p->GetY(i);
322 }
323 }
324 unplaced_volume = new UnplacedSExtruVolume(p->GetNvert(), x, y, p->GetZ()[0], p->GetZ()[1]);
325 }
326 }
327
328 // New volumes should be implemented here...
329 if (!unplaced_volume) {
330 printf("Unsupported shape for ROOT shape \"%s\" of type %s. "
331 "Using ROOT implementation.\n",
332 shape->GetName(), shape->ClassName());
333 return nullptr;
334 }
335
336 return ( unplaced_volume );
337}
338
339////////////////////////////////////////////////////////////////////////////////
340/// Compute bounding box.
341
343{
345}
346
347////////////////////////////////////////////////////////////////////////////////
348/// Returns analytic capacity of the solid
349
351{
352 return fVGShape->Capacity();
353}
354
355////////////////////////////////////////////////////////////////////////////////
356/// Normal computation.
357
358void TGeoVGShape::ComputeNormal(const Double_t *point, const Double_t */*dir*/, Double_t *norm)
359{
360 vecgeom::cxx::Vector3D<Double_t> vnorm;
361 fVGShape->Normal(vecgeom::cxx::Vector3D<Double_t>(point[0], point[1], point[2]), vnorm);
362 norm[0] = vnorm.x(); norm[1] = vnorm.y(), norm[2] = vnorm.z();
363}
364
365////////////////////////////////////////////////////////////////////////////////
366/// Test if point is inside this shape.
367
369{
370 return ( fVGShape->Contains(vecgeom::cxx::Vector3D<Double_t>(point[0], point[1], point[2])) );
371}
372
373////////////////////////////////////////////////////////////////////////////////
374
375Double_t TGeoVGShape::DistFromInside(const Double_t *point, const Double_t *dir, Int_t /*iact*/,
376 Double_t step, Double_t * /*safe*/) const
377{
378 Double_t dist = fVGShape->DistanceToOut(vecgeom::cxx::Vector3D<Double_t>(point[0], point[1], point[2]),
379 vecgeom::cxx::Vector3D<Double_t>(dir[0], dir[1], dir[2]), step);
380 return ( (dist < 0.)? 0. : dist );
381}
382
383////////////////////////////////////////////////////////////////////////////////
384
386 Double_t step, Double_t * /*safe*/) const
387{
388 Double_t dist = fVGShape->DistanceToIn(vecgeom::cxx::Vector3D<Double_t>(point[0], point[1], point[2]),
389 vecgeom::cxx::Vector3D<Double_t>(dir[0], dir[1], dir[2]), step);
390 return ( (dist < 0.)? 0. : dist );
391}
392
393////////////////////////////////////////////////////////////////////////////////
394
396{
397 Double_t safety = (in) ? fVGShape->SafetyToOut(vecgeom::cxx::Vector3D<Double_t>(point[0], point[1], point[2]))
398 : fVGShape->SafetyToIn(vecgeom::cxx::Vector3D<Double_t>(point[0], point[1], point[2]));
399 return ( (safety < 0.)? 0. : safety );
400}
401
402////////////////////////////////////////////////////////////////////////////////
403/// Print info about the VecGeom solid
404
406{
407 fVGShape->GetUnplacedVolume()->Print();
408 printf("\n");
409}
void Class()
Definition: Class.C:29
ROOT::R::TRInterface & r
Definition: Object.C:4
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
double Double_t
Definition: RtypesCore.h:55
double tan(double)
An arbitrary trapezoid with less than 8 vertices standing on two parallel planes perpendicular to Z a...
Definition: TGeoArb8.h:18
Double_t GetDz() const
Definition: TGeoArb8.h:65
Double_t * GetVertices()
Definition: TGeoArb8.h:69
Box class.
Definition: TGeoBBox.h:18
virtual Double_t GetDZ() const
Definition: TGeoBBox.h:72
Double_t fOrigin[3]
Definition: TGeoBBox.h:24
void SetBoxDimensions(Double_t dx, Double_t dy, Double_t dz, Double_t *origin=0)
Set parameters of the box.
Definition: TGeoBBox.cxx:900
Base class for Boolean operations between two shapes.
Definition: TGeoBoolNode.h:25
virtual EGeoBoolType GetBooleanOperator() const =0
TGeoMatrix * GetRightMatrix() const
Definition: TGeoBoolNode.h:79
TGeoShape * GetLeftShape() const
Definition: TGeoBoolNode.h:80
TGeoMatrix * GetLeftMatrix() const
Definition: TGeoBoolNode.h:78
TGeoShape * GetRightShape() const
Definition: TGeoBoolNode.h:81
Class handling Boolean composition of shapes.
TGeoBoolNode * GetBoolNode() const
A phi segment of a conical tube.
Definition: TGeoCone.h:99
Double_t GetPhi1() const
Definition: TGeoCone.h:160
Double_t GetPhi2() const
Definition: TGeoCone.h:161
Conical tube class.
Definition: TGeoCone.h:18
virtual Double_t GetRmax2() const
Definition: TGeoCone.h:76
virtual Double_t GetDz() const
Definition: TGeoCone.h:68
virtual Double_t GetRmin2() const
Definition: TGeoCone.h:75
virtual Double_t GetRmin1() const
Definition: TGeoCone.h:73
virtual Double_t GetRmax1() const
Definition: TGeoCone.h:74
Elliptical tube class.
Definition: TGeoEltu.h:18
virtual Double_t GetA() const
Definition: TGeoEltu.h:43
virtual Double_t GetB() const
Definition: TGeoEltu.h:44
Geometrical transformation package.
Definition: TGeoMatrix.h:41
virtual const Double_t * GetTranslation() const =0
virtual const Double_t * GetRotationMatrix() const =0
Parallelepiped class.
Definition: TGeoPara.h:18
Double_t GetZ() const
Definition: TGeoPara.h:63
Double_t GetPhi() const
Definition: TGeoPara.h:66
Double_t GetAlpha() const
Definition: TGeoPara.h:64
Double_t GetX() const
Definition: TGeoPara.h:61
Double_t GetY() const
Definition: TGeoPara.h:62
Double_t GetTheta() const
Definition: TGeoPara.h:65
Paraboloid class.
Double_t GetDz() const
Double_t GetRhi() const
Double_t GetRlo() const
A polycone.
Definition: TGeoPcon.h:18
Double_t * GetRmax() const
Definition: TGeoPcon.h:77
Double_t GetDphi() const
Definition: TGeoPcon.h:72
Double_t * GetZ() const
Definition: TGeoPcon.h:79
Int_t GetNz() const
Definition: TGeoPcon.h:73
Double_t * GetRmin() const
Definition: TGeoPcon.h:75
Double_t GetPhi1() const
Definition: TGeoPcon.h:71
A polygone.
Definition: TGeoPgon.h:20
Int_t GetNedges() const
Definition: TGeoPgon.h:81
virtual const Double_t * GetScale() const
Definition: TGeoMatrix.h:279
A shape scaled by a TGeoScale transformation.
TGeoShape * GetShape() const
TGeoScale * GetScale() const
Base abstract class for all shapes.
Definition: TGeoShape.h:26
virtual const char * GetName() const
Get the shape name.
Definition: TGeoShape.cxx:248
virtual void ComputeBBox()=0
Spherical shell class.
Definition: TGeoSphere.h:18
Double_t GetPhi1() const
Definition: TGeoSphere.h:71
Double_t GetPhi2() const
Definition: TGeoSphere.h:72
virtual Double_t GetRmin() const
Definition: TGeoSphere.h:67
Double_t GetTheta2() const
Definition: TGeoSphere.h:70
virtual Double_t GetRmax() const
Definition: TGeoSphere.h:68
Double_t GetTheta1() const
Definition: TGeoSphere.h:69
Torus segment class.
Definition: TGeoTorus.h:18
Double_t GetRmax() const
Definition: TGeoTorus.h:71
Double_t GetRmin() const
Definition: TGeoTorus.h:70
Double_t GetR() const
Definition: TGeoTorus.h:69
Double_t GetPhi1() const
Definition: TGeoTorus.h:72
Double_t GetDphi() const
Definition: TGeoTorus.h:73
TRAP is a general trapezoid, i.e.
Definition: TGeoArb8.h:92
Double_t GetTl1() const
Definition: TGeoArb8.h:130
Double_t GetPhi() const
Definition: TGeoArb8.h:127
Double_t GetAlpha2() const
Definition: TGeoArb8.h:135
Double_t GetTheta() const
Definition: TGeoArb8.h:126
Double_t GetAlpha1() const
Definition: TGeoArb8.h:131
Double_t GetBl2() const
Definition: TGeoArb8.h:133
Double_t GetTl2() const
Definition: TGeoArb8.h:134
Double_t GetH1() const
Definition: TGeoArb8.h:128
Double_t GetH2() const
Definition: TGeoArb8.h:132
Double_t GetBl1() const
Definition: TGeoArb8.h:129
A trapezoid with only x length varying with z.
Definition: TGeoTrd1.h:18
Double_t GetDy() const
Definition: TGeoTrd1.h:57
Double_t GetDx2() const
Definition: TGeoTrd1.h:56
Double_t GetDz() const
Definition: TGeoTrd1.h:58
Double_t GetDx1() const
Definition: TGeoTrd1.h:55
A trapezoid with both x and y lengths varying with z.
Definition: TGeoTrd2.h:18
Double_t GetDy2() const
Definition: TGeoTrd2.h:59
Double_t GetDy1() const
Definition: TGeoTrd2.h:58
Double_t GetDx2() const
Definition: TGeoTrd2.h:57
Double_t GetDz() const
Definition: TGeoTrd2.h:60
Double_t GetDx1() const
Definition: TGeoTrd2.h:56
A phi segment of a tube.
Definition: TGeoTube.h:89
Double_t GetPhi2() const
Definition: TGeoTube.h:149
Double_t GetPhi1() const
Definition: TGeoTube.h:148
Cylindrical tube class.
Definition: TGeoTube.h:18
virtual Double_t GetRmin() const
Definition: TGeoTube.h:66
virtual Double_t GetDz() const
Definition: TGeoTube.h:68
virtual Double_t GetRmax() const
Definition: TGeoTube.h:67
Bridge class for using a VecGeom solid as TGeoShape.
Definition: TGeoVGShape.h:31
static vecgeom::cxx::VPlacedVolume * CreateVecGeomSolid(TGeoShape *shape)
Conversion method to create VecGeom solid corresponding to TGeoShape.
Definition: TGeoVGShape.cxx:93
static TGeoVGShape * Create(TGeoShape *shape)
Factory creating TGeoVGShape from a Root shape.
Definition: TGeoVGShape.cxx:83
virtual void ComputeBBox()
Compute bounding box.
TGeoShape * fShape
Definition: TGeoVGShape.h:34
virtual Bool_t Contains(const Double_t *point) const
Test if point is inside this shape.
virtual void ComputeNormal(const Double_t *point, const Double_t *dir, Double_t *norm)
Normal computation.
virtual ~TGeoVGShape()
Destructor.
Definition: TGeoVGShape.cxx:73
virtual Double_t Capacity() const
Returns analytic capacity of the solid.
vecgeom::cxx::VPlacedVolume * fVGShape
Definition: TGeoVGShape.h:33
virtual Double_t DistFromOutside(const Double_t *point, const Double_t *dir, Int_t iact=1, Double_t step=TGeoShape::Big(), Double_t *safe=0) const
Compute distance from outside point to surface of the box.
virtual void InspectShape() const
Print info about the VecGeom solid.
virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const
Computes the closest distance from given point to this shape.
virtual Double_t DistFromInside(const Double_t *point, const Double_t *dir, Int_t iact=1, Double_t step=TGeoShape::Big(), Double_t *safe=0) const
Compute distance from inside point to surface of the box.
static vecgeom::cxx::Transformation3D * Convert(TGeoMatrix const *const geomatrix)
Convert a TGeoMatrix to a TRansformation3D.
An extrusion with fixed outline shape in x-y and a sequence of z extents (segments).
Definition: TGeoXtru.h:22
Double_t * GetZ() const
Definition: TGeoXtru.h:100
Int_t GetNvert() const
Definition: TGeoXtru.h:94
Double_t GetY(Int_t i) const
Definition: TGeoXtru.h:96
Int_t GetNz() const
Definition: TGeoXtru.h:93
Double_t GetX(Int_t i) const
Definition: TGeoXtru.h:95
virtual const char * ClassName() const
Returns name of class to which the object belongs.
Definition: TObject.cxx:128
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition: fillpatterns.C:1
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
std::string GetName(const std::string &scope_name)
Definition: Cppyy.cxx:150
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
RooCmdArg Precision(Double_t prec)