| 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 //
>> 27 // $Id$
>> 28 //
>> 29 // --------------------------------------------------------------------
>> 30 // GEANT 4 inline definitions file
>> 31 //
>> 32 // G4Sphere.icc
>> 33 //
26 // Implementation of inline methods of G4Spher 34 // Implementation of inline methods of G4Sphere
27 // ------------------------------------------- 35 // --------------------------------------------------------------------
28 36
29 inline 37 inline
>> 38 G4double G4Sphere::GetInsideRadius() const
>> 39 {
>> 40 return fRmin;
>> 41 }
>> 42
>> 43 inline
30 G4double G4Sphere::GetInnerRadius() const 44 G4double G4Sphere::GetInnerRadius() const
31 { 45 {
32 return fRmin; 46 return fRmin;
33 } 47 }
34 48
35 inline 49 inline
36 G4double G4Sphere::GetOuterRadius() const 50 G4double G4Sphere::GetOuterRadius() const
37 { 51 {
38 return fRmax; 52 return fRmax;
39 } 53 }
40 54
41 inline 55 inline
42 G4double G4Sphere::GetStartPhiAngle() const 56 G4double G4Sphere::GetStartPhiAngle() const
43 { 57 {
44 return fSPhi; 58 return fSPhi;
45 } 59 }
46 60
47 inline 61 inline
48 G4double G4Sphere::GetDeltaPhiAngle() const 62 G4double G4Sphere::GetDeltaPhiAngle() const
49 { 63 {
50 return fDPhi; 64 return fDPhi;
51 } 65 }
52 66
53 inline 67 inline
54 G4double G4Sphere::GetStartThetaAngle() const 68 G4double G4Sphere::GetStartThetaAngle() const
55 { 69 {
56 return fSTheta; 70 return fSTheta;
57 } 71 }
58 72
59 G4double G4Sphere::GetDeltaThetaAngle() const 73 G4double G4Sphere::GetDeltaThetaAngle() const
60 { 74 {
61 return fDTheta; 75 return fDTheta;
62 } 76 }
63 77
64 inline 78 inline
65 G4double G4Sphere::GetSinStartPhi () const 79 G4double G4Sphere::GetSinStartPhi () const
66 { 80 {
67 return sinSPhi; 81 return sinSPhi;
68 } 82 }
69 83
70 inline 84 inline
71 G4double G4Sphere::GetCosStartPhi () const 85 G4double G4Sphere::GetCosStartPhi () const
72 { 86 {
73 return cosSPhi; 87 return cosSPhi;
74 } 88 }
75 89
76 inline 90 inline
77 G4double G4Sphere::GetSinEndPhi () const 91 G4double G4Sphere::GetSinEndPhi () const
78 { 92 {
79 return sinEPhi; 93 return sinEPhi;
80 } 94 }
81 95
82 inline 96 inline
83 G4double G4Sphere::GetCosEndPhi () const 97 G4double G4Sphere::GetCosEndPhi () const
84 { 98 {
85 return cosEPhi; 99 return cosEPhi;
86 } 100 }
87 101
88 inline 102 inline
89 G4double G4Sphere::GetSinStartTheta () const 103 G4double G4Sphere::GetSinStartTheta () const
90 { 104 {
91 return sinSTheta; 105 return sinSTheta;
92 } 106 }
93 107
94 inline 108 inline
95 G4double G4Sphere::GetCosStartTheta () const 109 G4double G4Sphere::GetCosStartTheta () const
96 { 110 {
97 return cosSTheta; 111 return cosSTheta;
98 } 112 }
99 113
100 inline 114 inline
101 G4double G4Sphere::GetSinEndTheta () const 115 G4double G4Sphere::GetSinEndTheta () const
102 { 116 {
103 return sinETheta; 117 return sinETheta;
104 } 118 }
105 119
106 inline 120 inline
107 G4double G4Sphere::GetCosEndTheta () const 121 G4double G4Sphere::GetCosEndTheta () const
108 { 122 {
109 return cosETheta; 123 return cosETheta;
110 } 124 }
111 125
112 inline << 126 inline
113 void G4Sphere::Initialize() 127 void G4Sphere::Initialize()
114 { 128 {
115 fCubicVolume = 0.; 129 fCubicVolume = 0.;
116 fSurfaceArea = 0.; 130 fSurfaceArea = 0.;
117 fRebuildPolyhedron = true; 131 fRebuildPolyhedron = true;
118 } 132 }
119 133
120 inline 134 inline
121 void G4Sphere::InitializePhiTrigonometry() 135 void G4Sphere::InitializePhiTrigonometry()
122 { 136 {
123 hDPhi = 0.5*fDPhi; // 137 hDPhi = 0.5*fDPhi; // half delta phi
124 cPhi = fSPhi + hDPhi; << 138 cPhi = fSPhi + hDPhi;
125 ePhi = fSPhi + fDPhi; 139 ePhi = fSPhi + fDPhi;
126 140
127 sinCPhi = std::sin(cPhi); 141 sinCPhi = std::sin(cPhi);
128 cosCPhi = std::cos(cPhi); 142 cosCPhi = std::cos(cPhi);
129 cosHDPhi = std::cos(hDPhi); <<
130 cosHDPhiIT = std::cos(hDPhi - 0.5*kAngTolera 143 cosHDPhiIT = std::cos(hDPhi - 0.5*kAngTolerance); // inner/outer tol half dphi
131 cosHDPhiOT = std::cos(hDPhi + 0.5*kAngTolera 144 cosHDPhiOT = std::cos(hDPhi + 0.5*kAngTolerance);
132 sinSPhi = std::sin(fSPhi); 145 sinSPhi = std::sin(fSPhi);
133 cosSPhi = std::cos(fSPhi); 146 cosSPhi = std::cos(fSPhi);
134 sinEPhi = std::sin(ePhi); 147 sinEPhi = std::sin(ePhi);
135 cosEPhi = std::cos(ePhi); 148 cosEPhi = std::cos(ePhi);
136 } 149 }
137 150
138 inline 151 inline
139 void G4Sphere::InitializeThetaTrigonometry() 152 void G4Sphere::InitializeThetaTrigonometry()
140 { 153 {
141 eTheta = fSTheta + fDTheta; 154 eTheta = fSTheta + fDTheta;
142 155
143 sinSTheta = std::sin(fSTheta); 156 sinSTheta = std::sin(fSTheta);
144 cosSTheta = std::cos(fSTheta); 157 cosSTheta = std::cos(fSTheta);
145 sinETheta = std::sin(eTheta); 158 sinETheta = std::sin(eTheta);
146 cosETheta = std::cos(eTheta); 159 cosETheta = std::cos(eTheta);
147 160
148 tanSTheta = sinSTheta/cosSTheta; << 161 tanSTheta = std::tan(fSTheta);
149 tanSTheta2 = tanSTheta*tanSTheta; 162 tanSTheta2 = tanSTheta*tanSTheta;
150 tanETheta = sinETheta/cosETheta; << 163 tanETheta = std::tan(eTheta);
151 tanETheta2 = tanETheta*tanETheta; 164 tanETheta2 = tanETheta*tanETheta;
152 } 165 }
153 166
154 inline 167 inline
155 void G4Sphere::CheckThetaAngles(G4double sThet 168 void G4Sphere::CheckThetaAngles(G4double sTheta, G4double dTheta)
156 { 169 {
157 if ( (sTheta<0) || (sTheta>CLHEP::pi) ) 170 if ( (sTheta<0) || (sTheta>CLHEP::pi) )
158 { 171 {
159 std::ostringstream message; 172 std::ostringstream message;
160 message << "sTheta outside 0-PI range." << 173 message << "sTheta outside 0-PI range." << G4endl
161 << "Invalid starting Theta angle f 174 << "Invalid starting Theta angle for solid: " << GetName();
162 G4Exception("G4Sphere::CheckThetaAngles()" 175 G4Exception("G4Sphere::CheckThetaAngles()", "GeomSolids0002",
163 FatalException, message); 176 FatalException, message);
164 } 177 }
165 else 178 else
166 { 179 {
167 fSTheta=sTheta; 180 fSTheta=sTheta;
168 } 181 }
169 if ( dTheta+sTheta >= CLHEP::pi ) 182 if ( dTheta+sTheta >= CLHEP::pi )
170 { 183 {
171 fDTheta=CLHEP::pi-sTheta; 184 fDTheta=CLHEP::pi-sTheta;
172 } 185 }
173 else if ( dTheta > 0 ) 186 else if ( dTheta > 0 )
174 { 187 {
175 fDTheta=dTheta; 188 fDTheta=dTheta;
176 } 189 }
177 else 190 else
178 { 191 {
179 std::ostringstream message; 192 std::ostringstream message;
180 message << "Invalid dTheta." << G4endl 193 message << "Invalid dTheta." << G4endl
181 << "Negative delta-Theta (" << dTh 194 << "Negative delta-Theta (" << dTheta << "), for solid: "
182 << GetName(); 195 << GetName();
183 G4Exception("G4Sphere::CheckThetaAngles()" 196 G4Exception("G4Sphere::CheckThetaAngles()", "GeomSolids0002",
184 FatalException, message); 197 FatalException, message);
185 } 198 }
186 fFullThetaSphere = fDTheta-fSTheta >= CLHEP: << 199 if ( fDTheta-fSTheta < CLHEP::pi ) { fFullThetaSphere = false; }
>> 200 else { fFullThetaSphere = true ; }
187 fFullSphere = fFullPhiSphere && fFullThetaSp 201 fFullSphere = fFullPhiSphere && fFullThetaSphere;
188 202
189 InitializeThetaTrigonometry(); 203 InitializeThetaTrigonometry();
190 } 204 }
191 205
192 inline 206 inline
193 void G4Sphere::CheckSPhiAngle(G4double sPhi) 207 void G4Sphere::CheckSPhiAngle(G4double sPhi)
194 { 208 {
195 // Ensure fSphi in 0-2PI or -2PI-0 range if 209 // Ensure fSphi in 0-2PI or -2PI-0 range if shape crosses 0
196 210
197 if ( sPhi < 0 ) 211 if ( sPhi < 0 )
198 { 212 {
199 fSPhi = CLHEP::twopi - std::fmod(std::fabs 213 fSPhi = CLHEP::twopi - std::fmod(std::fabs(sPhi),CLHEP::twopi);
200 } 214 }
201 else 215 else
202 { 216 {
203 fSPhi = std::fmod(sPhi,CLHEP::twopi) ; 217 fSPhi = std::fmod(sPhi,CLHEP::twopi) ;
204 } 218 }
205 if ( fSPhi+fDPhi > CLHEP::twopi ) 219 if ( fSPhi+fDPhi > CLHEP::twopi )
206 { 220 {
207 fSPhi -= CLHEP::twopi ; 221 fSPhi -= CLHEP::twopi ;
208 } 222 }
209 } 223 }
210 224
211 inline 225 inline
212 void G4Sphere::CheckDPhiAngle(G4double dPhi) 226 void G4Sphere::CheckDPhiAngle(G4double dPhi)
213 { 227 {
214 fFullPhiSphere = true; 228 fFullPhiSphere = true;
215 if ( dPhi >= CLHEP::twopi-kAngTolerance*0.5 229 if ( dPhi >= CLHEP::twopi-kAngTolerance*0.5 )
216 { 230 {
217 fDPhi=CLHEP::twopi; 231 fDPhi=CLHEP::twopi;
218 } 232 }
219 else 233 else
220 { 234 {
221 fFullPhiSphere = false; 235 fFullPhiSphere = false;
222 if ( dPhi > 0 ) 236 if ( dPhi > 0 )
223 { 237 {
224 fDPhi = dPhi; 238 fDPhi = dPhi;
225 } 239 }
226 else 240 else
227 { 241 {
228 std::ostringstream message; 242 std::ostringstream message;
229 message << "Invalid dphi." << G4endl 243 message << "Invalid dphi." << G4endl
230 << "Negative delta-Phi (" << dPh 244 << "Negative delta-Phi (" << dPhi << "), for solid: "
231 << GetName(); 245 << GetName();
232 G4Exception("G4Sphere::CheckDPhiAngle()" 246 G4Exception("G4Sphere::CheckDPhiAngle()", "GeomSolids0002",
233 FatalException, message); 247 FatalException, message);
234 } 248 }
235 } 249 }
236 } 250 }
237 251
238 inline 252 inline
239 void G4Sphere::CheckPhiAngles(G4double sPhi, G 253 void G4Sphere::CheckPhiAngles(G4double sPhi, G4double dPhi)
240 { 254 {
241 CheckDPhiAngle(dPhi); 255 CheckDPhiAngle(dPhi);
242 if (!fFullPhiSphere && (sPhi != 0.0)) { Chec << 256 if (!fFullPhiSphere && sPhi) { CheckSPhiAngle(sPhi); }
243 fFullSphere = fFullPhiSphere && fFullThetaSp 257 fFullSphere = fFullPhiSphere && fFullThetaSphere;
244 258
245 InitializePhiTrigonometry(); 259 InitializePhiTrigonometry();
246 } 260 }
247 261
248 inline 262 inline
249 void G4Sphere::SetInnerRadius(G4double newRmin << 263 void G4Sphere::SetInsideRadius(G4double newRmin)
250 { 264 {
251 fRmin= newRmin; 265 fRmin= newRmin;
252 fRminTolerance = (fRmin) != 0.0 ? std::max( << 266 fRminTolerance = (fRmin) ? std::max( kRadTolerance, fEpsilon*fRmin ) : 0;
253 Initialize(); 267 Initialize();
254 } 268 }
255 269
256 inline 270 inline
>> 271 void G4Sphere::SetInnerRadius(G4double newRmin)
>> 272 {
>> 273 SetInsideRadius(newRmin);
>> 274 }
>> 275
>> 276 inline
257 void G4Sphere::SetOuterRadius(G4double newRmax 277 void G4Sphere::SetOuterRadius(G4double newRmax)
258 { 278 {
259 fRmax= newRmax; 279 fRmax= newRmax;
260 fRmaxTolerance = std::max( kRadTolerance, fE 280 fRmaxTolerance = std::max( kRadTolerance, fEpsilon*fRmax );
261 Initialize(); 281 Initialize();
262 } 282 }
263 283
264 inline 284 inline
265 void G4Sphere::SetStartPhiAngle(G4double newSP 285 void G4Sphere::SetStartPhiAngle(G4double newSPhi, G4bool compute)
266 { 286 {
267 // Flag 'compute' can be used to explicitely 287 // Flag 'compute' can be used to explicitely avoid recomputation of
268 // trigonometry in case SetDeltaPhiAngle() i 288 // trigonometry in case SetDeltaPhiAngle() is invoked afterwards
269 289
270 CheckSPhiAngle(newSPhi); 290 CheckSPhiAngle(newSPhi);
271 fFullPhiSphere = false; 291 fFullPhiSphere = false;
272 if (compute) { InitializePhiTrigonometry(); 292 if (compute) { InitializePhiTrigonometry(); }
273 Initialize(); 293 Initialize();
274 } 294 }
275 295
276 inline 296 inline
277 void G4Sphere::SetDeltaPhiAngle(G4double newDP 297 void G4Sphere::SetDeltaPhiAngle(G4double newDPhi)
278 { 298 {
279 CheckPhiAngles(fSPhi, newDPhi); 299 CheckPhiAngles(fSPhi, newDPhi);
280 Initialize(); 300 Initialize();
281 } 301 }
282 302
283 inline 303 inline
284 void G4Sphere::SetStartThetaAngle(G4double new 304 void G4Sphere::SetStartThetaAngle(G4double newSTheta)
285 { 305 {
286 CheckThetaAngles(newSTheta, fDTheta); 306 CheckThetaAngles(newSTheta, fDTheta);
287 Initialize(); 307 Initialize();
288 } 308 }
289 309
290 inline 310 inline
291 void G4Sphere::SetDeltaThetaAngle(G4double new 311 void G4Sphere::SetDeltaThetaAngle(G4double newDTheta)
292 { 312 {
293 CheckThetaAngles(fSTheta, newDTheta); 313 CheckThetaAngles(fSTheta, newDTheta);
294 Initialize(); 314 Initialize();
>> 315 }
>> 316
>> 317 // Old access functions
>> 318
>> 319 inline
>> 320 G4double G4Sphere::GetRmin() const
>> 321 {
>> 322 return GetInsideRadius();
>> 323 }
>> 324
>> 325 inline
>> 326 G4double G4Sphere::GetRmax() const
>> 327 {
>> 328 return GetOuterRadius();
>> 329 }
>> 330
>> 331 inline
>> 332 G4double G4Sphere::GetSPhi() const
>> 333 {
>> 334 return GetStartPhiAngle();
>> 335 }
>> 336
>> 337 inline
>> 338 G4double G4Sphere::GetDPhi() const
>> 339 {
>> 340 return GetDeltaPhiAngle();
>> 341 }
>> 342
>> 343 inline
>> 344 G4double G4Sphere::GetSTheta() const
>> 345 {
>> 346 return GetStartThetaAngle();
>> 347 }
>> 348
>> 349 inline
>> 350 G4double G4Sphere::GetDTheta() const
>> 351 {
>> 352 return GetDeltaThetaAngle();
>> 353 }
>> 354
>> 355 inline
>> 356 G4double G4Sphere::GetCubicVolume()
>> 357 {
>> 358 if(fCubicVolume != 0.) {;}
>> 359 else { fCubicVolume = fDPhi*(std::cos(fSTheta)-std::cos(fSTheta+fDTheta))*
>> 360 (fRmax*fRmax*fRmax-fRmin*fRmin*fRmin)/3.; }
>> 361 return fCubicVolume;
295 } 362 }
296 363