DUNE-FEM (unstable)

parameter.hh
1#ifndef DUNE_FEM_SOLVERPARAMETER_HH
2#define DUNE_FEM_SOLVERPARAMETER_HH
3
4#include <dune/fem/io/parameter.hh>
5#include <dune/fem/common/staticlistofint.hh>
6
7namespace Dune
8{
9
10 namespace Fem
11 {
12 namespace LinearSolver
13 {
14 struct ToleranceCriteria {
15 static const int absolute = 0;
16 static const int relative = 1;
17 static const int residualReduction = 2;
18 };
19 }
20
21 struct SolverParameter
22#ifndef DOXYGEN
23 : public LocalParameter< SolverParameter, SolverParameter >
24#endif
25 {
26 protected:
27 // key prefix, default is fem.solver (can be overloaded by user)
28 const std::string keyPrefix_;
29
30 ParameterReader parameter_;
31
32 public:
33 // identifier for Fem, ISTL and Petsc solvers
34 LIST_OF_INT_FORWARDED(Solvers,
35 cg = 1, // CG
36 bicgstab = 2, // BiCGStab
37 gmres = 3, // GMRES
38 minres = 4, // MinRes
39 gradient = 5, // GradientSolver
40 loop = 6, // LoopSolver
41 superlu = 7, // SuperLUSolver
42 bicg = 8, // BiCG
43 preonly = 9); // only preconder
44
45 static const std::string solverMethodTable(int id)
46 {
47 return Solvers::to_string( id );
48 }
49
50 // identifier for Fem, ISTL and Petsc preconditioner
51 // Note: underscores in variable names will be replaced with dash in the string of the name
52 // e.g. amg_jacobi --> amg-jacobi as string
53 LIST_OF_INT_FORWARDED(Preconditioners,
54 none = 1 , // no preconditioner
55 ssor = 2 , // SSOR preconditioner
56 sor = 3 , // SOR preconditioner
57 ilu = 4 , // ILU preconditioner
58 gauss_seidel = 5 , // Gauss-Seidel preconditioner
59 jacobi = 6 , // Jacobi preconditioner
60 amg_ilu = 7 , // AMG with ILU-0 smoother (deprecated)
61 amg_jacobi = 8 , // AMG with Jacobi smoother
62 ildl = 9 , // ILDL from istl
63 oas = 10, // Overlapping Additive Schwarz
64 icc = 11);// Incomplete Cholesky factorization
65 static const std::string preconditionMethodTable(int id)
66 {
67 return Preconditioners::to_string( id );
68 }
69
70 SolverParameter ( const ParameterReader &parameter = Parameter::container() )
71 : keyPrefix_( "fem.solver." ), parameter_( parameter )
72 {}
73
74 explicit SolverParameter ( const std::string keyPrefix, const ParameterReader &parameter = Parameter::container() )
75 : keyPrefix_( keyPrefix ), parameter_( parameter )
76 {}
77
78 const std::string& keyPrefix() const { return keyPrefix_; }
79
80 const ParameterReader& parameter() const { return parameter_; }
81
82 virtual void reset()
83 {
84 verbose_ = -1;
85 absoluteTol_ = -1;
86 reductionTol_ = -1;
87 maxIterations_ = -1;
88 }
89
90 virtual bool verbose() const
91 {
92 if( verbose_ < 0 )
93 {
94 verbose_ = parameter_.getValue< bool >( keyPrefix_ + "verbose", false ) ? 1 : 0;
95 }
96 return bool(verbose_);
97 }
98
99 virtual void setVerbose( const bool verb )
100 {
101 verbose_ = verb ? 1 : 0;
102 }
103
104 virtual int errorMeasure() const
105 {
106 const std::string errorTypeTable[] =
107 { "absolute", "relative", "residualreduction" };
108 const int errorType = parameter_.getEnum( keyPrefix_ + "errormeasure", errorTypeTable, 0 );
109 return errorType ;
110 }
111
112 virtual double tolerance ( ) const
113 {
114 if( tolerance_ < 0 )
115 {
116 double defaultTol = 1e-8;
117 if(parameter_.exists(keyPrefix_ + "tolerance"))
118 tolerance_ = parameter_.getValue< double >( keyPrefix_ + "tolerance", defaultTol );
119 else
120 {
121 if( parameter_.exists(keyPrefix_ + "absolutetol") ||
122 parameter_.exists(keyPrefix_ + "reductiontol") )
123 // new parameter not used but old parameters exist
124 {
125 int measure = errorMeasure();
126 if (measure == 0)
127 tolerance_ = absoluteTol__();
128 else
129 tolerance_ = reductionTol__();
130 }
131 else tolerance_ = defaultTol; // no parameter set
132 }
133 }
134 return tolerance_;
135 }
136
137 virtual void setTolerance ( const double eps )
138 {
139 assert( eps >= 0.0 );
140 tolerance_ = eps;
141 }
142
143 virtual int maxIterations () const
144 {
145 if( maxIterations_ < 0 )
146 {
147 if(parameter_.exists(keyPrefix_ + "maxlineariterations"))
148 {
149 std::cout << "WARNING: Parameter " + keyPrefix_ +"maxlineariterations is deprecated. Please use " + keyPrefix_ + "maxiterations instead." << std::endl;
150 maxIterations_ = parameter_.getValue< double >(keyPrefix_ + "maxlineariterations");
151 }
152 else
153 maxIterations_ = parameter_.getValue< int >( keyPrefix_ + "maxiterations", std::numeric_limits< int >::max() );
154 }
155 return maxIterations_;
156 }
157
158 virtual void setMaxIterations ( const int maxIter )
159 {
160 assert( maxIter >= 0 );
161 maxIterations_ = maxIter;
162 }
163
164 virtual int solverMethod(
165 const std::vector<int> standardMethods,
166 const std::vector<std::string> &additionalMethods = {},
167 int defaultMethod = 0 // this is the first method passed in
168 ) const
169 {
170 std::vector<std::string> methodTable(standardMethods.size()+additionalMethods.size());
171 for (std::size_t i=0;i<standardMethods.size();++i)
172 methodTable[i] = solverMethodTable(standardMethods[i]);
173 for (std::size_t i=0;i<additionalMethods.size();++i)
174 methodTable[standardMethods.size()+i] = additionalMethods[i];
175 std::size_t method;
176 if( parameter_.exists( keyPrefix_ + "method" ) ||
177 !parameter_.exists( "method" ) )
178 method = parameter_.getEnum( keyPrefix_ + "method", methodTable, defaultMethod );
179 else
180 {
181 method = parameter_.getEnum( "krylovmethod", methodTable, defaultMethod );
182 std::cout << "WARNING: using old parameter name 'krylovmethod' "
183 << "please switch to '" << keyPrefix_ << "method'\n";
184 }
185 if (method < standardMethods.size())
186 return standardMethods[method];
187 else
188 return -(method-standardMethods.size()); // return in [ 0,-additionalMethods.size() )
189 }
190
191 virtual int gmresRestart() const
192 {
193 int defaultRestart = 20;
194 return parameter_.getValue< int >( keyPrefix_ + "gmres.restart", defaultRestart );
195 }
196
197 virtual int preconditionMethod(
198 const std::vector<int> standardMethods,
199 const std::vector<std::string> &additionalMethods = {},
200 int defaultMethod = 0 // this is the first method passed in
201 ) const
202 {
203 std::vector<std::string> methodTable(standardMethods.size()+additionalMethods.size());
204 for (std::size_t i=0;i<standardMethods.size();++i)
205 methodTable[i] = preconditionMethodTable(standardMethods[i]);
206 for (std::size_t i=0;i<additionalMethods.size();++i)
207 methodTable[standardMethods.size()+i] = additionalMethods[i];
208 std::size_t method = parameter_.getEnum( keyPrefix_ + "preconditioning.method", methodTable, defaultMethod );
209 if (method < standardMethods.size())
210 return standardMethods[method];
211 else
212 return -(method-standardMethods.size()); // return in [ 0,-additionalMethods.size() )
213 }
214
215 virtual double relaxation () const
216 {
217 return parameter_.getValue< double >( keyPrefix_ + "preconditioning.relaxation", 1.1 );
218 }
219
220 virtual int preconditionerIteration () const
221 {
222 return parameter_.getValue< int >( keyPrefix_ + "preconditioning.iterations", 1 );
223 }
224
225 virtual int preconditionerLevel () const
226 {
227 return parameter_.getValue< int >( keyPrefix_ + "preconditioning.level", 0 );
228 }
229
230 virtual bool threading () const
231 {
232 return parameter_.getValue< bool >( keyPrefix_ + "threading", true );
233 }
234
235 virtual bool knollTrick() const
236 {
237 return parameter_.getValue< bool >( keyPrefix_ + "knolltrick", false );
238 }
239
240 private:
241 virtual double absoluteTol__ ( ) const
242 {
243 if( absoluteTol_ < 0 )
244 {
245 if(parameter_.exists(keyPrefix_ + "linabstol"))
246 {
247 std::cout << "WARNING: Parameter " + keyPrefix_ + "linabstol is deprecated. Please use " + keyPrefix_ + "absolutetol instead." << std::endl;
248 absoluteTol_ = parameter_.getValue< double >(keyPrefix_ + "linabstol");
249 }
250 else
251 {
252 std::cout << "WARNING: Parameter " + keyPrefix_ + "absolutetol is deprecated. Please use " + keyPrefix_ + "tolerance instead." << std::endl;
253 absoluteTol_ = parameter_.getValue< double >(keyPrefix_ + "absolutetol", 1e-8 );
254 }
255 }
256 return absoluteTol_;
257 }
258
259 virtual double reductionTol__ ( ) const
260 {
261 if( reductionTol_ < 0 )
262 {
263 if(parameter_.exists(keyPrefix_ + "linreduction"))
264 {
265 std::cout << "WARNING: Parameter " + keyPrefix_ +"linreduction is deprecated. Please use " + keyPrefix_ + "reductiontol instead." << std::endl;
266 reductionTol_ = parameter_.getValue< double >(keyPrefix_ + "linreduction");
267 }
268 else
269 {
270 std::cout << "WARNING: Parameter " + keyPrefix_ +"reductiontol is deprecated. Please use " + keyPrefix_ + "tolerance instead." << std::endl;
271 reductionTol_ = parameter_.getValue< double >( keyPrefix_ + "reductiontol", 1e-8 );
272 }
273 }
274 return reductionTol_;
275 }
276
277 mutable int verbose_ = -1;
278 mutable int maxIterations_ = -1;
279 mutable double absoluteTol_ = -1.;
280 mutable double reductionTol_ = -1.;
281 mutable double tolerance_ = -1.;
282 };
283 }
284}
285
286#endif // #ifndef DUNE_FEM_SOLVERPARAMETER_HH
Dune::FloatCmp::absolute
@ absolute
|a-b| <= epsilon
Definition: float_cmp.hh:110
Dune::GeometryTypes::none
constexpr GeometryType none(unsigned int dim)
Returns a GeometryType representing a singular of dimension dim.
Definition: type.hh:471
Dune::Hybrid::max
constexpr auto max
Function object that returns the greater of the given values.
Definition: hybridutilities.hh:484
Dune
Dune namespace.
Definition: alignedallocator.hh:13
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Jul 27, 22:29, 2024)