| Geant4 Cross Reference |
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.2 2004/09/08 15:13:51 grichine Exp $
>> 25 // GEANT4 tag $Name: geant4-07-00-patch-01 $
>> 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
59 inline 67 inline
60 G4double G4Torus::GetSinStartPhi () const << 68 G4double G4Torus::TorusEquation (G4double x, G4double y, G4double z,
>> 69 G4double R0, G4double R1) const
61 { 70 {
62 return std::sin(fSPhi); << 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 ;
63 } 88 }
64 89
65 inline 90 inline
66 G4double G4Torus::GetCosStartPhi () const << 91 G4double G4Torus::TorusDerivativeX (G4double x, G4double y, G4double z,
>> 92 G4double R0, G4double R1) const
67 { 93 {
68 return std::cos(fSPhi); << 94 return 4*x*(x*x + y*y + z*z + R0*R0 - R1*R1) - 8*R0*R0*x ;
69 } 95 }
70 96
71 inline 97 inline
72 G4double G4Torus::GetSinEndPhi () const << 98 G4double G4Torus::TorusDerivativeY (G4double x, G4double y, G4double z,
>> 99 G4double R0, G4double R1) const
73 { 100 {
74 return std::sin(fSPhi+fDPhi); << 101 return 4*y*(x*x + y*y + z*z + R0*R0 - R1*R1) - 8*R0*R0*y ;
75 } 102 }
76 103
77 inline 104 inline
78 G4double G4Torus::GetCosEndPhi () const << 105 G4double G4Torus::TorusDerivativeZ (G4double x, G4double y, G4double z,
>> 106 G4double R0, G4double R1) const
79 { 107 {
80 return std::cos(fSPhi+fDPhi); << 108 return 4*z*(x*x + y*y + z*z + R0*R0 - R1*R1) ;
81 } 109 }
82 110
83 inline 111 inline
84 G4double G4Torus::GetCubicVolume() << 112 G4double G4Torus::TorusGradient(G4double dx, G4double dy, G4double dz,
>> 113 G4double x, G4double y, G4double z,
>> 114 G4double Rmax, G4double Rmin) const
85 { 115 {
86 if(fCubicVolume != 0.) {;} << 116 // This tells the normal at a surface point
87 else { fCubicVolume = fDPhi*CLHEP::pi*fRtor << 117
88 return fCubicVolume; << 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;
>> 125 }
>> 126
>> 127 // ----------- G4TorusEquation methods ---------------
>> 128
>> 129 inline
>> 130 void G4TorusEquation::setRadius (G4double Rmax, G4double Rmin)
>> 131 {
>> 132 R0 = Rmax;
>> 133 R1 = Rmin;
>> 134 }
>> 135
>> 136 inline
>> 137 void G4TorusEquation::setPosition (G4double x,G4double y,G4double z)
>> 138 {
>> 139 Px = x;
>> 140 Py = y;
>> 141 Pz = z;
>> 142 }
>> 143
>> 144 inline
>> 145 void G4TorusEquation::setPosition (const G4ThreeVector& p)
>> 146 {
>> 147 Px = p.x();
>> 148 Py = p.y();
>> 149 Pz = p.z();
>> 150 }
>> 151
>> 152 inline
>> 153 void G4TorusEquation::setDirection (G4double dirx,G4double diry,G4double dirz)
>> 154 {
>> 155 dx = dirx;
>> 156 dy = diry;
>> 157 dz = dirz;
>> 158 }
>> 159
>> 160 inline
>> 161 void G4TorusEquation::setDirection (const G4ThreeVector& v)
>> 162 {
>> 163 dx = v.x();
>> 164 dy = v.y();
>> 165 dz = v.z();
89 } 166 }
90 167
91 inline 168 inline
92 G4double G4Torus::GetSurfaceArea() << 169 G4double G4TorusEquation::TorusEquation (G4double x, G4double y, G4double z)
93 { 170 {
94 if(fSurfaceArea != 0.) {;} << 171 // An interesting property is that the sign
95 else << 172 // tells if the point is inside or outside
96 { << 173 // or if > EPSILON on the surface
97 fSurfaceArea = fDPhi*CLHEP::twopi*fRtor*(f << 174
98 if(fDPhi < CLHEP::twopi) << 175 G4double temp;
99 { << 176
100 fSurfaceArea = fSurfaceArea + CLHEP::two << 177 temp = ((x*x + y*y + z*z) + R0*R0 - R1*R1) ;
101 } << 178 temp = temp*temp ;
102 } << 179 temp = temp - 4*R0*R0*(x*x + y*y) ;
103 return fSurfaceArea; << 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;
>> 234 }
>> 235
>> 236 ///////////////////////////////////////////////////
>> 237
>> 238 inline
>> 239 G4double G4Torus::GetCubicVolume()
>> 240 {
>> 241 if(fCubicVolume != 0.) ;
>> 242 else fCubicVolume = fDPhi*pi*fRtor*(fRmax*fRmax-fRmin*fRmin);
>> 243 return fCubicVolume;
104 } 244 }
105 245