| Geant4 Cross Reference |
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 //
27 //
28 // Hadronic Process: Nuclear De-excitations
29 // by V. Lara
30
31 #ifndef G4Solver_h
32 #define G4Solver_h 1
33
34 #include "globals.hh"
35
36 #include <cmath>
37
38 #define DefaultTolerance 5.0e-14
39
40 template <class Function> class G4Solver
41 {
42 public:
43 enum {DefaultMaxIter = 100};
44
45 // default constructor
46 G4Solver() : MaxIter(DefaultMaxIter), tolerance(DefaultTolerance),
47 a(0.0), b(0.0), root(0.0) {};
48
49 G4Solver(const G4int iterations, const G4double tol) :
50 MaxIter(iterations), tolerance(tol),
51 a(0.0), b(0.0), root(0.0) {};
52
53 // copy constructor
54 G4Solver(const G4Solver & right);
55
56 // destructor
57 ~G4Solver() {};
58
59 // operators
60 G4Solver & operator=(const G4Solver & right);
61 G4bool operator==(const G4Solver & right) const;
62 G4bool operator!=(const G4Solver & right) const;
63
64 G4int GetMaxIterations(void) const {return MaxIter;}
65 void SetMaxIterations(const G4int iterations) {MaxIter=iterations;}
66
67 G4double GetTolerance(void) const {return tolerance;}
68 void SetTolerance(const G4double epsilon) {tolerance = epsilon;}
69
70
71 G4double GetIntervalLowerLimit(void) const {return a;}
72 G4double GetIntervalUpperLimit(void) const {return b;}
73
74 void SetIntervalLimits(const G4double Limit1, const G4double Limit2);
75
76 G4double GetRoot(void) const {return root;}
77
78 // Calculates the root by the Bisection method
79 G4bool Bisection(Function & theFunction);
80
81 // Calculates the root by the Regula-Falsi method
82 G4bool RegulaFalsi(Function & theFunction);
83
84
85 // Calculates the root by the Brent's method
86 G4bool Brent(Function & theFunction);
87
88 // Calculates the root by the Inverse Parabolic Interpolation method
89 // due to Jack Crenshaw
90 G4bool Crenshaw(Function & theFunction);
91
92 private:
93
94 // Maximum number of iterations
95 G4int MaxIter;
96
97 //
98 G4double tolerance;
99
100 // interval limits [a,b] which should bracket the root
101 G4double a;
102 G4double b;
103
104 // The root
105 G4double root;
106
107 };
108
109 #include "G4Solver.icc"
110
111 #endif
112