Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/CSG/include/G4Torus.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/G4Torus.icc (Version 11.3.0) and /geometry/solids/CSG/include/G4Torus.icc (Version 5.2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
                                                   >>  23 //
                                                   >>  24 // $Id: G4Torus.icc,v 1.1 2002/10/28 11:43:04 gcosmo Exp $
                                                   >>  25 // GEANT4 tag $Name: geant4-05-02 $
                                                   >>  26 //
                                                   >>  27 // --------------------------------------------------------------------
                                                   >>  28 // GEANT 4 inline definitions file
                                                   >>  29 //
                                                   >>  30 // G4Torus.icc
                                                   >>  31 //
 26 // Implementation of inline methods of G4Torus     32 // Implementation of inline methods of G4Torus
 27 // -------------------------------------------     33 // --------------------------------------------------------------------
 28                                                    34 
 29 inline                                             35 inline
 30 G4double G4Torus::GetRmin() const                  36 G4double G4Torus::GetRmin() const
 31 {                                                  37 {
 32   return fRmin ;                                   38   return fRmin ;
 33 }                                                  39 }
 34                                                    40 
 35 inline                                             41 inline
 36 G4double G4Torus::GetRmax() const                  42 G4double G4Torus::GetRmax() const
 37 {                                                  43 {
 38   return fRmax ;                                   44   return fRmax ;
 39 }                                                  45 }
 40                                                    46 
 41 inline                                             47 inline
 42 G4double G4Torus::GetRtor() const                  48 G4double G4Torus::GetRtor() const
 43 {                                                  49 {
 44   return fRtor ;                                   50   return fRtor ;
 45 }                                                  51 }
 46                                                    52 
 47 inline                                             53 inline
 48 G4double G4Torus::GetSPhi() const                  54 G4double G4Torus::GetSPhi() const
 49 {                                                  55 {
 50   return fSPhi ;                                   56   return fSPhi ;
 51 }                                                  57 }
 52                                                    58 
 53 inline                                             59 inline
 54 G4double G4Torus::GetDPhi() const                  60 G4double G4Torus::GetDPhi() const
 55 {                                                  61 {
 56   return fDPhi ;                                   62   return fDPhi ;
 57 }                                                  63 }
 58                                                    64 
                                                   >>  65 // Utility functions
                                                   >>  66 
                                                   >>  67 inline
                                                   >>  68 G4double G4Torus::TorusEquation (G4double x, G4double y, G4double z,
                                                   >>  69                                  G4double R0, G4double R1) const
                                                   >>  70 {
                                                   >>  71   // R0 : Radius of all little circles
                                                   >>  72   // R1 : Radius of little circles
                                                   >>  73 
                                                   >>  74   // An interesting property is that the sign
                                                   >>  75   // tell if the point is inside or outside
                                                   >>  76   // or if > EPSILON on the surface
                                                   >>  77 
                                                   >>  78   G4double temp;
                                                   >>  79 
                                                   >>  80   temp = ((x*x + y*y + z*z) + R0*R0 - R1*R1) ;
                                                   >>  81   temp = temp*temp ;
                                                   >>  82   temp = temp - 4*R0*R0*(x*x + y*y) ;
                                                   >>  83 
                                                   >>  84   //  > 0 Outside
                                                   >>  85   //  < 0 Inside
                                                   >>  86 
                                                   >>  87   return temp ;
                                                   >>  88 }
                                                   >>  89 
                                                   >>  90 inline
                                                   >>  91 G4double G4Torus::TorusDerivativeX (G4double x, G4double y, G4double z,
                                                   >>  92                                     G4double R0, G4double R1) const
                                                   >>  93 {
                                                   >>  94   return 4*x*(x*x + y*y + z*z +  R0*R0 - R1*R1) - 8*R0*R0*x ;
                                                   >>  95 }
                                                   >>  96 
                                                   >>  97 inline
                                                   >>  98 G4double G4Torus::TorusDerivativeY (G4double x, G4double y, G4double z,
                                                   >>  99                                     G4double R0, G4double R1) const
                                                   >> 100 {
                                                   >> 101   return 4*y*(x*x + y*y + z*z +  R0*R0 - R1*R1) - 8*R0*R0*y ;
                                                   >> 102 }
                                                   >> 103 
                                                   >> 104 inline
                                                   >> 105 G4double G4Torus::TorusDerivativeZ (G4double x, G4double y, G4double z,
                                                   >> 106                                     G4double R0, G4double R1) const
                                                   >> 107 {
                                                   >> 108   return 4*z*(x*x + y*y + z*z +  R0*R0 - R1*R1) ;
                                                   >> 109 }
                                                   >> 110 
 59 inline                                            111 inline
 60 G4double G4Torus::GetSinStartPhi () const      << 112 G4double G4Torus::TorusGradient(G4double dx, G4double dy, G4double dz,
                                                   >> 113                                 G4double x, G4double y, G4double z,
                                                   >> 114                                 G4double Rmax, G4double Rmin) const
 61 {                                                 115 {
 62   return std::sin(fSPhi);                      << 116   // This tells the normal at a surface point
                                                   >> 117 
                                                   >> 118   G4double result;
                                                   >> 119   result = 0;
                                                   >> 120   result += dx*TorusDerivativeX(x,y,z,Rmax,Rmin); 
                                                   >> 121   result += dy*TorusDerivativeY(x,y,z,Rmax,Rmin); 
                                                   >> 122   result += dz*TorusDerivativeZ(x,y,z,Rmax,Rmin); 
                                                   >> 123 
                                                   >> 124   return result;
 63 }                                                 125 }
 64                                                   126 
                                                   >> 127 // ----------- G4TorusEquation methods ---------------
                                                   >> 128 
 65 inline                                            129 inline
 66 G4double G4Torus::GetCosStartPhi () const      << 130 void G4TorusEquation::setRadius (G4double Rmax, G4double Rmin)    
 67 {                                                 131 {
 68   return std::cos(fSPhi);                      << 132   R0 = Rmax;
                                                   >> 133   R1 = Rmin;
 69 }                                                 134 }
 70                                                   135 
 71 inline                                            136 inline
 72 G4double G4Torus::GetSinEndPhi () const        << 137 void G4TorusEquation::setPosition (G4double x,G4double y,G4double z)
 73 {                                                 138 {
 74   return std::sin(fSPhi+fDPhi);                << 139   Px = x;
                                                   >> 140   Py = y;
                                                   >> 141   Pz = z;
 75 }                                                 142 }
 76                                                   143 
 77 inline                                            144 inline
 78 G4double G4Torus::GetCosEndPhi () const        << 145 void G4TorusEquation::setPosition (const G4ThreeVector& p)
 79 {                                                 146 {
 80   return std::cos(fSPhi+fDPhi);                << 147   Px = p.x();
                                                   >> 148   Py = p.y();
                                                   >> 149   Pz = p.z();
 81 }                                                 150 }
 82                                                   151 
 83 inline                                            152 inline
 84 G4double G4Torus::GetCubicVolume()             << 153 void G4TorusEquation::setDirection (G4double dirx,G4double diry,G4double dirz)
 85 {                                                 154 {
 86   if(fCubicVolume != 0.) {;}                   << 155   dx = dirx;
 87   else  { fCubicVolume = fDPhi*CLHEP::pi*fRtor << 156   dy = diry;
 88   return fCubicVolume;                         << 157   dz = dirz;    
 89 }                                                 158 }
 90                                                   159 
 91 inline                                            160 inline
 92 G4double G4Torus::GetSurfaceArea()             << 161 void G4TorusEquation::setDirection (const G4ThreeVector& v)
 93 {                                                 162 {
 94   if(fSurfaceArea != 0.) {;}                   << 163   dx = v.x();
 95   else                                         << 164   dy = v.y();
 96   {                                            << 165   dz = v.z();    
 97     fSurfaceArea = fDPhi*CLHEP::twopi*fRtor*(f << 166 }
 98     if(fDPhi < CLHEP::twopi)                   << 167 
 99     {                                          << 168 inline
100       fSurfaceArea = fSurfaceArea + CLHEP::two << 169 G4double G4TorusEquation::TorusEquation (G4double x, G4double y, G4double z)
101     }                                          << 170 {
102   }                                            << 171   // An interesting property is that the sign
103   return fSurfaceArea;                         << 172   // tells if the point is inside or outside
                                                   >> 173   // or if > EPSILON on the surface
                                                   >> 174 
                                                   >> 175   G4double temp;
                                                   >> 176 
                                                   >> 177   temp = ((x*x + y*y + z*z) + R0*R0 - R1*R1) ;
                                                   >> 178   temp = temp*temp ;
                                                   >> 179   temp = temp - 4*R0*R0*(x*x + y*y) ;
                                                   >> 180 
                                                   >> 181   //  > 0 Outside
                                                   >> 182   //  < 0 Inside
                                                   >> 183 
                                                   >> 184   return temp ;
                                                   >> 185 }
                                                   >> 186 
                                                   >> 187 inline
                                                   >> 188 G4double G4TorusEquation::TorusDerivativeX (G4double x, G4double y, G4double z)
                                                   >> 189 {
                                                   >> 190   return 4*x*(x*x + y*y + z*z +  R0*R0 - R1*R1) - 8*R0*R0*x ;
                                                   >> 191 }
                                                   >> 192 
                                                   >> 193 inline
                                                   >> 194 G4double G4TorusEquation::TorusDerivativeY (G4double x, G4double y, G4double z)
                                                   >> 195 {
                                                   >> 196   return 4*y*(x*x + y*y + z*z +  R0*R0 - R1*R1) - 8*R0*R0*y ;
                                                   >> 197 }
                                                   >> 198 
                                                   >> 199 inline
                                                   >> 200 G4double G4TorusEquation::TorusDerivativeZ (G4double x, G4double y, G4double z)
                                                   >> 201 {
                                                   >> 202   return 4*z*(x*x + y*y + z*z +  R0*R0 - R1*R1) ;
                                                   >> 203 }
                                                   >> 204 
                                                   >> 205 inline
                                                   >> 206 G4double G4TorusEquation::Function (G4double value)
                                                   >> 207 {
                                                   >> 208   G4double Lx,Ly,Lz;
                                                   >> 209   G4double result;  
                                                   >> 210 
                                                   >> 211   Lx = Px + value*dx;
                                                   >> 212   Ly = Py + value*dy;
                                                   >> 213   Lz = Pz + value*dz;
                                                   >> 214 
                                                   >> 215   result = TorusEquation(Lx,Ly,Lz);
                                                   >> 216   return result ;  
                                                   >> 217 }
                                                   >> 218 
                                                   >> 219 inline
                                                   >> 220 G4double G4TorusEquation::Derivative(G4double value)
                                                   >> 221 {
                                                   >> 222   G4double Lx,Ly,Lz;
                                                   >> 223   G4double result;
                                                   >> 224 
                                                   >> 225   Lx = Px + value*dx;
                                                   >> 226   Ly = Py + value*dy;
                                                   >> 227   Lz = Pz + value*dz;
                                                   >> 228 
                                                   >> 229   result = dx*TorusDerivativeX(Lx,Ly,Lz);
                                                   >> 230   result += dy*TorusDerivativeY(Lx,Ly,Lz);
                                                   >> 231   result += dz*TorusDerivativeZ(Lx,Ly,Lz);
                                                   >> 232 
                                                   >> 233   return result;
104 }                                                 234 }
105                                                   235