| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // Implementation for G4UEllipticalTube wrappe 26 // Implementation for G4UEllipticalTube wrapper class
27 // 27 //
28 // 13-08-2019 Gabriele Cosmo, CERN 28 // 13-08-2019 Gabriele Cosmo, CERN
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4EllipticalTube.hh" 31 #include "G4EllipticalTube.hh"
32 #include "G4UEllipticalTube.hh" 32 #include "G4UEllipticalTube.hh"
33 33
34 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G 34 #if ( defined(G4GEOM_USE_USOLIDS) || defined(G4GEOM_USE_PARTIAL_USOLIDS) )
35 35
36 #include "G4AffineTransform.hh" 36 #include "G4AffineTransform.hh"
37 #include "G4VPVParameterisation.hh" 37 #include "G4VPVParameterisation.hh"
38 #include "G4PhysicalConstants.hh" 38 #include "G4PhysicalConstants.hh"
39 #include "G4BoundingEnvelope.hh" 39 #include "G4BoundingEnvelope.hh"
40 #include "G4Polyhedron.hh" 40 #include "G4Polyhedron.hh"
41 41
42 ////////////////////////////////////////////// 42 ////////////////////////////////////////////////////////////////////////
43 // 43 //
44 // Constructor - check & set half widths 44 // Constructor - check & set half widths
45 45
46 46
47 G4UEllipticalTube::G4UEllipticalTube(const G4S 47 G4UEllipticalTube::G4UEllipticalTube(const G4String& pName,
48 G4d 48 G4double dx,
49 G4d 49 G4double dy,
50 G4d 50 G4double dz )
51 : Base_t(pName, dx, dy, dz) 51 : Base_t(pName, dx, dy, dz)
52 { } 52 { }
53 53
54 ////////////////////////////////////////////// 54 //////////////////////////////////////////////////////////////////////////
55 // 55 //
56 // Fake default constructor - sets only member 56 // Fake default constructor - sets only member data and allocates memory
57 // for usage restri 57 // for usage restricted to object persistency.
58 58
59 G4UEllipticalTube::G4UEllipticalTube( __void__ 59 G4UEllipticalTube::G4UEllipticalTube( __void__& a )
60 : Base_t(a) 60 : Base_t(a)
61 { } 61 { }
62 62
63 ////////////////////////////////////////////// 63 //////////////////////////////////////////////////////////////////////////
64 // 64 //
65 // Destructor 65 // Destructor
66 66
67 G4UEllipticalTube::~G4UEllipticalTube() = defa << 67 G4UEllipticalTube::~G4UEllipticalTube() { }
68 68
69 ////////////////////////////////////////////// 69 //////////////////////////////////////////////////////////////////////////
70 // 70 //
71 // Copy constructor 71 // Copy constructor
72 72
73 G4UEllipticalTube::G4UEllipticalTube(const G4U 73 G4UEllipticalTube::G4UEllipticalTube(const G4UEllipticalTube& rhs)
74 : Base_t(rhs) 74 : Base_t(rhs)
75 { } 75 { }
76 76
77 ////////////////////////////////////////////// 77 //////////////////////////////////////////////////////////////////////////
78 // 78 //
79 // Assignment operator 79 // Assignment operator
80 80
81 G4UEllipticalTube& G4UEllipticalTube::operator 81 G4UEllipticalTube& G4UEllipticalTube::operator = (const G4UEllipticalTube& rhs)
82 { 82 {
83 // Check assignment to self 83 // Check assignment to self
84 // 84 //
85 if (this == &rhs) { return *this; } 85 if (this == &rhs) { return *this; }
86 86
87 // Copy base class data 87 // Copy base class data
88 // 88 //
89 Base_t::operator=(rhs); 89 Base_t::operator=(rhs);
90 90
91 return *this; 91 return *this;
92 } 92 }
93 93
94 ////////////////////////////////////////////// 94 //////////////////////////////////////////////////////////////////////////
95 // 95 //
96 // Accessors 96 // Accessors
97 97
98 G4double G4UEllipticalTube::GetDx() const 98 G4double G4UEllipticalTube::GetDx() const
99 { 99 {
100 return Base_t::GetDx(); 100 return Base_t::GetDx();
101 } 101 }
102 102
103 G4double G4UEllipticalTube::GetDy() const 103 G4double G4UEllipticalTube::GetDy() const
104 { 104 {
105 return Base_t::GetDy(); 105 return Base_t::GetDy();
106 } 106 }
107 107
108 G4double G4UEllipticalTube::GetDz() const 108 G4double G4UEllipticalTube::GetDz() const
109 { 109 {
110 return Base_t::GetDz(); 110 return Base_t::GetDz();
111 } 111 }
112 112
113 ////////////////////////////////////////////// 113 //////////////////////////////////////////////////////////////////////////
114 // 114 //
115 // Modifiers 115 // Modifiers
116 116
117 void G4UEllipticalTube::SetDx(G4double dx) 117 void G4UEllipticalTube::SetDx(G4double dx)
118 { 118 {
119 Base_t::SetDx(dx); 119 Base_t::SetDx(dx);
120 } 120 }
121 121
122 void G4UEllipticalTube::SetDy(G4double dy) 122 void G4UEllipticalTube::SetDy(G4double dy)
123 { 123 {
124 Base_t::SetDy(dy); 124 Base_t::SetDy(dy);
125 } 125 }
126 126
127 void G4UEllipticalTube::SetDz(G4double dz) 127 void G4UEllipticalTube::SetDz(G4double dz)
128 { 128 {
129 Base_t::SetDz(dz); 129 Base_t::SetDz(dz);
130 } 130 }
131 131
132 ////////////////////////////////////////////// 132 //////////////////////////////////////////////////////////////////////////
133 // 133 //
134 // Make a clone of the object 134 // Make a clone of the object
135 135
136 G4VSolid* G4UEllipticalTube::Clone() const 136 G4VSolid* G4UEllipticalTube::Clone() const
137 { 137 {
138 return new G4UEllipticalTube(*this); 138 return new G4UEllipticalTube(*this);
139 } 139 }
140 140
141 ////////////////////////////////////////////// 141 //////////////////////////////////////////////////////////////////////////
142 // 142 //
143 // Get bounding box 143 // Get bounding box
144 144
145 void G4UEllipticalTube::BoundingLimits(G4Three 145 void G4UEllipticalTube::BoundingLimits(G4ThreeVector& pMin,
146 G4Three 146 G4ThreeVector& pMax) const
147 { 147 {
148 G4double dx = GetDx(); 148 G4double dx = GetDx();
149 G4double dy = GetDy(); 149 G4double dy = GetDy();
150 G4double dz = GetDz(); 150 G4double dz = GetDz();
151 151
152 pMin.set(-dx,-dy,-dz); 152 pMin.set(-dx,-dy,-dz);
153 pMax.set( dx, dy, dz); 153 pMax.set( dx, dy, dz);
154 } 154 }
155 155
156 ////////////////////////////////////////////// 156 //////////////////////////////////////////////////////////////////////////
157 // 157 //
158 // Calculate extent under transform and specif 158 // Calculate extent under transform and specified limit
159 159
160 G4bool 160 G4bool
161 G4UEllipticalTube::CalculateExtent(const EAxis 161 G4UEllipticalTube::CalculateExtent(const EAxis pAxis,
162 const G4Vox 162 const G4VoxelLimits& pVoxelLimit,
163 const G4Aff 163 const G4AffineTransform& pTransform,
164 G4dou 164 G4double& pMin, G4double& pMax) const
165 { 165 {
166 G4ThreeVector bmin, bmax; 166 G4ThreeVector bmin, bmax;
167 G4bool exist; 167 G4bool exist;
168 168
169 // Check bounding box (bbox) 169 // Check bounding box (bbox)
170 // 170 //
171 BoundingLimits(bmin,bmax); 171 BoundingLimits(bmin,bmax);
172 G4BoundingEnvelope bbox(bmin,bmax); 172 G4BoundingEnvelope bbox(bmin,bmax);
173 #ifdef G4BBOX_EXTENT 173 #ifdef G4BBOX_EXTENT
174 return bbox.CalculateExtent(pAxis,pVoxelLimi 174 return bbox.CalculateExtent(pAxis,pVoxelLimit, pTransform, pMin, pMax);
175 #endif 175 #endif
176 if (bbox.BoundingBoxVsVoxelLimits(pAxis, pVo 176 if (bbox.BoundingBoxVsVoxelLimits(pAxis, pVoxelLimit, pTransform, pMin, pMax))
177 { 177 {
178 return exist = pMin < pMax; << 178 return exist = (pMin < pMax) ? true : false;
179 } 179 }
180 180
181 G4double dx = GetDx(); 181 G4double dx = GetDx();
182 G4double dy = GetDy(); 182 G4double dy = GetDy();
183 G4double dz = GetDz(); 183 G4double dz = GetDz();
184 184
185 // Set bounding envelope (benv) and calculat 185 // Set bounding envelope (benv) and calculate extent
186 // 186 //
187 const G4int NSTEPS = 24; // number of steps 187 const G4int NSTEPS = 24; // number of steps for whole circle
188 G4double ang = twopi/NSTEPS; 188 G4double ang = twopi/NSTEPS;
189 189
190 G4double sinHalf = std::sin(0.5*ang); 190 G4double sinHalf = std::sin(0.5*ang);
191 G4double cosHalf = std::cos(0.5*ang); 191 G4double cosHalf = std::cos(0.5*ang);
192 G4double sinStep = 2.*sinHalf*cosHalf; 192 G4double sinStep = 2.*sinHalf*cosHalf;
193 G4double cosStep = 1. - 2.*sinHalf*sinHalf; 193 G4double cosStep = 1. - 2.*sinHalf*sinHalf;
194 G4double sx = dx/cosHalf; 194 G4double sx = dx/cosHalf;
195 G4double sy = dy/cosHalf; 195 G4double sy = dy/cosHalf;
196 196
197 G4double sinCur = sinHalf; 197 G4double sinCur = sinHalf;
198 G4double cosCur = cosHalf; 198 G4double cosCur = cosHalf;
199 G4ThreeVectorList baseA(NSTEPS), baseB(NSTEP 199 G4ThreeVectorList baseA(NSTEPS), baseB(NSTEPS);
200 for (G4int k=0; k<NSTEPS; ++k) 200 for (G4int k=0; k<NSTEPS; ++k)
201 { 201 {
202 baseA[k].set(sx*cosCur,sy*sinCur,-dz); 202 baseA[k].set(sx*cosCur,sy*sinCur,-dz);
203 baseB[k].set(sx*cosCur,sy*sinCur, dz); 203 baseB[k].set(sx*cosCur,sy*sinCur, dz);
204 204
205 G4double sinTmp = sinCur; 205 G4double sinTmp = sinCur;
206 sinCur = sinCur*cosStep + cosCur*sinStep; 206 sinCur = sinCur*cosStep + cosCur*sinStep;
207 cosCur = cosCur*cosStep - sinTmp*sinStep; 207 cosCur = cosCur*cosStep - sinTmp*sinStep;
208 } 208 }
209 209
210 std::vector<const G4ThreeVectorList *> polyg 210 std::vector<const G4ThreeVectorList *> polygons(2);
211 polygons[0] = &baseA; 211 polygons[0] = &baseA;
212 polygons[1] = &baseB; 212 polygons[1] = &baseB;
213 G4BoundingEnvelope benv(bmin, bmax, polygons 213 G4BoundingEnvelope benv(bmin, bmax, polygons);
214 exist = benv.CalculateExtent(pAxis, pVoxelLi 214 exist = benv.CalculateExtent(pAxis, pVoxelLimit, pTransform, pMin, pMax);
215 return exist; 215 return exist;
216 } 216 }
217 217
218 ////////////////////////////////////////////// 218 ////////////////////////////////////////////////////////////////////////
219 // 219 //
220 // CreatePolyhedron 220 // CreatePolyhedron
221 // 221 //
222 G4Polyhedron* G4UEllipticalTube::CreatePolyhed 222 G4Polyhedron* G4UEllipticalTube::CreatePolyhedron() const
223 { 223 {
224 // create cylinder with radius=1... 224 // create cylinder with radius=1...
225 // 225 //
226 G4Polyhedron* eTube = new G4PolyhedronTube(0 226 G4Polyhedron* eTube = new G4PolyhedronTube(0., 1., GetDz());
227 227
228 // apply non-uniform scaling... 228 // apply non-uniform scaling...
229 // 229 //
230 eTube->Transform(G4Scale3D(GetDx(), GetDy(), 230 eTube->Transform(G4Scale3D(GetDx(), GetDy(), 1.));
231 return eTube; 231 return eTube;
232 } 232 }
233 233
234 #endif // G4GEOM_USE_USOLIDS 234 #endif // G4GEOM_USE_USOLIDS
235 235