| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th << 7 //
6 // * the Geant4 Collaboration. It is provided << 8 // $Id: G4PolynomialSolver.hh,v 1.2 2001/01/29 09:49:54 gcosmo Exp $
7 // * conditions of the Geant4 Software License << 9 // GEANT4 tag $Name: geant4-03-01 $
8 // * LICENSE and available at http://cern.ch/ << 10 //
9 // * include a list of copyright holders. << 11 // class G4PolynomialSolver
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // <<
26 // G4PolynomialSolver <<
27 // 12 //
28 // Class description: 13 // Class description:
29 // 14 //
30 // G4PolynomialSolver allows the user to sol 15 // G4PolynomialSolver allows the user to solve a polynomial equation
31 // with a great precision. This is used by I 16 // with a great precision. This is used by Implicit Equation solver.
32 // 17 //
33 // The Bezier clipping method is used to sol 18 // The Bezier clipping method is used to solve the polynomial.
34 // 19 //
35 // How to use it: 20 // How to use it:
36 // Create a class that is the function to be 21 // Create a class that is the function to be solved.
37 // This class could have internal parameters 22 // This class could have internal parameters to allow to change
38 // the equation to be solved without recreat 23 // the equation to be solved without recreating a new one.
39 // 24 //
40 // Define a Polynomial solver, example: 25 // Define a Polynomial solver, example:
41 // G4PolynomialSolver<MyFunctionClass,G4doub 26 // G4PolynomialSolver<MyFunctionClass,G4double(MyFunctionClass::*)(G4double)>
42 // PolySolver (&MyFunction, 27 // PolySolver (&MyFunction,
43 // &MyFunctionClass::Function, 28 // &MyFunctionClass::Function,
44 // &MyFunctionClass::Derivativ 29 // &MyFunctionClass::Derivative,
45 // precision); 30 // precision);
46 // 31 //
47 // The precision is relative to the function 32 // The precision is relative to the function to solve.
48 // 33 //
49 // In MyFunctionClass, provide the function 34 // In MyFunctionClass, provide the function to solve and its derivative:
50 // Example of function to provide : 35 // Example of function to provide :
51 // 36 //
52 // x,y,z,dx,dy,dz,Rmin,Rmax are internal var 37 // x,y,z,dx,dy,dz,Rmin,Rmax are internal variables of MyFunctionClass
53 // 38 //
54 // G4double MyFunctionClass::Function(G4doub 39 // G4double MyFunctionClass::Function(G4double value)
55 // { 40 // {
56 // G4double Lx,Ly,Lz; 41 // G4double Lx,Ly,Lz;
57 // G4double result; << 42 // G4double result;
58 // << 43 //
59 // Lx = x + value*dx; 44 // Lx = x + value*dx;
60 // Ly = y + value*dy; 45 // Ly = y + value*dy;
61 // Lz = z + value*dz; 46 // Lz = z + value*dz;
62 // << 47 //
63 // result = TorusEquation(Lx,Ly,Lz,Rmax,Rm 48 // result = TorusEquation(Lx,Ly,Lz,Rmax,Rmin);
64 // << 49 //
65 // return result ; << 50 // return result ;
66 // } << 51 // }
67 // << 52 //
68 // G4double MyFunctionClass::Derivative(G4do 53 // G4double MyFunctionClass::Derivative(G4double value)
69 // { 54 // {
70 // G4double Lx,Ly,Lz; 55 // G4double Lx,Ly,Lz;
71 // G4double result; << 56 // G4double result;
72 // << 57 //
73 // Lx = x + value*dx; 58 // Lx = x + value*dx;
74 // Ly = y + value*dy; 59 // Ly = y + value*dy;
75 // Lz = z + value*dz; 60 // Lz = z + value*dz;
76 // << 61 //
77 // result = dx*TorusDerivativeX(Lx,Ly,Lz,R 62 // result = dx*TorusDerivativeX(Lx,Ly,Lz,Rmax,Rmin);
78 // result += dy*TorusDerivativeY(Lx,Ly,Lz, 63 // result += dy*TorusDerivativeY(Lx,Ly,Lz,Rmax,Rmin);
79 // result += dz*TorusDerivativeZ(Lx,Ly,Lz, 64 // result += dz*TorusDerivativeZ(Lx,Ly,Lz,Rmax,Rmin);
80 // << 65 //
81 // return result; 66 // return result;
82 // } 67 // }
83 // << 68 //
84 // Then to have a root inside an interval [I 69 // Then to have a root inside an interval [IntervalMin,IntervalMax] do the
85 // following: 70 // following:
86 // 71 //
87 // MyRoot = PolySolver.solve(IntervalMin,Int 72 // MyRoot = PolySolver.solve(IntervalMin,IntervalMax);
>> 73 //
>> 74
>> 75 // History:
>> 76 //
>> 77 // - 19.12.00 E.Medernach, First implementation
>> 78 //
88 79
89 // Author: E.Medernach, 19.12.2000 - First imp <<
90 // ------------------------------------------- <<
91 #ifndef G4POL_SOLVER_HH 80 #ifndef G4POL_SOLVER_HH
92 #define G4POL_SOLVER_HH 1 << 81 #define G4POL_SOLVER_HH
93 82
94 #include "globals.hh" << 83 #include "globals.hh"
95 84
96 template <class T, class F> 85 template <class T, class F>
97 class G4PolynomialSolver << 86 class G4PolynomialSolver
98 { 87 {
99 public: << 88 public: // with description
100 G4PolynomialSolver(T* typeF, F func, F deriv << 89
>> 90 G4PolynomialSolver(T* typeF, F func, F deriv, G4double precision);
101 ~G4PolynomialSolver(); 91 ~G4PolynomialSolver();
>> 92
102 93
103 G4double solve(G4double IntervalMin, G4doubl << 94 G4double solve (G4double IntervalMin, G4double IntervalMax);
>> 95
>> 96 private:
104 97
105 private: << 98 G4double Newton (G4double IntervalMin, G4double IntervalMax);
106 G4double Newton(G4double IntervalMin, G4doub << 99 //General Newton method with Bezier Clipping
107 // General Newton method with Bezier Clippin <<
108 100
109 // Works for polynomial of order less or equ 101 // Works for polynomial of order less or equal than 4.
110 // But could be changed to work for polynomi 102 // But could be changed to work for polynomial of any order providing
111 // that we find the bezier control points. 103 // that we find the bezier control points.
112 104
113 G4int BezierClipping(G4double* IntervalMin, << 105 G4int BezierClipping(G4double *IntervalMin, G4double *IntervalMax);
114 // This is just one iteration of Bezier Clip << 106 // This is just one iteration of Bezier Clipping
115 107
116 T* FunctionClass; <<
117 F Function; <<
118 F Derivative; <<
119 108
>> 109 T* FunctionClass ;
>> 110 F Function ;
>> 111 F Derivative ;
>> 112
120 G4double Precision; 113 G4double Precision;
121 }; 114 };
122 115
123 #include "G4PolynomialSolver.icc" 116 #include "G4PolynomialSolver.icc"
124 117
125 #endif << 118 #endif
126 119