Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/CSG/include/G4Tubs.icc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /geometry/solids/CSG/include/G4Tubs.icc (Version 11.3.0) and /geometry/solids/CSG/include/G4Tubs.icc (Version 10.4.p3)


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