/[escript]/trunk/doc/user/linearPDE.tex
ViewVC logotype

Contents of /trunk/doc/user/linearPDE.tex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3306 - (show annotations)
Mon Oct 25 05:09:13 2010 UTC (8 years, 10 months ago) by caltinay
File MIME type: application/x-tex
File size: 41803 byte(s)
Commented declaremodule and modulesynopsis.

1
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %
4 % Copyright (c) 2003-2010 by University of Queensland
5 % Earth Systems Science Computational Center (ESSCC)
6 % http://www.uq.edu.au/esscc
7 %
8 % Primary Business: Queensland, Australia
9 % Licensed under the Open Software License version 3.0
10 % http://www.opensource.org/licenses/osl-3.0.php
11 %
12 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13
14
15 \chapter{The \linearPDEs Module}
16
17 \section{Linear Partial Differential Equations}
18 \label{SEC LinearPDE}
19
20 The \LinearPDE class is used to define a general linear, steady, second order PDE
21 for an unknown function $u$ on a given $\Omega$ defined through a \Domain object.
22 In the following $\Gamma$ denotes the boundary of the domain $\Omega$. $n$ denotes
23 the outer normal field on $\Gamma$.
24
25 For a single PDE with a solution with a single component the linear PDE is defined in the
26 following form:
27 \begin{equation}\label{LINEARPDE.SINGLE.1}
28 -(A_{jl} u_{,l})_{,j}-(B_{j} u)_{,j}+C_{l} u_{,l}+D u =-X_{j,j}+Y \; .
29 \end{equation}
30 $u_{,j}$ denotes the derivative of $u$ with respect to the $j$-th spatial direction. Einstein's summation convention, ie. summation over indexes appearing twice in a term of a sum is performed, is used.
31 The coefficients $A$, $B$, $C$, $D$, $X$ and $Y$ have to be specified through \Data objects in the
32 \Function on the PDE or objects that can be converted into such \Data objects.
33 $A$ is a \RankTwo, $B$, $C$ and $X$ are \RankOne and $D$ and $Y$ are scalar.
34 The following natural
35 boundary conditions are considered \index{boundary condition!natural} on $\Gamma$:
36 \begin{equation}\label{LINEARPDE.SINGLE.2}
37 n_{j}(A_{jl} u_{,l}+B_{j} u)+d u=n_{j}X_{j} + y \;.
38 \end{equation}
39 Notice that the coefficients $A$, $B$ and $X$ are defined in the PDE. The coefficients $d$ and $y$ are
40 each a \Scalar in the \FunctionOnBoundary. Constraints \index{constraint} for the solution prescribing the value of the
41 solution at certain locations in the domain. They have the form
42 \begin{equation}\label{LINEARPDE.SINGLE.3}
43 u=r \mbox{ where } q>0
44 \end{equation}
45 $r$ and $q$ are each \Scalar where $q$ is the characteristic function
46 \index{characteristic function} defining where the constraint is applied.
47 The constraints defined by \eqn{LINEARPDE.SINGLE.3} override any other condition set by \eqn{LINEARPDE.SINGLE.1}
48 or \eqn{LINEARPDE.SINGLE.2}.
49
50 For a system of PDEs and a solution with several components the PDE has the form
51 \begin{equation}\label{LINEARPDE.SYSTEM.1}
52 -(A_{ijkl} u_{k,l})_{,j}-(B_{ijk} u_{k})_{,j}+C_{ikl} u_{k,l}+D_{ik} u_{k} =-X_{ij,j}+Y_{i} \; .
53 \end{equation}
54 $A$ is a \RankFour, $B$ and $C$ are each a \RankThree, $D$ and $X$ are each a \RankTwo and $Y$ is a \RankOne.
55 The natural boundary conditions \index{boundary condition!natural} take the form:
56 \begin{equation}\label{LINEARPDE.SYSTEM.2}
57 n_{j}(A_{ijkl} u_{k,l}+B_{ijk} u_{k})+d_{ik} u_{k}=n_{j}X_{ij}+y_{i} \;.
58 \end{equation}
59 The coefficient $d$ is a \RankTwo and $y$ is a
60 \RankOne both in the \FunctionOnBoundary. Constraints \index{constraint} take the form
61 \begin{equation}\label{LINEARPDE.SYSTEM.3}
62 u_{i}=r_{i} \mbox{ where } q_{i}>0
63 \end{equation}
64 $r$ and $q$ are each \RankOne. Notice that not necessarily all components must
65 have a constraint at all locations.
66
67 \LinearPDE also supports solution discontinuities \index{discontinuity} over contact region $\Gamma^{contact}$
68 in the domain $\Omega$. To specify the conditions across the discontinuity we are using the
69 generalised flux $J$\footnote{In some applications the definition of flux used here can be different from the commonly used definition. For instance, if $T$ is a temperature field the heat flux $q$ is defined as $q_{,i}=-\kappa T_{,i}$ ($\kappa$ is diffusifity) which differs from the definition used here by the sign. This needs to be kept in mind when defining natural boundary conditions.\index{boundary condition!natural}} which is in the case of a systems of PDEs and several components of the solution
70 defined as
71 \begin{equation}\label{LINEARPDE.SYSTEM.5}
72 J_{ij}=A_{ijkl}u_{k,l}+B_{ijk}u_{k}-X_{ij}
73 \end{equation}
74 For the case of single solution component and single PDE $J$ is defined
75 \begin{equation}\label{LINEARPDE.SINGLE.5}
76 J_{j}=A_{jl}u_{,l}+B_{j}u_{k}-X_{j}
77 \end{equation}
78 In the context of discontinuities \index{discontinuity} $n$ denotes the normal on the
79 discontinuity pointing from side 0 towards side 1. For a system of PDEs
80 the contact condition takes the form
81 \begin{equation}\label{LINEARPDE.SYSTEM.6}
82 n_{j} J^{0}_{ij}=n_{j} J^{1}_{ij}=y^{contact}_{i} - d^{contact}_{ik} [u]_{k} \; .
83 \end{equation}
84 where $J^{0}$ and $J^{1}$ are the fluxes on side $0$ and side $1$ of the
85 discontinuity $\Gamma^{contact}$, respectively. $[u]$, which is the difference
86 of the solution at side 1 and at side 0, denotes the jump of $u$ across $\Gamma^{contact}$.
87 The coefficient $d^{contact}$ is a \RankTwo and $y^{contact}$ is a
88 \RankOne both in the \FunctionOnContactZero or \FunctionOnContactOne.
89 In case of a single PDE and a single component solution the contact condition takes the form
90 \begin{equation}\label{LINEARPDE.SINGLE.6}
91 n_{j} J^{0}_{j}=n_{j} J^{1}_{j}=y^{contact} - d^{contact}[u]
92 \end{equation}
93 In this case the the coefficient $d^{contact}$ and $y^{contact}$ are each \Scalar
94 both in the \FunctionOnContactZero or \FunctionOnContactOne.
95
96 The PDE is symmetrical \index{symmetrical} if
97 \begin{equation}\label{LINEARPDE.SINGLE.4}
98 A_{jl}=A_{lj} \mbox{ and } B_{j}=C_{j}
99 \end{equation}
100 The system of PDEs is symmetrical \index{symmetrical} if
101 \begin{eqnarray}
102 \label{LINEARPDE.SYSTEM.4}
103 A_{ijkl}&=&A_{klij} \\
104 B_{ijk}&=&C_{kij} \\
105 D_{ik}&=&D_{ki} \\
106 d_{ik}&=&d_{ki} \\
107 d^{contact}_{ik}&=&d^{contact}_{ki}
108 \end{eqnarray}
109 Note that in contrast with the scalar case~\eqn{LINEARPDE.SINGLE.4} now the coefficients $D$, $d$ abd $d^{contact}$
110 have to be inspected.
111
112 The following example illustrates the typical usage of the \LinearPDE class:
113 \begin{python}
114 from esys.escript import *
115 from esys.escript.linearPDEs import LinearPDE
116 from esys.finley import Rectangle
117 mydomain = Rectangle(l0=1.,l1=1.,n0=40, n1=20)
118 mypde=LinearPDE(mydomain)
119 mypde.setSymmetryOn()
120 mypde.setValue(A=kappa*kronecker(mydomain),D=1,Y=1)
121 u=mypde.getSolution()
122 \end{python}
123 We refer to chapter~\ref{CHAP: Tutorial} for more details.
124
125 An instance of the \SolverOptions class is attached to the \LinearPDE class object. It is used to set options of the solver used to solve the PDE. In the following
126 code the \method{getSolverOptions} is used to access the \SolverOptions
127 attached to \var{mypde}:
128 \begin{python}
129 from esys.escript import *
130 from esys.escript.linearPDEs import LinearPDE, SolverOptions
131 from esys.finley import Rectangle
132 mydomain = Rectangle(l0=1.,l1=1.,n0=40, n1=20)
133 mypde=LinearPDE(mydomain)
134 mypde.setValue(A=kappa*kronecker(mydomain),D=1,Y=1)
135 mypde.getSolverOptions().setVerbosityOn()
136 mypde.getSolverOptions().setSolverMethod(SolverOptions.PCG)
137 mypde.getSolverOptions().setPreconditioner(SolverOptions.AMG)
138 mypde.getSolverOptions().setTolerance(1e-8)
139 mypde.getSolverOptions().setIterMax(1000)
140 u=mypde.getSolution()
141 \end{python}
142 In this example, the preconditioned conjugate gradient method \PCG is used
143 with preconditioner \AMG. The relative tolerance is set to $10^{-8}$ and
144 the maximum number of iteration steps to $1000$.
145 After a completed solution call,
146 the attached \SolverOptions object gives access to diagnostic informations:
147 \begin{python}
148 u=mypde.getSolution()
149 print 'Number of iteration steps =', mypde.getDiagnostics('num_iter')
150 print 'Total solution time =', mypde.getDiagnostics('time')
151 print 'Set-up time =', mypde.getDiagnostics('set_up_time')
152 print 'Net time =', mypde.getDiagnostics('net_time')
153 print 'Residual norm of returned solution =', mypde.getDiagnostics('residual_norm')
154 \end{python}
155 Typically a negative value for a diagnostic value indicates that the value is undefined.
156
157 \subsection{Classes}
158 %\declaremodule{extension}{esys.escript.linearPDEs}
159 %\modulesynopsis{Linear partial differential equation handler}
160 The module \linearPDEs provides an interface to define and solve linear partial
161 differential equations within \escript. The module \linearPDEs does not provide any
162 solver capabilities in itself but hands the PDE over to
163 the PDE solver library defined through the \Domain of the PDE, eg. \finley.
164 The general interface is provided through the \LinearPDE class. The \Poisson
165 class which is also derived form the \LinearPDE class should be used
166 to define the Poisson equation \index{Poisson}.
167
168 \subsection{\LinearPDE class}
169 This is the general class to define a linear PDE in \escript. We list a selection of the most
170 important methods of the class. For a complete list, see the reference at \ReferenceGuide.
171
172 \begin{classdesc}{LinearPDE}{domain,numEquations=0,numSolutions=0}
173 opens a linear, steady, second order PDE on the \Domain \var{domain}. The parameters \var{numEquations}
174 and \var{numSolutions} give the number of equations and the number of solution components.
175 If \var{numEquations} and \var{numSolutions} are non-positive, then the number of equations
176 and the number solutions, respectively, stay undefined until a coefficient is
177 defined.
178 \end{classdesc}
179
180 \subsubsection{\LinearPDE methods}
181
182 \begin{methoddesc}[LinearPDE]{setValue}{
183 \optional{A}\optional{, B},
184 \optional{, C}\optional{, D}
185 \optional{, X}\optional{, Y}
186 \optional{, d}\optional{, y}
187 \optional{, d_contact}\optional{, y_contact}
188 \optional{, q}\optional{, r}}
189 assigns new values to coefficients. By default all values are assumed to be zero\footnote{
190 In fact it is assumed they are not present by assigning the value \code{escript.Data()}. The
191 can by used by the solver library to reduce computational costs.
192 }
193 If the new coefficient value is not a \Data object, it is converted into a \Data object in the
194 appropriate \FunctionSpace.
195 \end{methoddesc}
196
197 \begin{methoddesc}[LinearPDE]{getCoefficient}{name}
198 return the value assigned to coefficient \var{name}. If \var{name} is not a valid name
199 an exception is raised.
200 \end{methoddesc}
201
202 \begin{methoddesc}[LinearPDE]{getShapeOfCoefficient}{name}
203 returns the shape of coefficient \var{name} even if no value has been assigned to it.
204 \end{methoddesc}
205
206 \begin{methoddesc}[LinearPDE]{getFunctionSpaceForCoefficient}{name}
207 returns the \FunctionSpace of coefficient \var{name} even if no value has been assigned to it.
208 \end{methoddesc}
209
210 \begin{methoddesc}[LinearPDE]{setDebugOn}{}
211 switches on debug mode.
212 \end{methoddesc}
213
214 \begin{methoddesc}[LinearPDE]{setDebugOff}{}
215 switches off debug mode.
216 \end{methoddesc}
217
218 \begin{methoddesc}[LinearPDE]{getSolverOptions}{}
219 returns the solver options for solving the PDE. In fact the method returns
220 a \SolverOptions class object which can be used to modify the tolerance,
221 the solver or the preconditioner, see Section~\ref{SEC Solver Options} for details.
222 \end{methoddesc}
223
224 \begin{methoddesc}[LinearPDE]{setSolverOptions}{\optional{options=None}}
225 sets the solver options for solving the PDE. If argument \var{options} is present it
226 must be a \SolverOptions class object, see Section~\ref{SEC Solver Options} for details. Otherwise the solver options are reset to the default.
227 \end{methoddesc}
228
229
230 \begin{methoddesc}[LinearPDE]{isUsingLumping}{}
231 returns \True if \LUMPING is set as the solver for the system of linear equations.
232 Otherwise \False is returned.
233 \end{methoddesc}
234
235
236 \begin{methoddesc}[LinearPDE]{getDomain}{}
237 returns the \Domain of the PDE.
238 \end{methoddesc}
239
240 \begin{methoddesc}[LinearPDE]{getDim}{}
241 returns the spatial dimension of the PDE.
242 \end{methoddesc}
243
244 \begin{methoddesc}[LinearPDE]{getNumEquations}{}
245 returns the number of equations.
246 \end{methoddesc}
247
248 \begin{methoddesc}[LinearPDE]{getNumSolutions}{}
249 returns the number of components of the solution.
250 \end{methoddesc}
251
252 \begin{methoddesc}[LinearPDE]{checkSymmetry}{verbose=\False}
253 returns \True if the PDE is symmetric and \False otherwise.
254 The method is very computationally expensive and should only be
255 called for testing purposes. The symmetry flag is not altered.
256 If \var{verbose}=\True information about where symmetry is violated
257 are printed.
258 \end{methoddesc}
259
260 \begin{methoddesc}[LinearPDE]{getFlux}{u}
261 returns the flux $J_{ij}$ \index{flux} for given solution \var{u}
262 defined by \eqn{LINEARPDE.SYSTEM.5} and \eqn{LINEARPDE.SINGLE.5}, respectively.
263 \end{methoddesc}
264
265
266 \begin{methoddesc}[LinearPDE]{isSymmetric}{}
267 returns \True if the PDE has been indicated to be symmetric.
268 Otherwise \False is returned.
269 \end{methoddesc}
270
271 \begin{methoddesc}[LinearPDE]{setSymmetryOn}{}
272 indicates that the PDE is symmetric.
273 \end{methoddesc}
274
275 \begin{methoddesc}[LinearPDE]{setSymmetryOff}{}
276 indicates that the PDE is not symmetric.
277 \end{methoddesc}
278
279 \begin{methoddesc}[LinearPDE]{setReducedOrderOn}{}
280 switches on the reduction of polynomial order for the solution and equation evaluation even if
281 a quadratic or higher interpolation order is defined in the \Domain. This feature may not
282 be supported by all PDE libraries.
283 \end{methoddesc}
284
285 \begin{methoddesc}[LinearPDE]{setReducedOrderOff}{}
286 switches off the reduction of polynomial order for the solution and
287 equation evaluation.
288 \end{methoddesc}
289
290 \begin{methoddesc}[LinearPDE]{getOperator}{}
291 returns the \Operator of the PDE.
292 \end{methoddesc}
293
294 \begin{methoddesc}[LinearPDE]{getRightHandSide}{}
295 returns the right hand side of the PDE as a \Data object. If
296 \var{ignoreConstraint}=\True, then the constraints are not considered
297 when building up the right hand side.
298 \end{methoddesc}
299
300 \begin{methoddesc}[LinearPDE]{getSystem}{}
301 returns the \Operator and right hand side of the PDE.
302 \end{methoddesc}
303
304 \begin{methoddesc}[LinearPDE]{getSolution}{}
305 returns (an approximation of) the solution of the PDE. This call
306 will invoke the discretization of the PDE and the solution of the resulting
307 system of linear equations. Keep in mind that this call is typically computational
308 expensive and can - depending on the PDE and the discretiztion - take a long time to complete.
309 \end{methoddesc}
310
311
312
313 \subsection{The \Poisson Class}
314 The \Poisson class provides an easy way to define and solve the Poisson
315 equation
316 \begin{equation}\label{POISSON.1}
317 -u_{,ii}=f\; .
318 \end{equation}
319 with homogeneous boundary conditions
320 \begin{equation}\label{POISSON.2}
321 n_{i}u_{,i}=0
322 \end{equation}
323 and homogeneous constraints
324 \begin{equation}\label{POISSON.3}
325 u=0 \mbox{ where } q>0
326 \end{equation}
327 $f$ has to be a \Scalar in the \Function and $q$ must be
328 a \Scalar in the \SolutionFS.
329
330 \begin{classdesc}{Poisson}{domain}
331 opens a Poisson equation on the \Domain domain. \Poisson is derived from \LinearPDE.
332 \end{classdesc}
333 \begin{methoddesc}[Poisson]{setValue}{f=escript.Data(),q=escript.Data()}
334 assigns new values to \var{f} and \var{q}.
335 \end{methoddesc}
336
337 \subsection{The \Helmholtz Class}
338 The \Helmholtz class defines the Helmholtz problem
339 \begin{equation}\label{HZ.1}
340 \omega \; u - (k\; u_{,j})_{,j} = f
341 \end{equation}
342 with natural boundary conditions
343 \begin{equation}\label{HZ.2}
344 k\; u_{,j} n_{,j} = g- \alpha \; u
345 \end{equation}
346 and constraints:
347 \begin{equation}\label{HZ.3}
348 u=r \mbox{ where } q>0
349 \end{equation}
350 $\omega$, $k$, $f$ have to be a \Scalar in the \Function,
351 $g$ and $\alpha$ must be a \Scalar in the \FunctionOnBoundary,
352 and $q$ and $r$ must be a \Scalar in the \SolutionFS or must be mapped or interpolated into the particular \FunctionSpace.
353
354 \begin{classdesc}{Helmholtz}{domain}
355 opens a Helmholtz equation on the \Domain domain. \Helmholtz is derived from \LinearPDE.
356 \end{classdesc}
357 \begin{methoddesc}[Helmholtz]{setValue}{ \optional{omega} \optional{, k} \optional{, f} \optional{, alpha} \optional{, g} \optional{, r} \optional{, q}}
358 assigns new values to \var{omega}, \var{k}, \var{f}, \var{alpha}, \var{g}, \var{r}, \var{q}. By default all values are set to be zero.
359 \end{methoddesc}
360
361 \subsection{The \Lame Class}
362 The \Lame class defines a Lame equation problem:
363 \begin{equation}\label{LE.1}
364 -(\mu (u_{i,j}+u_{j,i})+\lambda u_{k,k}\delta_{ij})_{j} = F_{i}-\sigma_{ij,j}
365 \end{equation}
366 with natural boundary conditions:
367 \begin{equation}\label{LE.2}
368 n_{j}(\mu \; (u_{i,j}+u_{j,i})+\lambda u_{k,k}\delta_{ij}) = f_{i}+n_{j}\sigma_{ij}
369 \end{equation}
370 and constraint
371 \begin{equation}\label{LE.3}
372 u_{i}=r_{i} \mbox{ where } q_{i}>0
373 \end{equation}
374 $\mu$, $\lambda$ have to be a \Scalar in the \Function,
375 $F$ has to be a \Vector in the \Function,
376 $\sigma$ has to be a \Tensor in the \Function,
377 $f$ must be a \Vector in the \FunctionOnBoundary,
378 and $q$ and $r$ must be a \Vector in the \SolutionFS or must be mapped or interpolated into the particular \FunctionSpace.
379
380 \begin{classdesc}{Lame}{domain}
381 opens a Lame equation on the \Domain domain. \Lame is derived from \LinearPDE.
382 \end{classdesc}
383 \begin{methoddesc}[Lame]{setValue}{ \optional{lame_lambda} \optional{, lame_mu} \optional{, F} \optional{, sigma} \optional{, f} \optional{, r} \optional{, q}}
384 assigns new values to
385 \var{lame_lambda},
386 \var{lame_mu},
387 \var{F},
388 \var{sigma},
389 \var{f},
390 \var{r} and
391 \var{q}
392 By default all values are set to be zero.
393 \end{methoddesc}
394
395
396
397 \section{Projection}
398 %\declaremodule{extension}{esys.escript.pdetools}
399 \label{SEC Projection}
400
401 Using the \LinearPDE class provides an option to change the \FunctionSpace attribute in addition
402 to the standard interpolation mechanism\index{interpolation} as
403 discussed on in Chapter~\ref{ESCRIPT CHAP}. If one looks the
404 stripped down version
405 \begin{equation}\label{PROJ.1}
406 u = Y
407 \end{equation}
408 of the general scalar PDE~\ref{LINEARPDE.SINGLE.1} (boundary conditions are irrelevant)
409 one can see the solution $u$ of this PDE as a project of the input function $Y$
410 which has the \Function attribute to a function with the \SolutionFS or \ReducedSolutionFS
411 attribute. In fact, the solution maps values defined at
412 element centers representing a possibly discontinuous function
413 onto a continuous function represented by its values at the nodes of the FEM mesh.
414 This mapping is called a projection\index{projection}. Projection
415 can be a useful tool but needs to be applied with some care due to the fact that
416 a potentially discontinuous function is projected onto a continuous function but it can
417 also be a desirable effect for instance to smooth a function. The projection of the
418 gradient of a function typically calculated on the element center to the
419 nodes of a FEM mesh can be evaluated on the domain boundary and so projection provides a tool to extrapolate
420 the gradient from the internal to the boundary. This is only a reasonable procedure in the absence of singularities at the boundary.
421
422 As projection is used often in simulations \escript provides an easy to use class \class{Projector}
423 which is part of the \pdetools module. The following script demonstrates
424 the usage of the class to project the piecewise constant function ($=1$ for $x_{0}\ge 0.5$ and
425 $=-1$ for $x_{0}<0.5$ ) to a function with the \ReducedSolutionFS attribute (default target)
426 \begin{python}
427 from esys.escript.pdetools import Projector
428 proj=Projector(domain)
429 x0=domain.getX()[0]
430 jmp=1.-2.*wherePositive(x0-0.5)
431 u=proj.getValue(jmp)
432 # alternative call:
433 u=proj(jmp)
434 \end{python}
435 By default the class uses lumping to solve the PDE~\ref{PROJ.1}. This technique is faster
436 then using the standard solver techniques of PDEs. In essence it leads to using the average of
437 neighbor element values to calculate the value at each FEM node.
438
439 The following script illustrate how to evaluate the normal stress
440 on the boundary from a given displacement field \var{u}:
441 \begin{python}
442 from esys.escript.pdetools import Projector
443 u=...
444 proj=Projector(u.getDomin())
445 e=symmetric(grad(u))
446 stress = G*e+ (K-2./3.*G)*trace(e)*kronecker(u.getDomin())
447 normal_stress = inner(u.getDomin().getNormal(), proj(stress))
448 \end{python}
449
450
451
452 \begin{classdesc}{Projector}{domain\optional{, reduce=\True \optional{, fast=\True}}}
453 This class defines the projector on the domain \var{domain}.
454 If \var{reduce} is set to \True the projection will be returned
455 as a \ReducedSolutionFS \Data object. Otherwise \SolutionFS representation is returned.
456 If \var{reduce} is set to \True lumping is used when
457 the equation~\ref{PROJ.1} is solved. Otherwise the standard
458 PDE solver is used. Notice, that lumping is requires significant less
459 compute time and memory. The class is callable.
460 \end{classdesc}
461
462 \begin{methoddesc}[Projector]{getSolverOptions}{}
463 returns the solver options for solving the PDE. In fact the method returns
464 a \SolverOptions class object which can be used to modify the tolerance,
465 the solver or the preconditioner, see Section~\ref{SEC Solver Options} for details.
466 \end{methoddesc}
467
468 \begin{methoddesc}[Projector]{getValue}{input_data}
469 projects the \var{input_data}. This method is equivalent to call an instance
470 of the class with argument \var{input_data}:
471
472 \end{methoddesc}
473
474
475 % \section{Transport Problems}
476 % \label{SEC Transport}
477
478 \section{Solver Options}
479 \label{SEC Solver Options}
480
481 \begin{classdesc}{SolverOptions}{}
482 This class defines the solver options for a linear or non-linear solver.
483 The option also supports the handling of diagnostic informations.
484 \end{classdesc}
485
486 \begin{methoddesc}[SolverOptions]{getSummary}{}
487 Returns a string reporting the current settings
488 \end{methoddesc}
489
490 \begin{methoddesc}[SolverOptions]{getName}{key}
491 Returns the name as a string of a given key
492 \end{methoddesc}
493
494 \begin{methoddesc}[SolverOptions]{setSolverMethod}{\optional{method=SolverOptions.DEFAULT}}
495 Sets the solver method to be used. Use \var{method}=\member{SolverOptions.DIRECT} to indicate that a direct rather than an iterative solver should be used and use \var{method}=\member{SolverOptions.ITERATIVE} to indicate that an iterative rather than a direct solver should be used.
496 The value of \var{method} must be one of the constants:\\
497 \member{SolverOptions.DEFAULT}\\ \member{SolverOptions.DIRECT}\\ \member{SolverOptions.CHOLEVSKY}\\
498 \member{SolverOptions.PCG}\\\member{SolverOptions.CR}\\ \member{SolverOptions.CGS}\\ \member{SolverOptions.BICGSTAB}\\
499 \member{SolverOptions.SSOR}\\
500 \member{SolverOptions.GMRES}\\ \member{SolverOptions.PRES20}\\ \member{SolverOptions.LUMPING}\\ \member{SolverOptions.ITERATIVE}\\
501 \member{SolverOptions.NONLINEAR_GMRES}\\ \member{SolverOptions.TFQMR}\\ \member{SolverOptions.MINRES}\\
502 \member{SolverOptions.GAUSS_SEIDEL}.\\
503 Not all packages support all solvers. It can be assumed that a package makes a reasonable choice if it encounters. See Table~\ref{TAB FINLEY SOLVER OPTIONS 1} for the solvers supported by \finley.
504 \end{methoddesc}
505
506 \begin{methoddesc}[SolverOptions]{getSolverMethod}{}
507 Returns key of the solver method to be used.
508 \end{methoddesc}
509
510 \begin{methoddesc}[SolverOptions]{setPreconditioner}{\optional{preconditioner=SolverOptions.JACOBI}}
511 Sets the preconditioner to be used.
512 The value of \var{preconditioner} must be one of the constants:\\
513 \member{SolverOptions.ILU0}\\ \member{SolverOptions.ILUT}\\ \member{SolverOptions.JACOBI}\\
514 \member{SolverOptions.AMG}\\ \member{SolverOptions.REC_ILU}\\ \member{SolverOptions.GAUSS_SEIDEL}\\ \member{SolverOptions.RILU}\\
515 \member{SolverOptions.NO_PRECONDITIONER}.\\
516 Not all packages support all preconditioner. It can be assumed that a package makes a reasonable choice if it encounters
517 an unknown preconditioner. See Table~\ref{TAB FINLEY SOLVER OPTIONS 2} for the solvers supported by \finley.
518 \end{methoddesc}
519
520 \begin{methoddesc}[SolverOptions]{getPreconditioner}{}
521 Returns key of the preconditioner to be used.
522 \end{methoddesc}
523
524 \begin{methoddesc}[SolverOptions]{setPackage}{\optional{package=SolverOptions.DEFAULT}}
525 Sets the solver package to be used as a solver.
526 The value of \var{method} must be one of the constants:\\
527 \member{SolverOptions.DEFAULT}\\
528 \member{SolverOptions.PASO}\\
529 \member{SolverOptions.SUPER_LU}\\
530 \member{SolverOptions.PASTIX}\\
531 \member{SolverOptions.MKL}\\
532 \member{SolverOptions.UMFPACK}\\
533 \member{SolverOptions.TRILINOS}.\\
534 Not all packages are supported on all implementation. An exception may be thrown on some platforms if a particular package is requested. Currently \finley supports \member{SolverOptions.PASO} (as default)
535 and, if available, \member{SolverOptions.MKL}
536 \footnote{If the stiffness matrix is non-regular \MKL may return without
537 returning a proper error code. If you observe suspicious solutions when using MKL, this may cause by a non-invertible operator. }
538 and \member{SolverOptions.UMFPACK}
539
540 \end{methoddesc}
541
542 \begin{methoddesc}[SolverOptions]{getPackage}{}
543 Returns the solver package key
544 \end{methoddesc}
545
546
547 \begin{methoddesc}[SolverOptions]{resetDiagnostics}{\optional{all=False}}
548 resets the diagnostics. If \var{all} is \True all diagnostics including accumulative counters are reset.
549 \end{methoddesc}
550
551 \begin{methoddesc}[SolverOptions]{getDiagnostics}{\optional{ name}}
552 Returns the diagnostic information \var{name}. The following keywords are
553 supported:
554 \begin{itemize}
555 \item "num_iter": the number of iteration steps
556 \item "cum_num_iter": the cumulative number of iteration steps
557 \item "num_level": the number of level in multi level solver
558 \item "num_inner_iter": the number of inner iteration steps
559 \item"cum_num_inner_iter": the cumulative number of inner iteration steps
560 \item"time": execution time
561 \item "cum_time": cumulative execution time
562 \item "set_up_time": time to set up of the solver, typically this includes factorization and reordering
563 \item "cum_set_up_time": cumulative time to set up of the solver
564 \item "net_time": net execution time, excluding setup time for the solver and execution time for preconditioner
565 \item "cum_net_time": cumulative net execution time
566 \item "residual_norm": norm of the final residual
567 \item "converged": status of convergence
568 \item "preconditioner_size": size of precondtioner in Mbytes.
569 \end{itemize}
570 \end{methoddesc}
571
572
573 \begin{methoddesc}[SolverOptions]{hasConverged}{}
574 Returns \True if the last solver call has been finalized successfully.
575 If an exception has been thrown by the solver the status of this flag is undefined.
576 \end{methoddesc}
577
578 \begin{methoddesc}[SolverOptions]{setCoarsening}{\optional{method=SolverOptions.DEFAULT}}
579 Sets the key of the coarsening method to be applied in \AMG.
580 The value of \var{method} must be one of the constants:\\
581 \member{SolverOptions.DEFAULT}\\
582 \member{SolverOptions.STANDARD_COARSENING}\\
583 \member{SolverOptions.YAIR_SHAPIRA_COARSENING}, \\
584 \member{SolverOptions.RUGE_STUEBEN_COARSENING}~\footnote{The Ruge-Stueben and aggregation coarsening algorithms used for measuring the strength of connection only, but splitting is done with greedy algorithm.}, \\ \member{SolverOptions.AGGREGATION_COARSENING}.
585 \end{methoddesc}
586
587 \begin{methoddesc}[SolverOptions]{getCoarsening}{}
588 Returns the key of the coarsening algorithm to be applied \AMG.
589 \end{methoddesc}
590
591 \begin{methoddesc}[SolverOptions]{setReordering}{\optional{ordering=SolverOptions.DEFAULT_REORDERING}}
592 Sets the key of the reordering method to be applied if supported by the solver. Some direct solvers support reordering to optimize compute time and storage use during elimination. The value of \var{ordering} must be one of the constants
593 \member{SolverOptions.NO_REORDERING}, \member{SolverOptions.MINIMUM_FILL_IN},
594 \member{SolverOptions.NESTED_DISSECTION}, or \member{SolverOptions.DEFAULT_REORDERING}.
595 \end{methoddesc}
596
597 \begin{methoddesc}[SolverOptions]{getReordering}{}
598 Returns the key of the reordering method to be applied if supported by the solver.
599 \end{methoddesc}
600
601 \begin{methoddesc}[SolverOptions]{setRestart}{\optional{restart=None}}
602 Sets the number of iterations steps after which \GMRES is performing a restart.
603 If \var{restart} is equal to \var{None} no restart is performed.
604 \end{methoddesc}
605
606
607 \begin{methoddesc}[SolverOptions]{getRestart}{}
608 Returns the number of iterations steps after which \GMRES is performing a restart.
609 \end{methoddesc}
610
611 \begin{methoddesc}[SolverOptions]{setTruncation}{\optional{truncation=20}}
612 Sets the number of residuals in \GMRES to be stored for orthogonalization. The more residuals are stored the faster \GMRES converges but
613 \end{methoddesc}
614
615 \begin{methoddesc}[SolverOptions]{getTruncation}{}
616 Returns the number of residuals in \GMRES to be stored for orthogonalization
617 \end{methoddesc}
618
619
620 \begin{methoddesc}[SolverOptions]{setIterMax}{\optional{iter_max=10000}}
621 Sets the maximum number of iteration steps
622 \end{methoddesc}
623
624 \begin{methoddesc}[SolverOptions]{getIterMax}{}
625 Returns maximum number of iteration steps
626 \end{methoddesc}
627
628 \begin{methoddesc}[SolverOptions]{setLevelMax}{\optional{level_max=10}}
629 Sets the maximum number of coarsening levels to be used in the \AMG solver or preconditioner.
630 \end{methoddesc}
631
632 \begin{methoddesc}[SolverOptions]{getLevelMax}{}
633 Returns the maximum number of coarsening levels to be used in an algebraic multi level solver or preconditioner
634 \end{methoddesc}
635
636 \begin{methoddesc}[SolverOptions]{setCoarseningThreshold}{\optional{theta=0.25}}
637 Sets the threshold for coarsening in the \AMG solver or preconditioner
638 \end{methoddesc}
639
640 \begin{methoddesc}[SolverOptions]{getCoarseningThreshold}{}
641 Returns the threshold for coarsening in the \AMG solver or preconditioner
642 \end{methoddesc}
643
644 \begin{methoddesc}[SolverOptions]{setMinCoarseMatrixSize}{\optional{size=500}}
645 Sets the minumum size of the coarsest level matrix in \AMG.
646 \end{methoddesc}
647
648 \begin{methoddesc}[SolverOptions]{getMinCoarseMatrixSize}{}
649 Returns the minumum size of the coarsest level matrix in \AMG.
650 \end{methoddesc}
651
652 \begin{methoddesc}[SolverOptions]{setSmoother}{\optional{smoother=\GAUSSSEIDEL}}
653 Sets the \JACOBI or \GAUSSSEIDEL smoother to be used in \AMG.
654 \end{methoddesc}
655
656 \begin{methoddesc}[SolverOptions]{getSmoother}{}
657 Returns the key for \JACOBI or \GAUSSSEIDEL smoother used in \AMG.
658 \end{methoddesc}
659
660 \begin{methoddesc}[SolverOptions]{setNumSweeps}{\optional{sweeps=2}}
661 Sets the number of sweeps in a \JACOBI or \GAUSSSEIDEL preconditioner.
662 \end{methoddesc}
663
664 \begin{methoddesc}[SolverOptions]{getNumSweeps}{}
665 Returns the number of sweeps in a \JACOBI or \GAUSSSEIDEL preconditioner.
666 \end{methoddesc}
667
668 \begin{methoddesc}[SolverOptions]{setNumPreSweeps}{\optional{sweeps=2}}
669 Sets the number of sweeps in the pre-smoothing step of \AMG
670 \end{methoddesc}
671
672 \begin{methoddesc}[SolverOptions]{getNumPreSweeps}{}
673 Returns the number of sweeps in the pre-smoothing step of \AMG
674 \end{methoddesc}
675
676 \begin{methoddesc}[SolverOptions]{setNumPostSweeps}{\optional{sweeps=2}}
677 Sets the number of sweeps in the post-smoothing step of \AMG
678 \end{methoddesc}
679
680 \begin{methoddesc}[SolverOptions]{getNumPostSweeps}{}
681 Returns he number of sweeps sweeps in the post-smoothing step of \AMG
682 \end{methoddesc}
683
684 \begin{methoddesc}[SolverOptions]{setTolerance}{\optional{rtol=1.e-8}}
685 Sets the relative tolerance for the solver. The actually meaning of tolerance depends
686 on the underlying PDE library. In most cases, the tolerance
687 will only consider the error from solving the discrete problem but will
688 not consider any discretization error.
689 \end{methoddesc}
690
691 \begin{methoddesc}[SolverOptions]{getTolerance}{}
692 Returns the relative tolerance for the solver
693 \end{methoddesc}
694
695 \begin{methoddesc}[SolverOptions]{setAbsoluteTolerance}{\optional{atol=0.}}
696 Sets the absolute tolerance for the solver. The actually meaning of tolerance depends
697 on the underlying PDE library. In most cases, the tolerance
698 will only consider the error from solving the discrete problem but will
699 not consider any discretization error.
700 \end{methoddesc}
701
702 \begin{methoddesc}[SolverOptions]{getAbsoluteTolerance}{}
703 Returns the absolute tolerance for the solver
704 \end{methoddesc}
705
706
707 \begin{methoddesc}[SolverOptions]{setInnerTolerance}{\optional{rtol=0.9}}
708 Sets the relative tolerance for an inner iteration scheme for instance
709 on the coarsest level in a multi-level scheme.
710 \end{methoddesc}
711
712 \begin{methoddesc}[SolverOptions]{getInnerTolerance}{}
713 Returns the relative tolerance for an inner iteration scheme
714 \end{methoddesc}
715
716 \begin{methoddesc}[SolverOptions]{setDropTolerance}{\optional{drop_tol=0.01}}
717 Sets the relative drop tolerance in ILUT
718 \end{methoddesc}
719
720 \begin{methoddesc}[SolverOptions]{getDropTolerance}{}
721 Returns the relative drop tolerance in \ILUT
722 \end{methoddesc}
723
724
725 \begin{methoddesc}[SolverOptions]{setDropStorage}{\optional{storage=2.}}
726 Sets the maximum allowed increase in storage for \ILUT. \var{storage}=2 would mean that a doubling of the storage needed for the coefficient matrix is allowed in the \ILUT factorization.
727 \end{methoddesc}
728
729 \begin{methoddesc}[SolverOptions]{getDropStorage}{}
730 Returns the maximum allowed increase in storage for \ILUT
731 \end{methoddesc}
732
733 \begin{methoddesc}[SolverOptions]{setRelaxationFactor}{\optional{factor=0.3}}
734 Sets the relaxation factor used to add dropped elements in \RILU to the main diagonal.
735 \end{methoddesc}
736
737 \begin{methoddesc}[SolverOptions]{getRelaxationFactor}{}
738 Returns the relaxation factor used to add dropped elements in RILU to the main diagonal.
739 \end{methoddesc}
740
741 \begin{methoddesc}[SolverOptions]{isSymmetric}{}
742 Returns \True is the descrete system is indicated as symmetric.
743 \end{methoddesc}
744
745 \begin{methoddesc}[SolverOptions]{setSymmetryOn}{}
746 Sets the symmetry flag to indicate that the coefficient matrix is symmetric.
747 \end{methoddesc}
748
749 \begin{methoddesc}[SolverOptions]{setSymmetryOff}{}
750 Clears the symmetry flag for the coefficient matrix.
751 \end{methoddesc}
752
753 \begin{methoddesc}[SolverOptions]{isVerbose}{}
754 Returns \True if the solver is expected to be verbose.
755 \end{methoddesc}
756
757
758 \begin{methoddesc}[SolverOptions]{setVerbosityOn}{}
759 Switches the verbosity of the solver on.
760 \end{methoddesc}
761
762
763 \begin{methoddesc}[SolverOptions]{setVerbosityOff}{}
764 Switches the verbosity of the solver off.
765 \end{methoddesc}
766
767
768 \begin{methoddesc}[SolverOptions]{adaptInnerTolerance}{}
769 Returns \True if the tolerance of the inner solver is selected automatically.
770 Otherwise the inner tolerance set by \member{setInnerTolerance} is used.
771 \end{methoddesc}
772
773 \begin{methoddesc}[SolverOptions]{setInnerToleranceAdaptionOn}{}
774 Switches the automatic selection of inner tolerance on
775 \end{methoddesc}
776
777 \begin{methoddesc}[SolverOptions]{setInnerToleranceAdaptionOff}{}
778 Switches the automatic selection of inner tolerance off.
779 \end{methoddesc}
780
781 \begin{methoddesc}[SolverOptions]{setInnerIterMax}{\optional{iter_max=10}}
782 Sets the maximum number of iteration steps for the inner iteration.
783 \end{methoddesc}
784
785 \begin{methoddesc}[SolverOptions]{getInnerIterMax}{}
786 Returns maximum number of inner iteration steps.
787 \end{methoddesc}
788
789 \begin{methoddesc}[SolverOptions]{acceptConvergenceFailure}{}
790 Returns \True if a failure to meet the stopping criteria within the
791 given number of iteration steps is not raising in exception. This is useful
792 if a solver is used in a non-linear context where the non-linear solver can
793 continue even if the returned the solution does not necessarily meet the
794 stopping criteria. One can use the \member{hasConverged} method to check if the
795 last call to the solver was successful.
796 \end{methoddesc}
797
798 \begin{methoddesc}[SolverOptions]{setAcceptanceConvergenceFailureOn}{}
799 Switches the acceptance of a failure of convergence on.
800 \end{methoddesc}
801
802 \begin{methoddesc}[SolverOptions]{setAcceptanceConvergenceFailureOff}{}
803 Switches the acceptance of a failure of convergence off.
804 \end{methoddesc}
805
806 \begin{memberdesc}[SolverOptions]{DEFAULT}
807 default method, preconditioner or package to be used to solve the PDE. An appropriate method should be
808 chosen by the used PDE solver library.
809 \end{memberdesc}
810
811 \begin{memberdesc}[SolverOptions]{MKL}
812 the \MKL library by Intel,~\Ref{MKL}\footnote{The \MKL library will only be available when the Intel compilation environment is used.}.
813 \end{memberdesc}
814
815 \begin{memberdesc}[SolverOptions]{UMFPACK}
816 the \UMFPACK,~\Ref{UMFPACK}. Remark: \UMFPACK is not parallelized.
817 \end{memberdesc}
818
819 \begin{memberdesc}[SolverOptions]{PASO}
820 \PASO is the solver library of \finley, see \Sec{CHAPTER ON FINLEY}.
821 \end{memberdesc}
822
823 \begin{memberdesc}[SolverOptions]{ITERATIVE}
824 the default iterative method and preconditioner. The actually used method depends on the PDE solver library and the solver package been chosen. Typically, \PCG is used for symmetric PDEsand \BiCGStab otherwise, both with \JACOBI preconditioner.
825 \end{memberdesc}
826
827 \begin{memberdesc}[SolverOptions]{DIRECT}
828 the default direct linear solver.
829 \end{memberdesc}
830
831 \begin{memberdesc}[SolverOptions]{CHOLEVSKY}
832 direct solver based on Cholevsky factorization (or similar), see~\Ref{Saad}. The solver will require a symmetric PDE.
833 \end{memberdesc}
834
835 \begin{memberdesc}[SolverOptions]{PCG}
836 preconditioned conjugate gradient method, see~\Ref{WEISS}\index{linear solver!PCG}\index{PCG}. The solver will require a symmetric PDE.
837 \end{memberdesc}
838
839 \begin{memberdesc}[SolverOptions]{TFQMR}
840 transpose-free quasi-minimal residual method, see~\Ref{WEISS}\index{linear solver!TFQMR}\index{TFQMR}. \end{memberdesc}
841
842 \begin{memberdesc}[SolverOptions]{GMRES}
843 the GMRES method, see~\Ref{WEISS}\index{linear solver!GMRES}\index{GMRES}. Truncation and restart are controlled by the parameters
844 \var{truncation} and \var{restart} of \method{getSolution}.
845 \end{memberdesc}
846
847 \begin{memberdesc}[SolverOptions]{MINRES}
848 minimal residual method method, \index{linear solver!MINRES}\index{MINRES} \end{memberdesc}
849
850 \begin{memberdesc}[SolverOptions]{LUMPING}
851 uses lumping to solve the system of linear equations~\index{linear solver!lumping}\index{lumping}. This solver technique
852 condenses the stiffness matrix to a diagonal matrix so the solution of the linear systems becomes very cheap. It can be used when
853 only \var{D} is present but in any case has to applied with care. The difference in the solutions with and without lumping can be significant
854 but is expected to converge to zero when the mesh gets finer.
855 Lumping does not use the linear system solver library.
856 \end{memberdesc}
857
858 \begin{memberdesc}[SolverOptions]{PRES20}
859 the GMRES method with truncation after five residuals and
860 restart after 20 steps, see~\Ref{WEISS}.
861 \end{memberdesc}
862
863 \begin{memberdesc}[SolverOptions]{CGS}
864 conjugate gradient squared method, see~\Ref{WEISS}.
865 \end{memberdesc}
866
867 \begin{memberdesc}[SolverOptions]{BICGSTAB}
868 stabilized bi-conjugate gradients methods, see~\Ref{WEISS}.
869 \end{memberdesc}
870
871 \begin{memberdesc}[SolverOptions]{SSOR}
872 symmetric successive over-relaxation method, see~\Ref{WEISS}. Typically used as preconditioner but some linear solver libraries support
873 this as a solver.
874 \end{memberdesc}
875
876 \begin{memberdesc}[SolverOptions]{ILU0}
877 the incomplete LU factorization preconditioner with no fill-in, see~\Ref{Saad}.
878 \end{memberdesc}
879
880 \begin{memberdesc}[SolverOptions]{ILUT}
881 the incomplete LU factorization preconditioner with fill-in, see~\Ref{Saad}. During the LU-factorization element with
882 relative size less then \member{getDropTolerance} are dropped. Moreover, the size of the LU-factorization is restricted to the
883 \member{getDropStorage}-fold of the stiffness matrix. \member{getDropTolerance} and \member{getDropStorage} are both set in the
884 \method{getSolution} call.
885 \end{memberdesc}
886
887 \begin{memberdesc}[SolverOptions]{JACOBI}
888 the Jacobi preconditioner, see~\Ref{Saad}.
889 \end{memberdesc}
890
891
892 \begin{memberdesc}[SolverOptions]{AMG}
893 the algebraic--multi grid method, see~\Ref{AMG}. This method can be used as linear solver method but is more robust when used
894 in a preconditioner.
895 \end{memberdesc}
896
897 \begin{memberdesc}[SolverOptions]{GAUSS_SEIDEL}
898 the symmetric Gauss-Seidel preconditioner, see~\Ref{Saad}.
899 \member{getNumSweeps()} is the number of sweeps used.
900 \end{memberdesc}
901
902 \begin{memberdesc}[SolverOptions]{RILU}
903 relaxed incomplete LU factorization preconditioner, see~\Ref{RELAXILU}. This method is similar to the one used for \ILU but dropped elements are added to the main diagonal
904 with the relaxation factor \member{getRelaxationFactor}.
905 \end{memberdesc}
906
907 \begin{memberdesc}[SolverOptions]{REC_ILU}
908 recursive incomplete LU factorization preconditioner, see~\Ref{RILU}. This method is similar to the one used for \ILU but applies reordering during the factorization.
909 \end{memberdesc}
910
911 \begin{memberdesc}[SolverOptions]{NO_REORDERING}
912 no ordering is used during factorization.
913 \end{memberdesc}
914
915 \begin{memberdesc}[SolverOptions]{DEFAULT_REORDERING}
916 the default reordering method during factorization.
917 \end{memberdesc}
918
919 \begin{memberdesc}[SolverOptions]{MINIMUM_FILL_IN}
920 applies reordering before factorization using a fill-in minimization strategy. You have to check with the particular solver library or
921 linear solver package if this is supported. In any case, it is advisable to apply reordering on the mesh to minimize fill-in.
922 \end{memberdesc}
923
924 \begin{memberdesc}[SolverOptions]{NESTED_DISSECTION}
925 applies reordering before factorization using a nested dissection strategy. You have to check with the particular solver library or
926 linear solver package if this is supported. In any case, it is advisable to apply reordering on the mesh to minimize fill-in.
927 \end{memberdesc}
928
929 \begin{memberdesc}[SolverOptions]{TRILINOS}
930 the Trilinos library is used as a solver~\Ref{TRILINOS}
931 \end{memberdesc}
932
933 \begin{memberdesc}[SolverOptions]{SUPER_LU}
934 the SuperLU library is used as a solver~\Ref{SuperLU}
935 \end{memberdesc}
936
937 \begin{memberdesc}[SolverOptions]{PASTIX}
938 the Pastix library is used as a solver~\Ref{PASTIX}
939 \end{memberdesc}
940
941
942 \begin{memberdesc}[SolverOptions]{STANDARD_COARSENING}
943 \AMG coarsening method by Ruge and Stueben using measure of importance principle~\cite{Multigrid}.
944 \end{memberdesc}
945
946 \begin{memberdesc}[SolverOptions]{YAIR_SHAPIRA_COARSENING}
947 \AMG coarsening method by Yair-Shapira
948 \end{memberdesc}
949
950 \begin{memberdesc}[SolverOptions]{RUGE_STUEBEN_COARSENING} \AMG coarsening method by Ruge and Stueben using greedy algorithm for splitting.
951 \end{memberdesc}
952
953 \begin{memberdesc}[SolverOptions]{AGGREGATION_COARSENING} \AMG coarsening using (symmetric) aggregation using greedy algorithm for splitting.
954 \end{memberdesc}
955
956 \begin{memberdesc}[SolverOptions]{NO_PRECONDITIONER}
957 no preconditioner is applied.
958 \end{memberdesc}
959

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26