| 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 // G4CutTubs.icc
>> 33 //
26 // Implementation of inline methods of G4CutTu 34 // Implementation of inline methods of G4CutTubs
27 // ------------------------------------------- 35 // --------------------------------------------------------------------
28 36
29 inline 37 inline
30 G4double G4CutTubs::GetInnerRadius () const 38 G4double G4CutTubs::GetInnerRadius () const
31 { 39 {
32 return fRMin; 40 return fRMin;
33 } 41 }
34 42
35 inline 43 inline
36 G4double G4CutTubs::GetOuterRadius () const 44 G4double G4CutTubs::GetOuterRadius () const
37 { 45 {
38 return fRMax; 46 return fRMax;
39 } 47 }
40 48
41 inline 49 inline
42 G4double G4CutTubs::GetZHalfLength () const 50 G4double G4CutTubs::GetZHalfLength () const
43 { 51 {
44 return fDz; 52 return fDz;
45 } 53 }
46 54
47 inline 55 inline
48 G4double G4CutTubs::GetStartPhiAngle () const 56 G4double G4CutTubs::GetStartPhiAngle () const
49 { 57 {
50 return fSPhi; 58 return fSPhi;
51 } 59 }
52 60
53 inline 61 inline
54 G4double G4CutTubs::GetDeltaPhiAngle () const 62 G4double G4CutTubs::GetDeltaPhiAngle () const
55 { 63 {
56 return fDPhi; 64 return fDPhi;
57 } 65 }
58 66
59 inline 67 inline
60 G4double G4CutTubs::GetSinStartPhi () const 68 G4double G4CutTubs::GetSinStartPhi () const
61 { 69 {
62 return sinSPhi; 70 return sinSPhi;
63 } 71 }
64 72
65 inline 73 inline
66 G4double G4CutTubs::GetCosStartPhi () const 74 G4double G4CutTubs::GetCosStartPhi () const
67 { 75 {
68 return cosSPhi; 76 return cosSPhi;
69 } 77 }
70 78
71 inline 79 inline
72 G4double G4CutTubs::GetSinEndPhi () const 80 G4double G4CutTubs::GetSinEndPhi () const
73 { 81 {
74 return sinEPhi; 82 return sinEPhi;
75 } 83 }
76 84
77 inline 85 inline
78 G4double G4CutTubs::GetCosEndPhi () const 86 G4double G4CutTubs::GetCosEndPhi () const
79 { 87 {
80 return cosEPhi; 88 return cosEPhi;
81 } 89 }
82 90
83 inline 91 inline
84 G4ThreeVector G4CutTubs::GetLowNorm () const 92 G4ThreeVector G4CutTubs::GetLowNorm () const
85 { 93 {
86 return fLowNorm; 94 return fLowNorm;
87 } 95 }
88 96
89 inline 97 inline
90 G4ThreeVector G4CutTubs::GetHighNorm () const 98 G4ThreeVector G4CutTubs::GetHighNorm () const
91 { 99 {
92 return fHighNorm; 100 return fHighNorm;
93 } 101 }
94 102
95 inline 103 inline
96 void G4CutTubs::Initialize() 104 void G4CutTubs::Initialize()
97 { 105 {
98 fZMin = 0.; <<
99 fZMax = 0.; <<
100 fCubicVolume = 0.; 106 fCubicVolume = 0.;
101 fSurfaceArea = 0.; 107 fSurfaceArea = 0.;
102 fRebuildPolyhedron = true; 108 fRebuildPolyhedron = true;
103 } 109 }
104 110
105 inline 111 inline
106 void G4CutTubs::InitializeTrigonometry() 112 void G4CutTubs::InitializeTrigonometry()
107 { 113 {
108 G4double hDPhi = 0.5*fDPhi; 114 G4double hDPhi = 0.5*fDPhi; // half delta phi
109 G4double cPhi = fSPhi + hDPhi; 115 G4double cPhi = fSPhi + hDPhi;
110 G4double ePhi = fSPhi + fDPhi; 116 G4double ePhi = fSPhi + fDPhi;
111 117
112 sinCPhi = std::sin(cPhi); 118 sinCPhi = std::sin(cPhi);
113 cosCPhi = std::cos(cPhi); 119 cosCPhi = std::cos(cPhi);
114 cosHDPhi = std::cos(hDPhi); <<
115 cosHDPhiIT = std::cos(hDPhi - 0.5*kAngTolera 120 cosHDPhiIT = std::cos(hDPhi - 0.5*kAngTolerance); // inner/outer tol half dphi
116 cosHDPhiOT = std::cos(hDPhi + 0.5*kAngTolera 121 cosHDPhiOT = std::cos(hDPhi + 0.5*kAngTolerance);
117 sinSPhi = std::sin(fSPhi); 122 sinSPhi = std::sin(fSPhi);
118 cosSPhi = std::cos(fSPhi); 123 cosSPhi = std::cos(fSPhi);
119 sinEPhi = std::sin(ePhi); 124 sinEPhi = std::sin(ePhi);
120 cosEPhi = std::cos(ePhi); 125 cosEPhi = std::cos(ePhi);
121 } 126 }
122 127
123 inline void G4CutTubs::CheckSPhiAngle(G4double 128 inline void G4CutTubs::CheckSPhiAngle(G4double sPhi)
124 { 129 {
125 // Ensure fSphi in 0-2PI or -2PI-0 range if 130 // Ensure fSphi in 0-2PI or -2PI-0 range if shape crosses 0
126 131
127 if ( sPhi < 0 ) 132 if ( sPhi < 0 )
128 { 133 {
129 fSPhi = CLHEP::twopi - std::fmod(std::fabs 134 fSPhi = CLHEP::twopi - std::fmod(std::fabs(sPhi),CLHEP::twopi);
130 } 135 }
131 else 136 else
132 { 137 {
133 fSPhi = std::fmod(sPhi,CLHEP::twopi) ; 138 fSPhi = std::fmod(sPhi,CLHEP::twopi) ;
134 } 139 }
135 if ( fSPhi+fDPhi > CLHEP::twopi ) 140 if ( fSPhi+fDPhi > CLHEP::twopi )
136 { 141 {
137 fSPhi -= CLHEP::twopi ; 142 fSPhi -= CLHEP::twopi ;
138 } 143 }
139 } 144 }
140 145
141 inline void G4CutTubs::CheckDPhiAngle(G4double 146 inline void G4CutTubs::CheckDPhiAngle(G4double dPhi)
142 { 147 {
143 fPhiFullCutTube = true; 148 fPhiFullCutTube = true;
144 if ( dPhi >= CLHEP::twopi-kAngTolerance*0.5 149 if ( dPhi >= CLHEP::twopi-kAngTolerance*0.5 )
145 { 150 {
146 fDPhi=CLHEP::twopi; 151 fDPhi=CLHEP::twopi;
147 fSPhi=0; 152 fSPhi=0;
148 } 153 }
149 else 154 else
150 { 155 {
151 fPhiFullCutTube = false; 156 fPhiFullCutTube = false;
152 if ( dPhi > 0 ) 157 if ( dPhi > 0 )
153 { 158 {
154 fDPhi = dPhi; 159 fDPhi = dPhi;
155 } 160 }
156 else 161 else
157 { 162 {
158 std::ostringstream message; 163 std::ostringstream message;
159 message << "Invalid dphi." << G4endl 164 message << "Invalid dphi." << G4endl
160 << "Negative or zero delta-Phi ( 165 << "Negative or zero delta-Phi (" << dPhi << "), for solid: "
161 << GetName(); 166 << GetName();
162 G4Exception("G4CutTubs::CheckDPhiAngle() 167 G4Exception("G4CutTubs::CheckDPhiAngle()", "GeomSolids0002",
163 FatalException, message); 168 FatalException, message);
164 } 169 }
165 } 170 }
166 } 171 }
167 172
168 inline void G4CutTubs::CheckPhiAngles(G4double 173 inline void G4CutTubs::CheckPhiAngles(G4double sPhi, G4double dPhi)
169 { 174 {
170 CheckDPhiAngle(dPhi); 175 CheckDPhiAngle(dPhi);
171 if ( (fDPhi<CLHEP::twopi) && ((sPhi) != 0.0) << 176 if ( (fDPhi<CLHEP::twopi) && (sPhi) ) { CheckSPhiAngle(sPhi); }
172 InitializeTrigonometry(); 177 InitializeTrigonometry();
173 } 178 }
174 179
175 inline 180 inline
176 void G4CutTubs::SetInnerRadius (G4double newRM 181 void G4CutTubs::SetInnerRadius (G4double newRMin)
177 { 182 {
178 if ( newRMin < 0 ) // Check radii 183 if ( newRMin < 0 ) // Check radii
179 { 184 {
180 std::ostringstream message; 185 std::ostringstream message;
181 message << "Invalid radii." << G4endl 186 message << "Invalid radii." << G4endl
182 << "Invalid values for radii in so 187 << "Invalid values for radii in solid " << GetName() << G4endl
183 << " newRMin = " << newRMin 188 << " newRMin = " << newRMin
184 << ", fRMax = " << fRMax << G4endl 189 << ", fRMax = " << fRMax << G4endl
185 << " Negative inner radius! 190 << " Negative inner radius!";
186 G4Exception("G4CutTubs::SetInnerRadius()", 191 G4Exception("G4CutTubs::SetInnerRadius()", "GeomSolids0002",
187 FatalException, message); 192 FatalException, message);
188 } 193 }
189 fRMin= newRMin; 194 fRMin= newRMin;
190 Initialize(); 195 Initialize();
191 } 196 }
192 197
193 inline 198 inline
194 void G4CutTubs::SetOuterRadius (G4double newRM 199 void G4CutTubs::SetOuterRadius (G4double newRMax)
195 { 200 {
196 if ( newRMax <= 0 ) // Check radii 201 if ( newRMax <= 0 ) // Check radii
197 { 202 {
198 std::ostringstream message; 203 std::ostringstream message;
199 message << "Invalid radii." << G4endl 204 message << "Invalid radii." << G4endl
200 << "Invalid values for radii in so 205 << "Invalid values for radii in solid " << GetName() << G4endl
201 << " fRMin = " << fRMin 206 << " fRMin = " << fRMin
202 << ", newRMax = " << newRMax << G4 207 << ", newRMax = " << newRMax << G4endl
203 << " Invalid outer radius!" 208 << " Invalid outer radius!";
204 G4Exception("G4CutTubs::SetOuterRadius()", 209 G4Exception("G4CutTubs::SetOuterRadius()", "GeomSolids0002",
205 FatalException, message); 210 FatalException, message);
206 } 211 }
207 fRMax= newRMax; 212 fRMax= newRMax;
208 Initialize(); 213 Initialize();
209 } 214 }
210 215
211 inline 216 inline
212 void G4CutTubs::SetZHalfLength (G4double newDz 217 void G4CutTubs::SetZHalfLength (G4double newDz)
213 { 218 {
214 if (newDz<=0) // Check z-len 219 if (newDz<=0) // Check z-len
215 { 220 {
216 std::ostringstream message; 221 std::ostringstream message;
217 message << "Invalid Z half-length." << G4e 222 message << "Invalid Z half-length." << G4endl
218 << "Negative Z half-length (" << n 223 << "Negative Z half-length (" << newDz << "), for solid: "
219 << GetName(); 224 << GetName();
220 G4Exception("G4CutTubs::SetZHalfLength()", 225 G4Exception("G4CutTubs::SetZHalfLength()", "GeomSolids0002",
221 FatalException, message); 226 FatalException, message);
222 } 227 }
223 fDz= newDz; 228 fDz= newDz;
224 Initialize(); 229 Initialize();
225 } 230 }
226 231
227 inline 232 inline
228 void G4CutTubs::SetStartPhiAngle (G4double new 233 void G4CutTubs::SetStartPhiAngle (G4double newSPhi, G4bool compute)
229 { 234 {
230 // Flag 'compute' can be used to explicitely 235 // Flag 'compute' can be used to explicitely avoid recomputation of
231 // trigonometry in case SetDeltaPhiAngle() i 236 // trigonometry in case SetDeltaPhiAngle() is invoked afterwards
232 237
233 CheckSPhiAngle(newSPhi); 238 CheckSPhiAngle(newSPhi);
234 fPhiFullCutTube = false; 239 fPhiFullCutTube = false;
235 if (compute) { InitializeTrigonometry(); } 240 if (compute) { InitializeTrigonometry(); }
236 Initialize(); 241 Initialize();
237 } 242 }
238 243
239 inline 244 inline
240 void G4CutTubs::SetDeltaPhiAngle (G4double new 245 void G4CutTubs::SetDeltaPhiAngle (G4double newDPhi)
241 { 246 {
242 CheckPhiAngles(fSPhi, newDPhi); 247 CheckPhiAngles(fSPhi, newDPhi);
243 Initialize(); 248 Initialize();
>> 249 }
>> 250
>> 251 // Older names for access functions
>> 252
>> 253 inline
>> 254 G4double G4CutTubs::GetRMin () const
>> 255 {
>> 256 return GetInnerRadius();
>> 257 }
>> 258
>> 259 inline
>> 260 G4double G4CutTubs::GetRMax () const
>> 261 {
>> 262 return GetOuterRadius();
>> 263 }
>> 264
>> 265 inline
>> 266 G4double G4CutTubs::GetDz () const
>> 267 {
>> 268 return GetZHalfLength();
>> 269 }
>> 270
>> 271 inline
>> 272 G4double G4CutTubs::GetSPhi () const
>> 273 {
>> 274 return GetStartPhiAngle();
>> 275 }
>> 276
>> 277 inline
>> 278 G4double G4CutTubs::GetDPhi () const
>> 279 {
>> 280 return GetDeltaPhiAngle();
>> 281 }
>> 282
>> 283 inline G4double G4CutTubs::GetCubicVolume()
>> 284 {
>> 285 if (fCubicVolume == 0.) { fCubicVolume = G4VSolid::GetCubicVolume(); }
>> 286 return fCubicVolume;
>> 287 }
>> 288
>> 289 inline G4double G4CutTubs::GetSurfaceArea()
>> 290 {
>> 291 if (fSurfaceArea == 0.) { fSurfaceArea = G4VSolid::GetSurfaceArea(); }
>> 292 return fSurfaceArea;
244 } 293 }
245 294