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