| 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 GetX();
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 202 G4double G4UPara::GetPhi() const
201 { 203 {
202 return std::atan2(fTthetaSphi,fTthetaCphi); 204 return std::atan2(fTthetaSphi,fTthetaCphi);
203 } 205 }
204 206
205 G4double G4UPara::GetTheta() const 207 G4double G4UPara::GetTheta() const
206 { 208 {
207 return std::atan(std::sqrt(fTthetaCphi*fTth 209 return std::atan(std::sqrt(fTthetaCphi*fTthetaCphi
208 +fTthetaSphi*fTt 210 +fTthetaSphi*fTthetaSphi));
209 } 211 }
210 212
211 G4double G4UPara::GetAlpha() const 213 G4double G4UPara::GetAlpha() const
212 { 214 {
213 return std::atan(fTalpha); 215 return std::atan(fTalpha);
214 } 216 }
215 217
216 void G4UPara::SetXHalfLength(G4double val) 218 void G4UPara::SetXHalfLength(G4double val)
217 { 219 {
218 SetDimensions(val, GetY(), GetZ()); 220 SetDimensions(val, GetY(), GetZ());
219 fRebuildPolyhedron = true; 221 fRebuildPolyhedron = true;
220 222
221 CheckParameters(); 223 CheckParameters();
222 MakePlanes(); 224 MakePlanes();
223 } 225 }
224 void G4UPara::SetYHalfLength(G4double val) 226 void G4UPara::SetYHalfLength(G4double val)
225 { 227 {
226 SetDimensions(GetX(), val, GetZ()); 228 SetDimensions(GetX(), val, GetZ());
227 fRebuildPolyhedron = true; 229 fRebuildPolyhedron = true;
228 230
229 CheckParameters(); 231 CheckParameters();
230 MakePlanes(); 232 MakePlanes();
231 } 233 }
232 void G4UPara::SetZHalfLength(G4double val) 234 void G4UPara::SetZHalfLength(G4double val)
233 { 235 {
234 SetDimensions(GetX(), GetY(), val); 236 SetDimensions(GetX(), GetY(), val);
235 fRebuildPolyhedron = true; 237 fRebuildPolyhedron = true;
236 238
237 CheckParameters(); 239 CheckParameters();
238 MakePlanes(); 240 MakePlanes();
239 } 241 }
240 void G4UPara::SetAlpha(G4double alpha) 242 void G4UPara::SetAlpha(G4double alpha)
241 { 243 {
242 Base_t::SetAlpha(alpha); 244 Base_t::SetAlpha(alpha);
243 fTalpha = std::tan(alpha); 245 fTalpha = std::tan(alpha);
244 fRebuildPolyhedron = true; 246 fRebuildPolyhedron = true;
245 247
246 MakePlanes(); 248 MakePlanes();
247 } 249 }
248 void G4UPara::SetTanAlpha(G4double val) 250 void G4UPara::SetTanAlpha(G4double val)
249 { 251 {
250 fTalpha = val; 252 fTalpha = val;
251 fRebuildPolyhedron = true; 253 fRebuildPolyhedron = true;
252 254
253 MakePlanes(); 255 MakePlanes();
254 } 256 }
255 void G4UPara::SetThetaAndPhi(double pTheta, do 257 void G4UPara::SetThetaAndPhi(double pTheta, double pPhi)
256 { 258 {
257 Base_t::SetThetaAndPhi(pTheta, pPhi); 259 Base_t::SetThetaAndPhi(pTheta, pPhi);
258 G4double tanTheta = std::tan(pTheta); 260 G4double tanTheta = std::tan(pTheta);
259 fTthetaCphi = tanTheta*std::cos(pPhi); 261 fTthetaCphi = tanTheta*std::cos(pPhi);
260 fTthetaSphi = tanTheta*std::sin(pPhi); 262 fTthetaSphi = tanTheta*std::sin(pPhi);
261 fRebuildPolyhedron = true; 263 fRebuildPolyhedron = true;
262 264
263 MakePlanes(); 265 MakePlanes();
264 } 266 }
265 267
266 ////////////////////////////////////////////// 268 //////////////////////////////////////////////////////////////////////////
267 // 269 //
268 // Set all parameters, as for constructor - se 270 // Set all parameters, as for constructor - set and check half-widths
269 271
270 void G4UPara::SetAllParameters(G4double pDx, G 272 void G4UPara::SetAllParameters(G4double pDx, G4double pDy, G4double pDz,
271 G4double pAlpha 273 G4double pAlpha, G4double pTheta, G4double pPhi)
272 { 274 {
273 // Reset data of the base class 275 // Reset data of the base class
274 fRebuildPolyhedron = true; 276 fRebuildPolyhedron = true;
275 277
276 // Set parameters 278 // Set parameters
277 SetDimensions(pDx, pDy, pDz); 279 SetDimensions(pDx, pDy, pDz);
278 Base_t::SetAlpha(pAlpha); 280 Base_t::SetAlpha(pAlpha);
279 Base_t::SetThetaAndPhi(pTheta, pPhi); 281 Base_t::SetThetaAndPhi(pTheta, pPhi);
280 fTalpha = std::tan(pAlpha); 282 fTalpha = std::tan(pAlpha);
281 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi 283 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
282 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi 284 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
283 285
284 CheckParameters(); 286 CheckParameters();
285 MakePlanes(); 287 MakePlanes();
286 } 288 }
287 289
288 ////////////////////////////////////////////// 290 //////////////////////////////////////////////////////////////////////////
289 // 291 //
290 // Check dimensions 292 // Check dimensions
291 293
292 void G4UPara::CheckParameters() 294 void G4UPara::CheckParameters()
293 { 295 {
294 if (GetX() < 2*kCarTolerance || 296 if (GetX() < 2*kCarTolerance ||
295 GetY() < 2*kCarTolerance || 297 GetY() < 2*kCarTolerance ||
296 GetZ() < 2*kCarTolerance) 298 GetZ() < 2*kCarTolerance)
297 { 299 {
298 std::ostringstream message; 300 std::ostringstream message;
299 message << "Invalid (too small or negative 301 message << "Invalid (too small or negative) dimensions for Solid: "
300 << GetName() 302 << GetName()
301 << "\n X - " << GetX() 303 << "\n X - " << GetX()
302 << "\n Y - " << GetY() 304 << "\n Y - " << GetY()
303 << "\n Z - " << GetZ(); 305 << "\n Z - " << GetZ();
304 G4Exception("G4UPara::CheckParameters()", 306 G4Exception("G4UPara::CheckParameters()", "GeomSolids0002",
305 FatalException, message); 307 FatalException, message);
306 } 308 }
307 } 309 }
308 310
309 ////////////////////////////////////////////// 311 //////////////////////////////////////////////////////////////////////////
310 // 312 //
311 // Set side planes 313 // Set side planes
312 314
313 void G4UPara::MakePlanes() 315 void G4UPara::MakePlanes()
314 { 316 {
315 G4ThreeVector vx(1, 0, 0); 317 G4ThreeVector vx(1, 0, 0);
316 G4ThreeVector vy(fTalpha, 1, 0); 318 G4ThreeVector vy(fTalpha, 1, 0);
317 G4ThreeVector vz(fTthetaCphi, fTthetaSphi, 1 319 G4ThreeVector vz(fTthetaCphi, fTthetaSphi, 1);
318 320
319 // Set -Y & +Y planes 321 // Set -Y & +Y planes
320 // 322 //
321 G4ThreeVector ynorm = (vx.cross(vz)).unit(); 323 G4ThreeVector ynorm = (vx.cross(vz)).unit();
322 324
323 fPlanes[0].a = 0.; 325 fPlanes[0].a = 0.;
324 fPlanes[0].b = ynorm.y(); 326 fPlanes[0].b = ynorm.y();
325 fPlanes[0].c = ynorm.z(); 327 fPlanes[0].c = ynorm.z();
326 fPlanes[0].d = fPlanes[0].b*GetY(); // point 328 fPlanes[0].d = fPlanes[0].b*GetY(); // point (0,fDy,0) is on plane
327 329
328 fPlanes[1].a = 0.; 330 fPlanes[1].a = 0.;
329 fPlanes[1].b = -fPlanes[0].b; 331 fPlanes[1].b = -fPlanes[0].b;
330 fPlanes[1].c = -fPlanes[0].c; 332 fPlanes[1].c = -fPlanes[0].c;
331 fPlanes[1].d = fPlanes[0].d; 333 fPlanes[1].d = fPlanes[0].d;
332 334
333 // Set -X & +X planes 335 // Set -X & +X planes
334 // 336 //
335 G4ThreeVector xnorm = (vz.cross(vy)).unit(); 337 G4ThreeVector xnorm = (vz.cross(vy)).unit();
336 338
337 fPlanes[2].a = xnorm.x(); 339 fPlanes[2].a = xnorm.x();
338 fPlanes[2].b = xnorm.y(); 340 fPlanes[2].b = xnorm.y();
339 fPlanes[2].c = xnorm.z(); 341 fPlanes[2].c = xnorm.z();
340 fPlanes[2].d = fPlanes[2].a*GetZ(); // point 342 fPlanes[2].d = fPlanes[2].a*GetZ(); // point (fDx,0,0) is on plane
341 343
342 fPlanes[3].a = -fPlanes[2].a; 344 fPlanes[3].a = -fPlanes[2].a;
343 fPlanes[3].b = -fPlanes[2].b; 345 fPlanes[3].b = -fPlanes[2].b;
344 fPlanes[3].c = -fPlanes[2].c; 346 fPlanes[3].c = -fPlanes[2].c;
345 fPlanes[3].d = fPlanes[2].d; 347 fPlanes[3].d = fPlanes[2].d;
346 } 348 }
347 349
348 ////////////////////////////////////////////// 350 //////////////////////////////////////////////////////////////////////////
349 // 351 //
350 // Dispatch to parameterisation for replicatio 352 // Dispatch to parameterisation for replication mechanism dimension
351 // computation & modification 353 // computation & modification
352 354
353 void G4UPara::ComputeDimensions( G4VPVPar 355 void G4UPara::ComputeDimensions( G4VPVParameterisation* p,
354 const G4int n, 356 const G4int n,
355 const G4VPhysi 357 const G4VPhysicalVolume* pRep )
356 { 358 {
357 p->ComputeDimensions(*(G4Para*)this,n,pRep); 359 p->ComputeDimensions(*(G4Para*)this,n,pRep);
358 } 360 }
359 361
360 ////////////////////////////////////////////// 362 //////////////////////////////////////////////////////////////////////////
361 // 363 //
362 // Get bounding box 364 // Get bounding box
363 365
364 void G4UPara::BoundingLimits(G4ThreeVector& pM 366 void G4UPara::BoundingLimits(G4ThreeVector& pMin, G4ThreeVector& pMax) const
365 { 367 {
366 G4double dz = GetZHalfLength(); 368 G4double dz = GetZHalfLength();
367 G4double dx = GetXHalfLength(); 369 G4double dx = GetXHalfLength();
368 G4double dy = GetYHalfLength(); 370 G4double dy = GetYHalfLength();
369 371
370 G4double x0 = dz*fTthetaCphi; 372 G4double x0 = dz*fTthetaCphi;
371 G4double x1 = dy*GetTanAlpha(); 373 G4double x1 = dy*GetTanAlpha();
372 G4double xmin = 374 G4double xmin =
373 std::min( 375 std::min(
374 std::min( 376 std::min(
375 std::min(-x0-x1-dx,-x0+x1-dx),x0-x1-dx),x0 377 std::min(-x0-x1-dx,-x0+x1-dx),x0-x1-dx),x0+x1-dx);
376 G4double xmax = 378 G4double xmax =
377 std::max( 379 std::max(
378 std::max( 380 std::max(
379 std::max(-x0-x1+dx,-x0+x1+dx),x0-x1+dx),x0 381 std::max(-x0-x1+dx,-x0+x1+dx),x0-x1+dx),x0+x1+dx);
380 382
381 G4double y0 = dz*fTthetaSphi; 383 G4double y0 = dz*fTthetaSphi;
382 G4double ymin = std::min(-y0-dy,y0-dy); 384 G4double ymin = std::min(-y0-dy,y0-dy);
383 G4double ymax = std::max(-y0+dy,y0+dy); 385 G4double ymax = std::max(-y0+dy,y0+dy);
384 386
385 pMin.set(xmin,ymin,-dz); 387 pMin.set(xmin,ymin,-dz);
386 pMax.set(xmax,ymax, dz); 388 pMax.set(xmax,ymax, dz);
387 389
388 // Check correctness of the bounding box 390 // Check correctness of the bounding box
389 // 391 //
390 if (pMin.x() >= pMax.x() || pMin.y() >= pMax 392 if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
391 { 393 {
392 std::ostringstream message; 394 std::ostringstream message;
393 message << "Bad bounding box (min >= max) 395 message << "Bad bounding box (min >= max) for solid: "
394 << GetName() << " !" 396 << GetName() << " !"
395 << "\npMin = " << pMin 397 << "\npMin = " << pMin
396 << "\npMax = " << pMax; 398 << "\npMax = " << pMax;
397 G4Exception("G4UPara::BoundingLimits()", " 399 G4Exception("G4UPara::BoundingLimits()", "GeomMgt0001",
398 JustWarning, message); 400 JustWarning, message);
399 StreamInfo(G4cout); 401 StreamInfo(G4cout);
400 } 402 }
401 } 403 }
402 404
403 ////////////////////////////////////////////// 405 //////////////////////////////////////////////////////////////////////////
404 // 406 //
405 // Calculate extent under transform and specif 407 // Calculate extent under transform and specified limit
406 408
407 G4bool G4UPara::CalculateExtent( const EAxis p 409 G4bool G4UPara::CalculateExtent( const EAxis pAxis,
408 const G4Voxel 410 const G4VoxelLimits& pVoxelLimit,
409 const G4Affin 411 const G4AffineTransform& pTransform,
410 G4doubl 412 G4double& pMin, G4double& pMax ) const
411 { 413 {
412 G4ThreeVector bmin, bmax; 414 G4ThreeVector bmin, bmax;
413 G4bool exist; 415 G4bool exist;
414 416
415 // Check bounding box (bbox) 417 // Check bounding box (bbox)
416 // 418 //
417 BoundingLimits(bmin,bmax); 419 BoundingLimits(bmin,bmax);
418 G4BoundingEnvelope bbox(bmin,bmax); 420 G4BoundingEnvelope bbox(bmin,bmax);
419 #ifdef G4BBOX_EXTENT 421 #ifdef G4BBOX_EXTENT
420 if (true) return bbox.CalculateExtent(pAxis, 422 if (true) return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
421 #endif 423 #endif
422 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox 424 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
423 { 425 {
424 return exist = pMin < pMax; << 426 return exist = (pMin < pMax) ? true : false;
425 } 427 }
426 428
427 // Set bounding envelope (benv) and calculat 429 // Set bounding envelope (benv) and calculate extent
428 // 430 //
429 G4double dz = GetZHalfLength(); 431 G4double dz = GetZHalfLength();
430 G4double dx = GetXHalfLength(); 432 G4double dx = GetXHalfLength();
431 G4double dy = GetYHalfLength(); 433 G4double dy = GetYHalfLength();
432 434
433 G4double x0 = dz*fTthetaCphi; 435 G4double x0 = dz*fTthetaCphi;
434 G4double x1 = dy*GetTanAlpha(); 436 G4double x1 = dy*GetTanAlpha();
435 G4double y0 = dz*fTthetaSphi; 437 G4double y0 = dz*fTthetaSphi;
436 438
437 G4ThreeVectorList baseA(4), baseB(4); 439 G4ThreeVectorList baseA(4), baseB(4);
438 baseA[0].set(-x0-x1-dx,-y0-dy,-dz); 440 baseA[0].set(-x0-x1-dx,-y0-dy,-dz);
439 baseA[1].set(-x0-x1+dx,-y0-dy,-dz); 441 baseA[1].set(-x0-x1+dx,-y0-dy,-dz);
440 baseA[2].set(-x0+x1+dx,-y0+dy,-dz); 442 baseA[2].set(-x0+x1+dx,-y0+dy,-dz);
441 baseA[3].set(-x0+x1-dx,-y0+dy,-dz); 443 baseA[3].set(-x0+x1-dx,-y0+dy,-dz);
442 444
443 baseB[0].set(+x0-x1-dx, y0-dy, dz); 445 baseB[0].set(+x0-x1-dx, y0-dy, dz);
444 baseB[1].set(+x0-x1+dx, y0-dy, dz); 446 baseB[1].set(+x0-x1+dx, y0-dy, dz);
445 baseB[2].set(+x0+x1+dx, y0+dy, dz); 447 baseB[2].set(+x0+x1+dx, y0+dy, dz);
446 baseB[3].set(+x0+x1-dx, y0+dy, dz); 448 baseB[3].set(+x0+x1-dx, y0+dy, dz);
447 449
448 std::vector<const G4ThreeVectorList *> polyg 450 std::vector<const G4ThreeVectorList *> polygons(2);
449 polygons[0] = &baseA; 451 polygons[0] = &baseA;
450 polygons[1] = &baseB; 452 polygons[1] = &baseB;
451 453
452 G4BoundingEnvelope benv(bmin,bmax,polygons); 454 G4BoundingEnvelope benv(bmin,bmax,polygons);
453 exist = benv.CalculateExtent(pAxis,pVoxelLim 455 exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
454 return exist; 456 return exist;
455 } 457 }
456 458
457 ////////////////////////////////////////////// 459 //////////////////////////////////////////////////////////////////////////
458 // 460 //
459 // Make a clone of the object 461 // Make a clone of the object
460 // 462 //
461 G4VSolid* G4UPara::Clone() const 463 G4VSolid* G4UPara::Clone() const
462 { 464 {
463 return new G4UPara(*this); 465 return new G4UPara(*this);
464 } 466 }
465 467
466 ////////////////////////////////////////////// 468 //////////////////////////////////////////////////////////////////////////
467 // 469 //
468 // Methods for visualisation 470 // Methods for visualisation
469 471
470 G4Polyhedron* G4UPara::CreatePolyhedron () con 472 G4Polyhedron* G4UPara::CreatePolyhedron () const
471 { 473 {
472 return new G4PolyhedronPara(GetX(), GetY(), 474 return new G4PolyhedronPara(GetX(), GetY(), GetZ(),
473 GetAlpha(), GetT 475 GetAlpha(), GetTheta(), GetPhi());
474 } 476 }
475 477
476 #endif // G4GEOM_USE_USOLIDS 478 #endif // G4GEOM_USE_USOLIDS
477 479