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.2.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.11 2008/11/06 10:55:40 gcosmo Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-02-patch-01 $
                                                   >>  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
                                                   >>  94 void G4Tubs::SetInnerRadius (G4double newRMin)
112 {                                                  95 {
113   // Ensure fSphi in 0-2PI or -2PI-0 range if  <<  96   fRMin= newRMin;
                                                   >>  97   Initialize();
                                                   >>  98 }
114                                                    99 
115   if ( sPhi < 0 )                              << 100 inline
116   {                                            << 101 void G4Tubs::SetOuterRadius (G4double newRMax)
117     fSPhi = CLHEP::twopi - std::fmod(std::fabs << 102 {
118   }                                            << 103   fRMax= newRMax;
119   else                                         << 104   Initialize();
120   {                                            << 
121     fSPhi = std::fmod(sPhi,CLHEP::twopi) ;     << 
122   }                                            << 
123   if ( fSPhi+fDPhi > CLHEP::twopi )            << 
124   {                                            << 
125     fSPhi -= CLHEP::twopi ;                    << 
126   }                                            << 
127 }                                                 105 }
128                                                   106 
129 inline void G4Tubs::CheckDPhiAngle(G4double dP << 107 inline
                                                   >> 108 void G4Tubs::SetZHalfLength (G4double newDz)
130 {                                                 109 {
131   fPhiFullTube = true;                         << 110   fDz= newDz;
132   if ( dPhi >= CLHEP::twopi-kAngTolerance*0.5  << 111   Initialize();
133   {                                            << 
134     fDPhi=CLHEP::twopi;                        << 
135     fSPhi=0;                                   << 
136   }                                            << 
137   else                                         << 
138   {                                            << 
139     fPhiFullTube = false;                      << 
140     if ( dPhi > 0 )                            << 
141     {                                          << 
142       fDPhi = dPhi;                            << 
143     }                                          << 
144     else                                       << 
145     {                                          << 
146       std::ostringstream message;              << 
147       message << "Invalid dphi." << G4endl     << 
148               << "Negative or zero delta-Phi ( << 
149               << GetName();                    << 
150       G4Exception("G4Tubs::CheckDPhiAngle()",  << 
151                   FatalException, message);    << 
152     }                                          << 
153   }                                            << 
154 }                                                 112 }
155                                                   113 
156 inline void G4Tubs::CheckPhiAngles(G4double sP << 114 inline
                                                   >> 115 void G4Tubs::SetStartPhiAngle (G4double newSPhi)
157 {                                                 116 {
158   CheckDPhiAngle(dPhi);                        << 117   fSPhi= newSPhi;
159   if ( (fDPhi<CLHEP::twopi) && ((sPhi) != 0.0) << 118   Initialize();
160   InitializeTrigonometry();                       119   InitializeTrigonometry();
161 }                                                 120 }
162                                                   121 
163 inline                                            122 inline
164 void G4Tubs::SetInnerRadius (G4double newRMin) << 123 void G4Tubs::SetDeltaPhiAngle (G4double newDPhi)
165 {                                                 124 {
166   if ( newRMin < 0 ) // Check radii            << 125   if ( newDPhi >= twopi-kAngTolerance*0.5 )
167   {                                               126   {
168     std::ostringstream message;                << 127     fPhiFullTube = true;
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   }                                               128   }
177   fRMin= newRMin;                              << 129   else if ( newDPhi > 0 )
                                                   >> 130   {
                                                   >> 131     fPhiFullTube = false;
                                                   >> 132   }
                                                   >> 133   else
                                                   >> 134   {
                                                   >> 135      G4cerr << "ERROR - G4Tubs()::SetDeltaPhiAngle() : " << GetName() << G4endl
                                                   >> 136             << "        Negative delta-Phi ! - " << newDPhi << G4endl;
                                                   >> 137      G4Exception("G4Tubs::SetDeltaPhiAngle()", "InvalidSetup",
                                                   >> 138                   FatalException, "Invalid dphi.");
                                                   >> 139   }
                                                   >> 140   fDPhi= newDPhi;
178   Initialize();                                   141   Initialize();
                                                   >> 142   InitializeTrigonometry();
179 }                                                 143 }
180                                                   144 
                                                   >> 145 //  Older names for access functions
                                                   >> 146 
181 inline                                            147 inline
182 void G4Tubs::SetOuterRadius (G4double newRMax) << 148 G4double G4Tubs::GetRMin () const
183 {                                                 149 {
184   if ( newRMax <= 0 ) // Check radii           << 150   return GetInnerRadius();
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;                              << 
196   Initialize();                                << 
197 }                                                 151 }
198                                                   152 
199 inline                                            153 inline
200 void G4Tubs::SetZHalfLength (G4double newDz)   << 154 G4double G4Tubs::GetRMax () const
201 {                                                 155 {
202   if (newDz<=0) // Check z-len                 << 156   return GetOuterRadius();
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;                                  << 
212   Initialize();                                << 
213 }                                                 157 }
214                                                   158 
215 inline                                            159 inline
216 void G4Tubs::SetStartPhiAngle (G4double newSPh << 160 G4double G4Tubs::GetDz () const
217 {                                                 161 {
218   // Flag 'compute' can be used to explicitely << 162   return GetZHalfLength()  ;
219   // trigonometry in case SetDeltaPhiAngle() i << 163 }
220                                                   164 
221   CheckSPhiAngle(newSPhi);                     << 165 inline
222   fPhiFullTube = false;                        << 166 G4double G4Tubs::GetSPhi () const
223   if (compute)  { InitializeTrigonometry(); }  << 167 {
224   Initialize();                                << 168   return GetStartPhiAngle();
225 }                                                 169 }
226                                                   170 
227 inline                                            171 inline
228 void G4Tubs::SetDeltaPhiAngle (G4double newDPh << 172 G4double G4Tubs::GetDPhi () const
229 {                                                 173 {
230   CheckPhiAngles(fSPhi, newDPhi);              << 174   return GetDeltaPhiAngle();
231   Initialize();                                << 
232 }                                                 175 }
233                                                   176 
234 inline                                            177 inline
235 G4double G4Tubs::GetCubicVolume()                 178 G4double G4Tubs::GetCubicVolume()
236 {                                                 179 {
237   if(fCubicVolume != 0.) {;}                      180   if(fCubicVolume != 0.) {;}
238   else   { fCubicVolume = fDPhi*fDz*(fRMax*fRM    181   else   { fCubicVolume = fDPhi*fDz*(fRMax*fRMax-fRMin*fRMin); }
239   return fCubicVolume;                            182   return fCubicVolume;
240 }                                                 183 }
241                                                   184 
242 inline                                            185 inline
243 G4double G4Tubs::GetSurfaceArea()                 186 G4double G4Tubs::GetSurfaceArea()
244 {                                                 187 {
245   if(fSurfaceArea != 0.) {;}                      188   if(fSurfaceArea != 0.) {;}
246   else                                            189   else
247   {                                               190   {
248     fSurfaceArea = fDPhi*(fRMin+fRMax)*(2*fDz+    191     fSurfaceArea = fDPhi*(fRMin+fRMax)*(2*fDz+fRMax-fRMin);
249     if (!fPhiFullTube)                            192     if (!fPhiFullTube)
250     {                                             193     {
251       fSurfaceArea = fSurfaceArea + 4*fDz*(fRM    194       fSurfaceArea = fSurfaceArea + 4*fDz*(fRMax-fRMin);
252     }                                             195     }
253   }                                               196   }
254   return fSurfaceArea;                            197   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 }                                                 198 }
267                                                   199