Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
G4PolynomialSolver.hh
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// G4PolynomialSolver
27//
28// Class description:
29//
30// G4PolynomialSolver allows the user to solve a polynomial equation
31// with a great precision. This is used by Implicit Equation solver.
32//
33// The Bezier clipping method is used to solve the polynomial.
34//
35// How to use it:
36// Create a class that is the function to be solved.
37// This class could have internal parameters to allow to change
38// the equation to be solved without recreating a new one.
39//
40// Define a Polynomial solver, example:
41// G4PolynomialSolver<MyFunctionClass,G4double(MyFunctionClass::*)(G4double)>
42// PolySolver (&MyFunction,
43// &MyFunctionClass::Function,
44// &MyFunctionClass::Derivative,
45// precision);
46//
47// The precision is relative to the function to solve.
48//
49// In MyFunctionClass, provide the function to solve and its derivative:
50// Example of function to provide :
51//
52// x,y,z,dx,dy,dz,Rmin,Rmax are internal variables of MyFunctionClass
53//
54// G4double MyFunctionClass::Function(G4double value)
55// {
56// G4double Lx,Ly,Lz;
57// G4double result;
58//
59// Lx = x + value*dx;
60// Ly = y + value*dy;
61// Lz = z + value*dz;
62//
63// result = TorusEquation(Lx,Ly,Lz,Rmax,Rmin);
64//
65// return result ;
66// }
67//
68// G4double MyFunctionClass::Derivative(G4double value)
69// {
70// G4double Lx,Ly,Lz;
71// G4double result;
72//
73// Lx = x + value*dx;
74// Ly = y + value*dy;
75// Lz = z + value*dz;
76//
77// result = dx*TorusDerivativeX(Lx,Ly,Lz,Rmax,Rmin);
78// result += dy*TorusDerivativeY(Lx,Ly,Lz,Rmax,Rmin);
79// result += dz*TorusDerivativeZ(Lx,Ly,Lz,Rmax,Rmin);
80//
81// return result;
82// }
83//
84// Then to have a root inside an interval [IntervalMin,IntervalMax] do the
85// following:
86//
87// MyRoot = PolySolver.solve(IntervalMin,IntervalMax);
88
89// Author: E.Medernach, 19.12.2000 - First implementation
90// --------------------------------------------------------------------
91#ifndef G4POL_SOLVER_HH
92#define G4POL_SOLVER_HH 1
93
94#include "globals.hh"
95
96template <class T, class F>
98{
99 public:
100 G4PolynomialSolver(T* typeF, F func, F deriv, G4double precision);
102
103 G4double solve(G4double IntervalMin, G4double IntervalMax);
104
105 private:
106 G4double Newton(G4double IntervalMin, G4double IntervalMax);
107 // General Newton method with Bezier Clipping
108
109 // Works for polynomial of order less or equal than 4.
110 // But could be changed to work for polynomial of any order providing
111 // that we find the bezier control points.
112
113 G4int BezierClipping(G4double* IntervalMin, G4double* IntervalMax);
114 // This is just one iteration of Bezier Clipping
115
116 T* FunctionClass;
117 F Function;
118 F Derivative;
119
120 G4double Precision;
121};
122
123#include "G4PolynomialSolver.icc"
124
125#endif
double G4double
Definition: G4Types.hh:83
int G4int
Definition: G4Types.hh:85
G4PolynomialSolver(T *typeF, F func, F deriv, G4double precision)
G4double solve(G4double IntervalMin, G4double IntervalMax)