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