| 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 G4UPara wrapper class 26 // Implementation for G4UPara wrapper class
27 // 27 //
28 // 13.09.13 G.Cosmo, CERN/PH 28 // 13.09.13 G.Cosmo, CERN/PH
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4Para.hh" 31 #include "G4Para.hh"
32 #include "G4UPara.hh" 32 #include "G4UPara.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 "G4BoundingEnvelope.hh" 38 #include "G4BoundingEnvelope.hh"
39 39
40 using namespace CLHEP; 40 using namespace CLHEP;
41 41
42 ////////////////////////////////////////////// 42 //////////////////////////////////////////////////////////////////////////
43 // 43 //
44 // Constructor - set & check half widths 44 // Constructor - set & check half widths
45 45
46 G4UPara::G4UPara(const G4String& pName, 46 G4UPara::G4UPara(const G4String& pName,
47 G4double pDx, G4double 47 G4double pDx, G4double pDy, G4double pDz,
48 G4double pAlpha, G4doub 48 G4double pAlpha, G4double pTheta, G4double pPhi)
49 : Base_t(pName, pDx, pDy, pDz, pAlpha, pThet 49 : Base_t(pName, pDx, pDy, pDz, pAlpha, pTheta, pPhi)
50 { 50 {
51 fTalpha = std::tan(pAlpha); 51 fTalpha = std::tan(pAlpha);
52 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi 52 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
53 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi 53 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
54 CheckParameters(); 54 CheckParameters();
55 MakePlanes(); 55 MakePlanes();
56 } 56 }
57 57
58 ////////////////////////////////////////////// 58 //////////////////////////////////////////////////////////////////////////
59 // 59 //
60 // Constructor - design of trapezoid based on 60 // Constructor - design of trapezoid based on 8 vertices
61 61
62 G4UPara::G4UPara( const G4String& pName, 62 G4UPara::G4UPara( const G4String& pName,
63 const G4ThreeVector pt[8] ) 63 const G4ThreeVector pt[8] )
64 : Base_t(pName) 64 : Base_t(pName)
65 { 65 {
66 // Find dimensions and trigonometric values 66 // Find dimensions and trigonometric values
67 // 67 //
68 G4double fDx = (pt[3].x() - pt[2].x())*0.5; 68 G4double fDx = (pt[3].x() - pt[2].x())*0.5;
69 G4double fDy = (pt[2].y() - pt[1].y())*0.5; 69 G4double fDy = (pt[2].y() - pt[1].y())*0.5;
70 G4double fDz = pt[7].z(); 70 G4double fDz = pt[7].z();
71 SetDimensions(fDx, fDy, fDz); 71 SetDimensions(fDx, fDy, fDz);
72 CheckParameters(); // check dimensions 72 CheckParameters(); // check dimensions
73 73
74 fTalpha = (pt[2].x() + pt[3].x() - pt[1].x() 74 fTalpha = (pt[2].x() + pt[3].x() - pt[1].x() - pt[0].x())*0.25/fDy;
75 fTthetaCphi = (pt[4].x() + fDy*fTalpha + fDx 75 fTthetaCphi = (pt[4].x() + fDy*fTalpha + fDx)/fDz;
76 fTthetaSphi = (pt[4].y() + fDy)/fDz; 76 fTthetaSphi = (pt[4].y() + fDy)/fDz;
77 SetAlpha(std::atan(fTalpha)); 77 SetAlpha(std::atan(fTalpha));
78 SetTheta(std::atan(std::sqrt(fTthetaSphi*fTt 78 SetTheta(std::atan(std::sqrt(fTthetaSphi*fTthetaSphi
79 + fTthetaCphi*fT 79 + fTthetaCphi*fTthetaCphi)));
80 SetPhi (std::atan2(fTthetaSphi, fTthetaCphi) 80 SetPhi (std::atan2(fTthetaSphi, fTthetaCphi));
81 MakePlanes(); 81 MakePlanes();
82 82
83 // Recompute vertices 83 // Recompute vertices
84 // 84 //
85 G4ThreeVector v[8]; 85 G4ThreeVector v[8];
86 G4double DyTalpha = fDy*fTalpha; 86 G4double DyTalpha = fDy*fTalpha;
87 G4double DzTthetaSphi = fDz*fTthetaSphi; 87 G4double DzTthetaSphi = fDz*fTthetaSphi;
88 G4double DzTthetaCphi = fDz*fTthetaCphi; 88 G4double DzTthetaCphi = fDz*fTthetaCphi;
89 v[0].set(-DzTthetaCphi-DyTalpha-fDx, -DzTthe 89 v[0].set(-DzTthetaCphi-DyTalpha-fDx, -DzTthetaSphi-fDy, -fDz);
90 v[1].set(-DzTthetaCphi-DyTalpha+fDx, -DzTthe 90 v[1].set(-DzTthetaCphi-DyTalpha+fDx, -DzTthetaSphi-fDy, -fDz);
91 v[2].set(-DzTthetaCphi+DyTalpha-fDx, -DzTthe 91 v[2].set(-DzTthetaCphi+DyTalpha-fDx, -DzTthetaSphi+fDy, -fDz);
92 v[3].set(-DzTthetaCphi+DyTalpha+fDx, -DzTthe 92 v[3].set(-DzTthetaCphi+DyTalpha+fDx, -DzTthetaSphi+fDy, -fDz);
93 v[4].set( DzTthetaCphi-DyTalpha-fDx, DzTthe 93 v[4].set( DzTthetaCphi-DyTalpha-fDx, DzTthetaSphi-fDy, fDz);
94 v[5].set( DzTthetaCphi-DyTalpha+fDx, DzTthe 94 v[5].set( DzTthetaCphi-DyTalpha+fDx, DzTthetaSphi-fDy, fDz);
95 v[6].set( DzTthetaCphi+DyTalpha-fDx, DzTthe 95 v[6].set( DzTthetaCphi+DyTalpha-fDx, DzTthetaSphi+fDy, fDz);
96 v[7].set( DzTthetaCphi+DyTalpha+fDx, DzTthe 96 v[7].set( DzTthetaCphi+DyTalpha+fDx, DzTthetaSphi+fDy, fDz);
97 97
98 // Compare with original vertices 98 // Compare with original vertices
99 // 99 //
100 for (G4int i=0; i<8; ++i) 100 for (G4int i=0; i<8; ++i)
101 { 101 {
102 G4double delx = std::abs(pt[i].x() - v[i]. 102 G4double delx = std::abs(pt[i].x() - v[i].x());
103 G4double dely = std::abs(pt[i].y() - v[i]. 103 G4double dely = std::abs(pt[i].y() - v[i].y());
104 G4double delz = std::abs(pt[i].z() - v[i]. 104 G4double delz = std::abs(pt[i].z() - v[i].z());
105 G4double discrepancy = std::max(std::max(d 105 G4double discrepancy = std::max(std::max(delx,dely),delz);
106 if (discrepancy > 0.1*kCarTolerance) 106 if (discrepancy > 0.1*kCarTolerance)
107 { 107 {
108 std::ostringstream message; 108 std::ostringstream message;
109 G4long oldprc = message.precision(16); << 109 G4int oldprc = message.precision(16);
110 message << "Invalid vertice coordinates 110 message << "Invalid vertice coordinates for Solid: " << GetName()
111 << "\nVertix #" << i << ", discr 111 << "\nVertix #" << i << ", discrepancy = " << discrepancy
112 << "\n original : " << pt[i] 112 << "\n original : " << pt[i]
113 << "\n recomputed : " << v[i]; 113 << "\n recomputed : " << v[i];
114 G4cout.precision(oldprc); 114 G4cout.precision(oldprc);
115 G4Exception("G4UPara::G4UPara()", "GeomS 115 G4Exception("G4UPara::G4UPara()", "GeomSolids0002",
116 FatalException, message); 116 FatalException, message);
117 117
118 } 118 }
119 } 119 }
120 } 120 }
121 121
122 ////////////////////////////////////////////// 122 //////////////////////////////////////////////////////////////////////////
123 // 123 //
124 // Fake default constructor - sets only member 124 // Fake default constructor - sets only member data and allocates memory
125 // for usage restri 125 // for usage restricted to object persistency
126 126
127 G4UPara::G4UPara( __void__& a ) 127 G4UPara::G4UPara( __void__& a )
128 : Base_t(a) 128 : Base_t(a)
129 { 129 {
130 SetAllParameters(1., 1., 1., 0., 0., 0.); 130 SetAllParameters(1., 1., 1., 0., 0., 0.);
131 fRebuildPolyhedron = false; 131 fRebuildPolyhedron = false;
132 } 132 }
133 133
134 ////////////////////////////////////////////// 134 //////////////////////////////////////////////////////////////////////////
135 // 135 //
136 // Destructor 136 // Destructor
137 137
138 G4UPara::~G4UPara() = default; << 138 G4UPara::~G4UPara()
>> 139 {
>> 140 }
139 141
140 ////////////////////////////////////////////// 142 //////////////////////////////////////////////////////////////////////////
141 // 143 //
142 // Copy constructor 144 // Copy constructor
143 145
144 G4UPara::G4UPara(const G4UPara& rhs) 146 G4UPara::G4UPara(const G4UPara& rhs)
145 : Base_t(rhs), fTalpha(rhs.fTalpha), 147 : Base_t(rhs), fTalpha(rhs.fTalpha),
146 fTthetaCphi(rhs.fTthetaCphi),fTthetaSphi(r 148 fTthetaCphi(rhs.fTthetaCphi),fTthetaSphi(rhs.fTthetaSphi)
147 { 149 {
148 for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs 150 for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs.fPlanes[i]; }
149 } 151 }
150 152
151 ////////////////////////////////////////////// 153 //////////////////////////////////////////////////////////////////////////
152 // 154 //
153 // Assignment operator 155 // Assignment operator
154 156
155 G4UPara& G4UPara::operator = (const G4UPara& r 157 G4UPara& G4UPara::operator = (const G4UPara& rhs)
156 { 158 {
157 // Check assignment to self 159 // Check assignment to self
158 // 160 //
159 if (this == &rhs) { return *this; } 161 if (this == &rhs) { return *this; }
160 162
161 // Copy base class data 163 // Copy base class data
162 // 164 //
163 Base_t::operator=(rhs); 165 Base_t::operator=(rhs);
164 166
165 // Copy data 167 // Copy data
166 // 168 //
167 fTalpha = rhs.fTalpha; 169 fTalpha = rhs.fTalpha;
168 fTthetaCphi = rhs.fTthetaCphi; 170 fTthetaCphi = rhs.fTthetaCphi;
169 fTthetaSphi = rhs.fTthetaSphi; 171 fTthetaSphi = rhs.fTthetaSphi;
170 for (G4int i=0; i<4; ++i) { fPlanes[i] = rh 172 for (G4int i=0; i<4; ++i) { fPlanes[i] = rhs.fPlanes[i]; }
171 173
172 return *this; 174 return *this;
173 } 175 }
174 176
175 ////////////////////////////////////////////// 177 //////////////////////////////////////////////////////////////////////////
176 // 178 //
177 // Accessors & modifiers 179 // Accessors & modifiers
178 180
179 G4double G4UPara::GetZHalfLength() const 181 G4double G4UPara::GetZHalfLength() const
180 { 182 {
181 return GetZ(); 183 return GetZ();
182 } 184 }
183 G4double G4UPara::GetYHalfLength() const 185 G4double G4UPara::GetYHalfLength() const
184 { 186 {
185 return GetY(); 187 return GetY();
186 } 188 }
187 G4double G4UPara::GetXHalfLength() const 189 G4double G4UPara::GetXHalfLength() const
188 { 190 {
189 return GetX(); << 191 return GetZ();
190 } 192 }
191 G4ThreeVector G4UPara::GetSymAxis() const 193 G4ThreeVector G4UPara::GetSymAxis() const
192 { 194 {
193 return G4ThreeVector(fTthetaCphi,fTthetaSphi 195 return G4ThreeVector(fTthetaCphi,fTthetaSphi,1.).unit();
194 } 196 }
195 G4double G4UPara::GetTanAlpha() const 197 G4double G4UPara::GetTanAlpha() const
196 { 198 {
197 return fTalpha; 199 return fTalpha;
198 } 200 }
199 201
200 G4double G4UPara::GetPhi() const <<
201 { <<
202 return std::atan2(fTthetaSphi,fTthetaCphi); <<
203 } <<
204 <<
205 G4double G4UPara::GetTheta() const <<
206 { <<
207 return std::atan(std::sqrt(fTthetaCphi*fTth <<
208 +fTthetaSphi*fTt <<
209 } <<
210 <<
211 G4double G4UPara::GetAlpha() const <<
212 { <<
213 return std::atan(fTalpha); <<
214 } <<
215 <<
216 void G4UPara::SetXHalfLength(G4double val) 202 void G4UPara::SetXHalfLength(G4double val)
217 { 203 {
218 SetDimensions(val, GetY(), GetZ()); 204 SetDimensions(val, GetY(), GetZ());
219 fRebuildPolyhedron = true; 205 fRebuildPolyhedron = true;
220 206
221 CheckParameters(); 207 CheckParameters();
222 MakePlanes(); 208 MakePlanes();
223 } 209 }
224 void G4UPara::SetYHalfLength(G4double val) 210 void G4UPara::SetYHalfLength(G4double val)
225 { 211 {
226 SetDimensions(GetX(), val, GetZ()); 212 SetDimensions(GetX(), val, GetZ());
227 fRebuildPolyhedron = true; 213 fRebuildPolyhedron = true;
228 214
229 CheckParameters(); 215 CheckParameters();
230 MakePlanes(); 216 MakePlanes();
231 } 217 }
232 void G4UPara::SetZHalfLength(G4double val) 218 void G4UPara::SetZHalfLength(G4double val)
233 { 219 {
234 SetDimensions(GetX(), GetY(), val); 220 SetDimensions(GetX(), GetY(), val);
235 fRebuildPolyhedron = true; 221 fRebuildPolyhedron = true;
236 222
237 CheckParameters(); 223 CheckParameters();
238 MakePlanes(); 224 MakePlanes();
239 } 225 }
240 void G4UPara::SetAlpha(G4double alpha) 226 void G4UPara::SetAlpha(G4double alpha)
241 { 227 {
242 Base_t::SetAlpha(alpha); 228 Base_t::SetAlpha(alpha);
243 fTalpha = std::tan(alpha); 229 fTalpha = std::tan(alpha);
244 fRebuildPolyhedron = true; 230 fRebuildPolyhedron = true;
245 231
246 MakePlanes(); 232 MakePlanes();
247 } 233 }
248 void G4UPara::SetTanAlpha(G4double val) 234 void G4UPara::SetTanAlpha(G4double val)
249 { 235 {
250 fTalpha = val; 236 fTalpha = val;
251 fRebuildPolyhedron = true; 237 fRebuildPolyhedron = true;
252 238
253 MakePlanes(); 239 MakePlanes();
254 } 240 }
255 void G4UPara::SetThetaAndPhi(double pTheta, do 241 void G4UPara::SetThetaAndPhi(double pTheta, double pPhi)
256 { 242 {
257 Base_t::SetThetaAndPhi(pTheta, pPhi); 243 Base_t::SetThetaAndPhi(pTheta, pPhi);
258 G4double tanTheta = std::tan(pTheta); 244 G4double tanTheta = std::tan(pTheta);
259 fTthetaCphi = tanTheta*std::cos(pPhi); 245 fTthetaCphi = tanTheta*std::cos(pPhi);
260 fTthetaSphi = tanTheta*std::sin(pPhi); 246 fTthetaSphi = tanTheta*std::sin(pPhi);
261 fRebuildPolyhedron = true; 247 fRebuildPolyhedron = true;
262 248
263 MakePlanes(); 249 MakePlanes();
264 } 250 }
265 251
266 ////////////////////////////////////////////// 252 //////////////////////////////////////////////////////////////////////////
267 // 253 //
268 // Set all parameters, as for constructor - se 254 // Set all parameters, as for constructor - set and check half-widths
269 255
270 void G4UPara::SetAllParameters(G4double pDx, G 256 void G4UPara::SetAllParameters(G4double pDx, G4double pDy, G4double pDz,
271 G4double pAlpha 257 G4double pAlpha, G4double pTheta, G4double pPhi)
272 { 258 {
273 // Reset data of the base class 259 // Reset data of the base class
274 fRebuildPolyhedron = true; 260 fRebuildPolyhedron = true;
275 261
276 // Set parameters 262 // Set parameters
277 SetDimensions(pDx, pDy, pDz); 263 SetDimensions(pDx, pDy, pDz);
278 Base_t::SetAlpha(pAlpha); 264 Base_t::SetAlpha(pAlpha);
279 Base_t::SetThetaAndPhi(pTheta, pPhi); 265 Base_t::SetThetaAndPhi(pTheta, pPhi);
280 fTalpha = std::tan(pAlpha); 266 fTalpha = std::tan(pAlpha);
281 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi 267 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
282 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi 268 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
283 269
284 CheckParameters(); 270 CheckParameters();
285 MakePlanes(); 271 MakePlanes();
286 } 272 }
287 273
288 ////////////////////////////////////////////// 274 //////////////////////////////////////////////////////////////////////////
289 // 275 //
290 // Check dimensions 276 // Check dimensions
291 277
292 void G4UPara::CheckParameters() 278 void G4UPara::CheckParameters()
293 { 279 {
294 if (GetX() < 2*kCarTolerance || 280 if (GetX() < 2*kCarTolerance ||
295 GetY() < 2*kCarTolerance || 281 GetY() < 2*kCarTolerance ||
296 GetZ() < 2*kCarTolerance) 282 GetZ() < 2*kCarTolerance)
297 { 283 {
298 std::ostringstream message; 284 std::ostringstream message;
299 message << "Invalid (too small or negative 285 message << "Invalid (too small or negative) dimensions for Solid: "
300 << GetName() 286 << GetName()
301 << "\n X - " << GetX() 287 << "\n X - " << GetX()
302 << "\n Y - " << GetY() 288 << "\n Y - " << GetY()
303 << "\n Z - " << GetZ(); 289 << "\n Z - " << GetZ();
304 G4Exception("G4UPara::CheckParameters()", 290 G4Exception("G4UPara::CheckParameters()", "GeomSolids0002",
305 FatalException, message); 291 FatalException, message);
306 } 292 }
307 } 293 }
308 294
309 ////////////////////////////////////////////// 295 //////////////////////////////////////////////////////////////////////////
310 // 296 //
311 // Set side planes 297 // Set side planes
312 298
313 void G4UPara::MakePlanes() 299 void G4UPara::MakePlanes()
314 { 300 {
315 G4ThreeVector vx(1, 0, 0); 301 G4ThreeVector vx(1, 0, 0);
316 G4ThreeVector vy(fTalpha, 1, 0); 302 G4ThreeVector vy(fTalpha, 1, 0);
317 G4ThreeVector vz(fTthetaCphi, fTthetaSphi, 1 303 G4ThreeVector vz(fTthetaCphi, fTthetaSphi, 1);
318 304
319 // Set -Y & +Y planes 305 // Set -Y & +Y planes
320 // 306 //
321 G4ThreeVector ynorm = (vx.cross(vz)).unit(); 307 G4ThreeVector ynorm = (vx.cross(vz)).unit();
322 308
323 fPlanes[0].a = 0.; 309 fPlanes[0].a = 0.;
324 fPlanes[0].b = ynorm.y(); 310 fPlanes[0].b = ynorm.y();
325 fPlanes[0].c = ynorm.z(); 311 fPlanes[0].c = ynorm.z();
326 fPlanes[0].d = fPlanes[0].b*GetY(); // point 312 fPlanes[0].d = fPlanes[0].b*GetY(); // point (0,fDy,0) is on plane
327 313
328 fPlanes[1].a = 0.; 314 fPlanes[1].a = 0.;
329 fPlanes[1].b = -fPlanes[0].b; 315 fPlanes[1].b = -fPlanes[0].b;
330 fPlanes[1].c = -fPlanes[0].c; 316 fPlanes[1].c = -fPlanes[0].c;
331 fPlanes[1].d = fPlanes[0].d; 317 fPlanes[1].d = fPlanes[0].d;
332 318
333 // Set -X & +X planes 319 // Set -X & +X planes
334 // 320 //
335 G4ThreeVector xnorm = (vz.cross(vy)).unit(); 321 G4ThreeVector xnorm = (vz.cross(vy)).unit();
336 322
337 fPlanes[2].a = xnorm.x(); 323 fPlanes[2].a = xnorm.x();
338 fPlanes[2].b = xnorm.y(); 324 fPlanes[2].b = xnorm.y();
339 fPlanes[2].c = xnorm.z(); 325 fPlanes[2].c = xnorm.z();
340 fPlanes[2].d = fPlanes[2].a*GetZ(); // point 326 fPlanes[2].d = fPlanes[2].a*GetZ(); // point (fDx,0,0) is on plane
341 327
342 fPlanes[3].a = -fPlanes[2].a; 328 fPlanes[3].a = -fPlanes[2].a;
343 fPlanes[3].b = -fPlanes[2].b; 329 fPlanes[3].b = -fPlanes[2].b;
344 fPlanes[3].c = -fPlanes[2].c; 330 fPlanes[3].c = -fPlanes[2].c;
345 fPlanes[3].d = fPlanes[2].d; 331 fPlanes[3].d = fPlanes[2].d;
346 } 332 }
347 333
348 ////////////////////////////////////////////// 334 //////////////////////////////////////////////////////////////////////////
349 // 335 //
350 // Dispatch to parameterisation for replicatio 336 // Dispatch to parameterisation for replication mechanism dimension
351 // computation & modification 337 // computation & modification
352 338
353 void G4UPara::ComputeDimensions( G4VPVPar 339 void G4UPara::ComputeDimensions( G4VPVParameterisation* p,
354 const G4int n, 340 const G4int n,
355 const G4VPhysi 341 const G4VPhysicalVolume* pRep )
356 { 342 {
357 p->ComputeDimensions(*(G4Para*)this,n,pRep); 343 p->ComputeDimensions(*(G4Para*)this,n,pRep);
358 } 344 }
359 345
360 ////////////////////////////////////////////// 346 //////////////////////////////////////////////////////////////////////////
361 // 347 //
362 // Get bounding box 348 // Get bounding box
363 349
364 void G4UPara::BoundingLimits(G4ThreeVector& pM 350 void G4UPara::BoundingLimits(G4ThreeVector& pMin, G4ThreeVector& pMax) const
365 { 351 {
366 G4double dz = GetZHalfLength(); 352 G4double dz = GetZHalfLength();
367 G4double dx = GetXHalfLength(); 353 G4double dx = GetXHalfLength();
368 G4double dy = GetYHalfLength(); 354 G4double dy = GetYHalfLength();
369 355
370 G4double x0 = dz*fTthetaCphi; 356 G4double x0 = dz*fTthetaCphi;
371 G4double x1 = dy*GetTanAlpha(); 357 G4double x1 = dy*GetTanAlpha();
372 G4double xmin = 358 G4double xmin =
373 std::min( 359 std::min(
374 std::min( 360 std::min(
375 std::min(-x0-x1-dx,-x0+x1-dx),x0-x1-dx),x0 361 std::min(-x0-x1-dx,-x0+x1-dx),x0-x1-dx),x0+x1-dx);
376 G4double xmax = 362 G4double xmax =
377 std::max( 363 std::max(
378 std::max( 364 std::max(
379 std::max(-x0-x1+dx,-x0+x1+dx),x0-x1+dx),x0 365 std::max(-x0-x1+dx,-x0+x1+dx),x0-x1+dx),x0+x1+dx);
380 366
381 G4double y0 = dz*fTthetaSphi; 367 G4double y0 = dz*fTthetaSphi;
382 G4double ymin = std::min(-y0-dy,y0-dy); 368 G4double ymin = std::min(-y0-dy,y0-dy);
383 G4double ymax = std::max(-y0+dy,y0+dy); 369 G4double ymax = std::max(-y0+dy,y0+dy);
384 370
385 pMin.set(xmin,ymin,-dz); 371 pMin.set(xmin,ymin,-dz);
386 pMax.set(xmax,ymax, dz); 372 pMax.set(xmax,ymax, dz);
387 373
388 // Check correctness of the bounding box 374 // Check correctness of the bounding box
389 // 375 //
390 if (pMin.x() >= pMax.x() || pMin.y() >= pMax 376 if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
391 { 377 {
392 std::ostringstream message; 378 std::ostringstream message;
393 message << "Bad bounding box (min >= max) 379 message << "Bad bounding box (min >= max) for solid: "
394 << GetName() << " !" 380 << GetName() << " !"
395 << "\npMin = " << pMin 381 << "\npMin = " << pMin
396 << "\npMax = " << pMax; 382 << "\npMax = " << pMax;
397 G4Exception("G4UPara::BoundingLimits()", " 383 G4Exception("G4UPara::BoundingLimits()", "GeomMgt0001",
398 JustWarning, message); 384 JustWarning, message);
399 StreamInfo(G4cout); 385 StreamInfo(G4cout);
400 } 386 }
401 } 387 }
402 388
403 ////////////////////////////////////////////// 389 //////////////////////////////////////////////////////////////////////////
404 // 390 //
405 // Calculate extent under transform and specif 391 // Calculate extent under transform and specified limit
406 392
407 G4bool G4UPara::CalculateExtent( const EAxis p 393 G4bool G4UPara::CalculateExtent( const EAxis pAxis,
408 const G4Voxel 394 const G4VoxelLimits& pVoxelLimit,
409 const G4Affin 395 const G4AffineTransform& pTransform,
410 G4doubl 396 G4double& pMin, G4double& pMax ) const
411 { 397 {
412 G4ThreeVector bmin, bmax; 398 G4ThreeVector bmin, bmax;
413 G4bool exist; 399 G4bool exist;
414 400
415 // Check bounding box (bbox) 401 // Check bounding box (bbox)
416 // 402 //
417 BoundingLimits(bmin,bmax); 403 BoundingLimits(bmin,bmax);
418 G4BoundingEnvelope bbox(bmin,bmax); 404 G4BoundingEnvelope bbox(bmin,bmax);
419 #ifdef G4BBOX_EXTENT 405 #ifdef G4BBOX_EXTENT
420 if (true) return bbox.CalculateExtent(pAxis, 406 if (true) return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
421 #endif 407 #endif
422 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox 408 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
423 { 409 {
424 return exist = pMin < pMax; << 410 return exist = (pMin < pMax) ? true : false;
425 } 411 }
426 412
427 // Set bounding envelope (benv) and calculat 413 // Set bounding envelope (benv) and calculate extent
428 // 414 //
429 G4double dz = GetZHalfLength(); 415 G4double dz = GetZHalfLength();
430 G4double dx = GetXHalfLength(); 416 G4double dx = GetXHalfLength();
431 G4double dy = GetYHalfLength(); 417 G4double dy = GetYHalfLength();
432 418
433 G4double x0 = dz*fTthetaCphi; 419 G4double x0 = dz*fTthetaCphi;
434 G4double x1 = dy*GetTanAlpha(); 420 G4double x1 = dy*GetTanAlpha();
435 G4double y0 = dz*fTthetaSphi; 421 G4double y0 = dz*fTthetaSphi;
436 422
437 G4ThreeVectorList baseA(4), baseB(4); 423 G4ThreeVectorList baseA(4), baseB(4);
438 baseA[0].set(-x0-x1-dx,-y0-dy,-dz); 424 baseA[0].set(-x0-x1-dx,-y0-dy,-dz);
439 baseA[1].set(-x0-x1+dx,-y0-dy,-dz); 425 baseA[1].set(-x0-x1+dx,-y0-dy,-dz);
440 baseA[2].set(-x0+x1+dx,-y0+dy,-dz); 426 baseA[2].set(-x0+x1+dx,-y0+dy,-dz);
441 baseA[3].set(-x0+x1-dx,-y0+dy,-dz); 427 baseA[3].set(-x0+x1-dx,-y0+dy,-dz);
442 428
443 baseB[0].set(+x0-x1-dx, y0-dy, dz); 429 baseB[0].set(+x0-x1-dx, y0-dy, dz);
444 baseB[1].set(+x0-x1+dx, y0-dy, dz); 430 baseB[1].set(+x0-x1+dx, y0-dy, dz);
445 baseB[2].set(+x0+x1+dx, y0+dy, dz); 431 baseB[2].set(+x0+x1+dx, y0+dy, dz);
446 baseB[3].set(+x0+x1-dx, y0+dy, dz); 432 baseB[3].set(+x0+x1-dx, y0+dy, dz);
447 433
448 std::vector<const G4ThreeVectorList *> polyg 434 std::vector<const G4ThreeVectorList *> polygons(2);
449 polygons[0] = &baseA; 435 polygons[0] = &baseA;
450 polygons[1] = &baseB; 436 polygons[1] = &baseB;
451 437
452 G4BoundingEnvelope benv(bmin,bmax,polygons); 438 G4BoundingEnvelope benv(bmin,bmax,polygons);
453 exist = benv.CalculateExtent(pAxis,pVoxelLim 439 exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
454 return exist; 440 return exist;
455 } 441 }
456 442
457 ////////////////////////////////////////////// 443 //////////////////////////////////////////////////////////////////////////
458 // 444 //
459 // Make a clone of the object 445 // Make a clone of the object
460 // 446 //
461 G4VSolid* G4UPara::Clone() const 447 G4VSolid* G4UPara::Clone() const
462 { 448 {
463 return new G4UPara(*this); 449 return new G4UPara(*this);
464 } 450 }
465 451
466 ////////////////////////////////////////////// 452 //////////////////////////////////////////////////////////////////////////
467 // 453 //
468 // Methods for visualisation 454 // Methods for visualisation
469 455
470 G4Polyhedron* G4UPara::CreatePolyhedron () con 456 G4Polyhedron* G4UPara::CreatePolyhedron () const
471 { 457 {
472 return new G4PolyhedronPara(GetX(), GetY(), 458 return new G4PolyhedronPara(GetX(), GetY(), GetZ(),
473 GetAlpha(), GetT 459 GetAlpha(), GetTheta(), GetPhi());
474 } 460 }
475 461
476 #endif // G4GEOM_USE_USOLIDS 462 #endif // G4GEOM_USE_USOLIDS
477 463