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 9.3.p2)


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