| 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 G4UCons wrapper class 26 // Implementation for G4UCons wrapper class
27 // 27 //
28 // 30.10.13 G.Cosmo, CERN/PH 28 // 30.10.13 G.Cosmo, CERN/PH
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4Cons.hh" 31 #include "G4Cons.hh"
32 #include "G4UCons.hh" 32 #include "G4UCons.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 "G4GeomTools.hh" 36 #include "G4GeomTools.hh"
37 #include "G4AffineTransform.hh" 37 #include "G4AffineTransform.hh"
38 #include "G4VPVParameterisation.hh" 38 #include "G4VPVParameterisation.hh"
39 #include "G4BoundingEnvelope.hh" 39 #include "G4BoundingEnvelope.hh"
40 40
41 using namespace CLHEP; 41 using namespace CLHEP;
42 42
43 ////////////////////////////////////////////// 43 //////////////////////////////////////////////////////////////////////////
44 // 44 //
45 // constructor - check parameters, convert ang 45 // constructor - check parameters, convert angles so 0<sphi+dpshi<=2_PI
46 // - note if pDPhi>2PI then rese 46 // - note if pDPhi>2PI then reset to 2PI
47 47
48 G4UCons::G4UCons( const G4String& pName, 48 G4UCons::G4UCons( const G4String& pName,
49 G4double pRmin1, G4do 49 G4double pRmin1, G4double pRmax1,
50 G4double pRmin2, G4do 50 G4double pRmin2, G4double pRmax2,
51 G4double pDz, 51 G4double pDz,
52 G4double pSPhi, G4doub 52 G4double pSPhi, G4double pDPhi)
53 : Base_t(pName, pRmin1, pRmax1, pRmin2, pRma 53 : Base_t(pName, pRmin1, pRmax1, pRmin2, pRmax2, pDz, pSPhi, pDPhi)
54 { 54 {
55 } 55 }
56 56
57 ////////////////////////////////////////////// 57 ///////////////////////////////////////////////////////////////////////
58 // 58 //
59 // Fake default constructor - sets only member 59 // Fake default constructor - sets only member data and allocates memory
60 // for usage restri 60 // for usage restricted to object persistency.
61 // 61 //
62 G4UCons::G4UCons( __void__& a ) 62 G4UCons::G4UCons( __void__& a )
63 : Base_t(a) 63 : Base_t(a)
64 { 64 {
65 } 65 }
66 66
67 ////////////////////////////////////////////// 67 ///////////////////////////////////////////////////////////////////////
68 // 68 //
69 // Destructor 69 // Destructor
70 70
71 G4UCons::~G4UCons() = default; << 71 G4UCons::~G4UCons()
>> 72 {
>> 73 }
72 74
73 ////////////////////////////////////////////// 75 //////////////////////////////////////////////////////////////////////////
74 // 76 //
75 // Copy constructor 77 // Copy constructor
76 78
77 G4UCons::G4UCons(const G4UCons& rhs) 79 G4UCons::G4UCons(const G4UCons& rhs)
78 : Base_t(rhs) 80 : Base_t(rhs)
79 { 81 {
80 } 82 }
81 83
82 ////////////////////////////////////////////// 84 //////////////////////////////////////////////////////////////////////////
83 // 85 //
84 // Assignment operator 86 // Assignment operator
85 87
86 G4UCons& G4UCons::operator = (const G4UCons& r 88 G4UCons& G4UCons::operator = (const G4UCons& rhs)
87 { 89 {
88 // Check assignment to self 90 // Check assignment to self
89 // 91 //
90 if (this == &rhs) { return *this; } 92 if (this == &rhs) { return *this; }
91 93
92 // Copy base class data 94 // Copy base class data
93 // 95 //
94 Base_t::operator=(rhs); 96 Base_t::operator=(rhs);
95 97
96 return *this; 98 return *this;
97 } 99 }
98 100
99 ////////////////////////////////////////////// 101 /////////////////////////////////////////////////////////////////////////
100 // 102 //
101 // Accessors and modifiers 103 // Accessors and modifiers
102 104
103 G4double G4UCons::GetInnerRadiusMinusZ() const 105 G4double G4UCons::GetInnerRadiusMinusZ() const
104 { 106 {
105 return GetRmin1(); 107 return GetRmin1();
106 } 108 }
107 G4double G4UCons::GetOuterRadiusMinusZ() const 109 G4double G4UCons::GetOuterRadiusMinusZ() const
108 { 110 {
109 return GetRmax1(); 111 return GetRmax1();
110 } 112 }
111 G4double G4UCons::GetInnerRadiusPlusZ() const 113 G4double G4UCons::GetInnerRadiusPlusZ() const
112 { 114 {
113 return GetRmin2(); 115 return GetRmin2();
114 } 116 }
115 G4double G4UCons::GetOuterRadiusPlusZ() const 117 G4double G4UCons::GetOuterRadiusPlusZ() const
116 { 118 {
117 return GetRmax2(); 119 return GetRmax2();
118 } 120 }
119 G4double G4UCons::GetZHalfLength() const 121 G4double G4UCons::GetZHalfLength() const
120 { 122 {
121 return GetDz(); 123 return GetDz();
122 } 124 }
123 G4double G4UCons::GetStartPhiAngle() const 125 G4double G4UCons::GetStartPhiAngle() const
124 { 126 {
125 return GetSPhi(); 127 return GetSPhi();
126 } 128 }
127 G4double G4UCons::GetDeltaPhiAngle() const 129 G4double G4UCons::GetDeltaPhiAngle() const
128 { 130 {
129 return GetDPhi(); 131 return GetDPhi();
130 } 132 }
131 G4double G4UCons::GetSinStartPhi() const 133 G4double G4UCons::GetSinStartPhi() const
132 { 134 {
133 G4double phi = GetStartPhiAngle(); 135 G4double phi = GetStartPhiAngle();
134 return std::sin(phi); 136 return std::sin(phi);
135 } 137 }
136 G4double G4UCons::GetCosStartPhi() const 138 G4double G4UCons::GetCosStartPhi() const
137 { 139 {
138 G4double phi = GetStartPhiAngle(); 140 G4double phi = GetStartPhiAngle();
139 return std::cos(phi); 141 return std::cos(phi);
140 } 142 }
141 G4double G4UCons::GetSinEndPhi() const 143 G4double G4UCons::GetSinEndPhi() const
142 { 144 {
143 G4double phi = GetStartPhiAngle() + GetDelta 145 G4double phi = GetStartPhiAngle() + GetDeltaPhiAngle();
144 return std::sin(phi); 146 return std::sin(phi);
145 } 147 }
146 G4double G4UCons::GetCosEndPhi() const 148 G4double G4UCons::GetCosEndPhi() const
147 { 149 {
148 G4double phi = GetStartPhiAngle() + GetDelta 150 G4double phi = GetStartPhiAngle() + GetDeltaPhiAngle();
149 return std::cos(phi); 151 return std::cos(phi);
150 } 152 }
151 153
152 void G4UCons::SetInnerRadiusMinusZ(G4double Rm 154 void G4UCons::SetInnerRadiusMinusZ(G4double Rmin1)
153 { 155 {
154 SetRmin1(Rmin1); 156 SetRmin1(Rmin1);
155 fRebuildPolyhedron = true; 157 fRebuildPolyhedron = true;
156 } 158 }
157 void G4UCons::SetOuterRadiusMinusZ(G4double Rm 159 void G4UCons::SetOuterRadiusMinusZ(G4double Rmax1)
158 { 160 {
159 SetRmax1(Rmax1); 161 SetRmax1(Rmax1);
160 fRebuildPolyhedron = true; 162 fRebuildPolyhedron = true;
161 } 163 }
162 void G4UCons::SetInnerRadiusPlusZ(G4double Rmi 164 void G4UCons::SetInnerRadiusPlusZ(G4double Rmin2)
163 { 165 {
164 SetRmin2(Rmin2); 166 SetRmin2(Rmin2);
165 fRebuildPolyhedron = true; 167 fRebuildPolyhedron = true;
166 } 168 }
167 void G4UCons::SetOuterRadiusPlusZ(G4double Rma 169 void G4UCons::SetOuterRadiusPlusZ(G4double Rmax2)
168 { 170 {
169 SetRmax2(Rmax2); 171 SetRmax2(Rmax2);
170 fRebuildPolyhedron = true; 172 fRebuildPolyhedron = true;
171 } 173 }
172 void G4UCons::SetZHalfLength(G4double newDz) 174 void G4UCons::SetZHalfLength(G4double newDz)
173 { 175 {
174 SetDz(newDz); 176 SetDz(newDz);
175 fRebuildPolyhedron = true; 177 fRebuildPolyhedron = true;
176 } 178 }
177 void G4UCons::SetStartPhiAngle(G4double newSPh 179 void G4UCons::SetStartPhiAngle(G4double newSPhi, G4bool)
178 { 180 {
179 SetSPhi(newSPhi); 181 SetSPhi(newSPhi);
180 fRebuildPolyhedron = true; 182 fRebuildPolyhedron = true;
181 } 183 }
182 void G4UCons::SetDeltaPhiAngle(G4double newDPh 184 void G4UCons::SetDeltaPhiAngle(G4double newDPhi)
183 { 185 {
184 SetDPhi(newDPhi); 186 SetDPhi(newDPhi);
185 fRebuildPolyhedron = true; 187 fRebuildPolyhedron = true;
186 } 188 }
187 189
188 ////////////////////////////////////////////// 190 /////////////////////////////////////////////////////////////////////////
189 // 191 //
190 // Dispatch to parameterisation for replicatio 192 // Dispatch to parameterisation for replication mechanism dimension
191 // computation & modification. 193 // computation & modification.
192 194
193 void G4UCons::ComputeDimensions( G4VPVPar 195 void G4UCons::ComputeDimensions( G4VPVParameterisation* p,
194 const G4int 196 const G4int n,
195 const G4VPhysi 197 const G4VPhysicalVolume* pRep )
196 { 198 {
197 p->ComputeDimensions(*(G4Cons*)this,n,pRep); 199 p->ComputeDimensions(*(G4Cons*)this,n,pRep);
198 } 200 }
199 201
200 ////////////////////////////////////////////// 202 //////////////////////////////////////////////////////////////////////////
201 // 203 //
202 // Make a clone of the object 204 // Make a clone of the object
203 205
204 G4VSolid* G4UCons::Clone() const 206 G4VSolid* G4UCons::Clone() const
205 { 207 {
206 return new G4UCons(*this); 208 return new G4UCons(*this);
207 } 209 }
208 210
209 ////////////////////////////////////////////// 211 //////////////////////////////////////////////////////////////////////////
210 // 212 //
211 // Get bounding box 213 // Get bounding box
212 214
213 void G4UCons::BoundingLimits(G4ThreeVector& pM 215 void G4UCons::BoundingLimits(G4ThreeVector& pMin, G4ThreeVector& pMax) const
214 { 216 {
215 static G4bool checkBBox = true; 217 static G4bool checkBBox = true;
216 218
217 G4double rmin = std::min(GetInnerRadiusMinus 219 G4double rmin = std::min(GetInnerRadiusMinusZ(),GetInnerRadiusPlusZ());
218 G4double rmax = std::max(GetOuterRadiusMinus 220 G4double rmax = std::max(GetOuterRadiusMinusZ(),GetOuterRadiusPlusZ());
219 G4double dz = GetZHalfLength(); 221 G4double dz = GetZHalfLength();
220 222
221 // Find bounding box 223 // Find bounding box
222 // 224 //
223 if (GetDeltaPhiAngle() < twopi) 225 if (GetDeltaPhiAngle() < twopi)
224 { 226 {
225 G4TwoVector vmin,vmax; 227 G4TwoVector vmin,vmax;
226 G4GeomTools::DiskExtent(rmin,rmax, 228 G4GeomTools::DiskExtent(rmin,rmax,
227 GetSinStartPhi(),G 229 GetSinStartPhi(),GetCosStartPhi(),
228 GetSinEndPhi(),Get 230 GetSinEndPhi(),GetCosEndPhi(),
229 vmin,vmax); 231 vmin,vmax);
230 pMin.set(vmin.x(),vmin.y(),-dz); 232 pMin.set(vmin.x(),vmin.y(),-dz);
231 pMax.set(vmax.x(),vmax.y(), dz); 233 pMax.set(vmax.x(),vmax.y(), dz);
232 } 234 }
233 else 235 else
234 { 236 {
235 pMin.set(-rmax,-rmax,-dz); 237 pMin.set(-rmax,-rmax,-dz);
236 pMax.set( rmax, rmax, dz); 238 pMax.set( rmax, rmax, dz);
237 } 239 }
238 240
239 // Check correctness of the bounding box 241 // Check correctness of the bounding box
240 // 242 //
241 if (pMin.x() >= pMax.x() || pMin.y() >= pMax 243 if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
242 { 244 {
243 std::ostringstream message; 245 std::ostringstream message;
244 message << "Bad bounding box (min >= max) 246 message << "Bad bounding box (min >= max) for solid: "
245 << GetName() << " !" 247 << GetName() << " !"
246 << "\npMin = " << pMin 248 << "\npMin = " << pMin
247 << "\npMax = " << pMax; 249 << "\npMax = " << pMax;
248 G4Exception("G4UCons::BoundingLimits()", " 250 G4Exception("G4UCons::BoundingLimits()", "GeomMgt0001",
249 JustWarning, message); 251 JustWarning, message);
250 StreamInfo(G4cout); 252 StreamInfo(G4cout);
251 } 253 }
252 254
253 // Check consistency of bounding boxes 255 // Check consistency of bounding boxes
254 // 256 //
255 if (checkBBox) 257 if (checkBBox)
256 { 258 {
257 U3Vector vmin, vmax; 259 U3Vector vmin, vmax;
258 Extent(vmin,vmax); 260 Extent(vmin,vmax);
259 if (std::abs(pMin.x()-vmin.x()) > kCarTole 261 if (std::abs(pMin.x()-vmin.x()) > kCarTolerance ||
260 std::abs(pMin.y()-vmin.y()) > kCarTole 262 std::abs(pMin.y()-vmin.y()) > kCarTolerance ||
261 std::abs(pMin.z()-vmin.z()) > kCarTole 263 std::abs(pMin.z()-vmin.z()) > kCarTolerance ||
262 std::abs(pMax.x()-vmax.x()) > kCarTole 264 std::abs(pMax.x()-vmax.x()) > kCarTolerance ||
263 std::abs(pMax.y()-vmax.y()) > kCarTole 265 std::abs(pMax.y()-vmax.y()) > kCarTolerance ||
264 std::abs(pMax.z()-vmax.z()) > kCarTole 266 std::abs(pMax.z()-vmax.z()) > kCarTolerance)
265 { 267 {
266 std::ostringstream message; 268 std::ostringstream message;
267 message << "Inconsistency in bounding bo 269 message << "Inconsistency in bounding boxes for solid: "
268 << GetName() << " !" 270 << GetName() << " !"
269 << "\nBBox min: wrapper = " << p 271 << "\nBBox min: wrapper = " << pMin << " solid = " << vmin
270 << "\nBBox max: wrapper = " << p 272 << "\nBBox max: wrapper = " << pMax << " solid = " << vmax;
271 G4Exception("G4UCons::BoundingLimits()", 273 G4Exception("G4UCons::BoundingLimits()", "GeomMgt0001",
272 JustWarning, message); 274 JustWarning, message);
273 checkBBox = false; 275 checkBBox = false;
274 } 276 }
275 } 277 }
276 } 278 }
277 279
278 ////////////////////////////////////////////// 280 /////////////////////////////////////////////////////////////////////////
279 // 281 //
280 // Calculate extent under transform and specif 282 // Calculate extent under transform and specified limit
281 283
282 G4bool 284 G4bool
283 G4UCons::CalculateExtent(const EAxis pAxis, 285 G4UCons::CalculateExtent(const EAxis pAxis,
284 const G4VoxelLimits& 286 const G4VoxelLimits& pVoxelLimit,
285 const G4AffineTransfo 287 const G4AffineTransform& pTransform,
286 G4double& pMin, 288 G4double& pMin, G4double& pMax) const
287 { 289 {
288 G4ThreeVector bmin, bmax; 290 G4ThreeVector bmin, bmax;
289 G4bool exist; 291 G4bool exist;
290 292
291 // Get bounding box 293 // Get bounding box
292 BoundingLimits(bmin,bmax); 294 BoundingLimits(bmin,bmax);
293 295
294 // Check bounding box 296 // Check bounding box
295 G4BoundingEnvelope bbox(bmin,bmax); 297 G4BoundingEnvelope bbox(bmin,bmax);
296 #ifdef G4BBOX_EXTENT 298 #ifdef G4BBOX_EXTENT
297 if (true) return bbox.CalculateExtent(pAxis, 299 if (true) return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
298 #endif 300 #endif
299 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVox 301 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
300 { 302 {
301 return exist = pMin < pMax; << 303 return exist = (pMin < pMax) ? true : false;
302 } 304 }
303 305
304 // Get parameters of the solid 306 // Get parameters of the solid
305 G4double rmin1 = GetInnerRadiusMinusZ(); 307 G4double rmin1 = GetInnerRadiusMinusZ();
306 G4double rmax1 = GetOuterRadiusMinusZ(); 308 G4double rmax1 = GetOuterRadiusMinusZ();
307 G4double rmin2 = GetInnerRadiusPlusZ(); 309 G4double rmin2 = GetInnerRadiusPlusZ();
308 G4double rmax2 = GetOuterRadiusPlusZ(); 310 G4double rmax2 = GetOuterRadiusPlusZ();
309 G4double dz = GetZHalfLength(); 311 G4double dz = GetZHalfLength();
310 G4double dphi = GetDeltaPhiAngle(); 312 G4double dphi = GetDeltaPhiAngle();
311 313
312 // Find bounding envelope and calculate exte 314 // Find bounding envelope and calculate extent
313 // 315 //
314 const G4int NSTEPS = 24; // numbe 316 const G4int NSTEPS = 24; // number of steps for whole circle
315 G4double astep = twopi/NSTEPS; // max a 317 G4double astep = twopi/NSTEPS; // max angle for one step
316 G4int ksteps = (dphi <= astep) ? 1 : (G4i 318 G4int ksteps = (dphi <= astep) ? 1 : (G4int)((dphi-deg)/astep) + 1;
317 G4double ang = dphi/ksteps; 319 G4double ang = dphi/ksteps;
318 320
319 G4double sinHalf = std::sin(0.5*ang); 321 G4double sinHalf = std::sin(0.5*ang);
320 G4double cosHalf = std::cos(0.5*ang); 322 G4double cosHalf = std::cos(0.5*ang);
321 G4double sinStep = 2.*sinHalf*cosHalf; 323 G4double sinStep = 2.*sinHalf*cosHalf;
322 G4double cosStep = 1. - 2.*sinHalf*sinHalf; 324 G4double cosStep = 1. - 2.*sinHalf*sinHalf;
323 G4double rext1 = rmax1/cosHalf; 325 G4double rext1 = rmax1/cosHalf;
324 G4double rext2 = rmax2/cosHalf; 326 G4double rext2 = rmax2/cosHalf;
325 327
326 // bounding envelope for full cone without h 328 // bounding envelope for full cone without hole consists of two polygons,
327 // in other cases it is a sequence of quadri 329 // in other cases it is a sequence of quadrilaterals
328 if (rmin1 == 0 && rmin2 == 0 && dphi == twop 330 if (rmin1 == 0 && rmin2 == 0 && dphi == twopi)
329 { 331 {
330 G4double sinCur = sinHalf; 332 G4double sinCur = sinHalf;
331 G4double cosCur = cosHalf; 333 G4double cosCur = cosHalf;
332 334
333 G4ThreeVectorList baseA(NSTEPS),baseB(NSTE 335 G4ThreeVectorList baseA(NSTEPS),baseB(NSTEPS);
334 for (G4int k=0; k<NSTEPS; ++k) 336 for (G4int k=0; k<NSTEPS; ++k)
335 { 337 {
336 baseA[k].set(rext1*cosCur,rext1*sinCur,- 338 baseA[k].set(rext1*cosCur,rext1*sinCur,-dz);
337 baseB[k].set(rext2*cosCur,rext2*sinCur, 339 baseB[k].set(rext2*cosCur,rext2*sinCur, dz);
338 340
339 G4double sinTmp = sinCur; 341 G4double sinTmp = sinCur;
340 sinCur = sinCur*cosStep + cosCur*sinStep 342 sinCur = sinCur*cosStep + cosCur*sinStep;
341 cosCur = cosCur*cosStep - sinTmp*sinStep 343 cosCur = cosCur*cosStep - sinTmp*sinStep;
342 } 344 }
343 std::vector<const G4ThreeVectorList *> pol 345 std::vector<const G4ThreeVectorList *> polygons(2);
344 polygons[0] = &baseA; 346 polygons[0] = &baseA;
345 polygons[1] = &baseB; 347 polygons[1] = &baseB;
346 G4BoundingEnvelope benv(bmin,bmax,polygons 348 G4BoundingEnvelope benv(bmin,bmax,polygons);
347 exist = benv.CalculateExtent(pAxis,pVoxelL 349 exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
348 } 350 }
349 else 351 else
350 { 352 {
351 G4double sinStart = GetSinStartPhi(); 353 G4double sinStart = GetSinStartPhi();
352 G4double cosStart = GetCosStartPhi(); 354 G4double cosStart = GetCosStartPhi();
353 G4double sinEnd = GetSinEndPhi(); 355 G4double sinEnd = GetSinEndPhi();
354 G4double cosEnd = GetCosEndPhi(); 356 G4double cosEnd = GetCosEndPhi();
355 G4double sinCur = sinStart*cosHalf + cos 357 G4double sinCur = sinStart*cosHalf + cosStart*sinHalf;
356 G4double cosCur = cosStart*cosHalf - sin 358 G4double cosCur = cosStart*cosHalf - sinStart*sinHalf;
357 359
358 // set quadrilaterals 360 // set quadrilaterals
359 G4ThreeVectorList pols[NSTEPS+2]; 361 G4ThreeVectorList pols[NSTEPS+2];
360 for (G4int k=0; k<ksteps+2; ++k) pols[k].r 362 for (G4int k=0; k<ksteps+2; ++k) pols[k].resize(4);
361 pols[0][0].set(rmin2*cosStart,rmin2*sinSta 363 pols[0][0].set(rmin2*cosStart,rmin2*sinStart, dz);
362 pols[0][1].set(rmin1*cosStart,rmin1*sinSta 364 pols[0][1].set(rmin1*cosStart,rmin1*sinStart,-dz);
363 pols[0][2].set(rmax1*cosStart,rmax1*sinSta 365 pols[0][2].set(rmax1*cosStart,rmax1*sinStart,-dz);
364 pols[0][3].set(rmax2*cosStart,rmax2*sinSta 366 pols[0][3].set(rmax2*cosStart,rmax2*sinStart, dz);
365 for (G4int k=1; k<ksteps+1; ++k) 367 for (G4int k=1; k<ksteps+1; ++k)
366 { 368 {
367 pols[k][0].set(rmin2*cosCur,rmin2*sinCur 369 pols[k][0].set(rmin2*cosCur,rmin2*sinCur, dz);
368 pols[k][1].set(rmin1*cosCur,rmin1*sinCur 370 pols[k][1].set(rmin1*cosCur,rmin1*sinCur,-dz);
369 pols[k][2].set(rext1*cosCur,rext1*sinCur 371 pols[k][2].set(rext1*cosCur,rext1*sinCur,-dz);
370 pols[k][3].set(rext2*cosCur,rext2*sinCur 372 pols[k][3].set(rext2*cosCur,rext2*sinCur, dz);
371 373
372 G4double sinTmp = sinCur; 374 G4double sinTmp = sinCur;
373 sinCur = sinCur*cosStep + cosCur*sinStep 375 sinCur = sinCur*cosStep + cosCur*sinStep;
374 cosCur = cosCur*cosStep - sinTmp*sinStep 376 cosCur = cosCur*cosStep - sinTmp*sinStep;
375 } 377 }
376 pols[ksteps+1][0].set(rmin2*cosEnd,rmin2*s 378 pols[ksteps+1][0].set(rmin2*cosEnd,rmin2*sinEnd, dz);
377 pols[ksteps+1][1].set(rmin1*cosEnd,rmin1*s 379 pols[ksteps+1][1].set(rmin1*cosEnd,rmin1*sinEnd,-dz);
378 pols[ksteps+1][2].set(rmax1*cosEnd,rmax1*s 380 pols[ksteps+1][2].set(rmax1*cosEnd,rmax1*sinEnd,-dz);
379 pols[ksteps+1][3].set(rmax2*cosEnd,rmax2*s 381 pols[ksteps+1][3].set(rmax2*cosEnd,rmax2*sinEnd, dz);
380 382
381 // set envelope and calculate extent 383 // set envelope and calculate extent
382 std::vector<const G4ThreeVectorList *> pol 384 std::vector<const G4ThreeVectorList *> polygons;
383 polygons.resize(ksteps+2); 385 polygons.resize(ksteps+2);
384 for (G4int k=0; k<ksteps+2; ++k) polygons[ 386 for (G4int k=0; k<ksteps+2; ++k) polygons[k] = &pols[k];
385 G4BoundingEnvelope benv(bmin,bmax,polygons 387 G4BoundingEnvelope benv(bmin,bmax,polygons);
386 exist = benv.CalculateExtent(pAxis,pVoxelL 388 exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
387 } 389 }
388 return exist; 390 return exist;
389 } 391 }
390 392
391 ////////////////////////////////////////////// 393 //////////////////////////////////////////////////////////////////////////
392 // 394 //
393 // Create polyhedron for visualization 395 // Create polyhedron for visualization
394 396
395 G4Polyhedron* G4UCons::CreatePolyhedron() cons 397 G4Polyhedron* G4UCons::CreatePolyhedron() const
396 { 398 {
397 return new G4PolyhedronCons(GetInnerRadiusMi 399 return new G4PolyhedronCons(GetInnerRadiusMinusZ(),
398 GetOuterRadiusMi 400 GetOuterRadiusMinusZ(),
399 GetInnerRadiusPl 401 GetInnerRadiusPlusZ(),
400 GetOuterRadiusPl 402 GetOuterRadiusPlusZ(),
401 GetZHalfLength() 403 GetZHalfLength(),
402 GetStartPhiAngle 404 GetStartPhiAngle(),
403 GetDeltaPhiAngle 405 GetDeltaPhiAngle());
404 } 406 }
405 407
406 #endif // G4GEOM_USE_USOLIDS 408 #endif // G4GEOM_USE_USOLIDS
407 409