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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 ksteube 1811
2     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 ksteube 1316 %
4 jfenwick 2881 % Copyright (c) 2003-2010 by University of Queensland
5 ksteube 1811 % Earth Systems Science Computational Center (ESSCC)
6     % http://www.uq.edu.au/esscc
7 gross 625 %
8 ksteube 1811 % 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 gross 625 %
12 ksteube 1811 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13 jgs 102
14 ksteube 1811
15 caltinay 3293 \chapter{The \linearPDEs Module}
16 jgs 102
17 gross 999 \section{Linear Partial Differential Equations}
18 jgs 102 \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 gross 660 the outer normal field on $\Gamma$.
24 jgs 102
25 gross 660 For a single PDE with a solution with a single component the linear PDE is defined in the
26 jgs 102 following form:
27     \begin{equation}\label{LINEARPDE.SINGLE.1}
28 jfenwick 3295 -(A_{jl} u_{,l})_{,j}-(B_{j} u)_{,j}+C_{l} u_{,l}+D u =-X_{j,j}+Y \; .
29 jgs 102 \end{equation}
30 gross 660 $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 jgs 102 The following natural
35     boundary conditions are considered \index{boundary condition!natural} on $\Gamma$:
36     \begin{equation}\label{LINEARPDE.SINGLE.2}
37 jfenwick 3295 n_{j}(A_{jl} u_{,l}+B_{j} u)+d u=n_{j}X_{j} + y \;.
38 jgs 102 \end{equation}
39 gross 660 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 jgs 102 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 gross 660 or \eqn{LINEARPDE.SINGLE.2}.
49 gross 625
50 jgs 102 For a system of PDEs and a solution with several components the PDE has the form
51     \begin{equation}\label{LINEARPDE.SYSTEM.1}
52 jfenwick 3295 -(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 jgs 102 \end{equation}
54 gross 660 $A$ is a \RankFour, $B$ and $C$ are each a \RankThree, $D$ and $X$ are each a \RankTwo and $Y$ is a \RankOne.
55 jgs 102 The natural boundary conditions \index{boundary condition!natural} take the form:
56     \begin{equation}\label{LINEARPDE.SYSTEM.2}
57 jfenwick 3295 n_{j}(A_{ijkl} u_{k,l}+B_{ijk} u_{k})+d_{ik} u_{k}=n_{j}X_{ij}+y_{i} \;.
58 jgs 102 \end{equation}
59 gross 660 The coefficient $d$ is a \RankTwo and $y$ is a
60 jgs 102 \RankOne both in the \FunctionOnBoundary. Constraints \index{constraint} take the form
61     \begin{equation}\label{LINEARPDE.SYSTEM.3}
62 jfenwick 3295 u_{i}=r_{i} \mbox{ where } q_{i}>0
63 jgs 102 \end{equation}
64 gross 660 $r$ and $q$ are each \RankOne. Notice that not necessarily all components must
65 gross 625 have a constraint at all locations.
66    
67 jgs 102 \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 jfenwick 3295 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 gross 660 defined as
71 jgs 102 \begin{equation}\label{LINEARPDE.SYSTEM.5}
72 jfenwick 3295 J_{ij}=A_{ijkl}u_{k,l}+B_{ijk}u_{k}-X_{ij}
73 jgs 102 \end{equation}
74     For the case of single solution component and single PDE $J$ is defined
75     \begin{equation}\label{LINEARPDE.SINGLE.5}
76 jfenwick 3295 J_{j}=A_{jl}u_{,l}+B_{j}u_{k}-X_{j}
77 jgs 102 \end{equation}
78 gross 660 In the context of discontinuities \index{discontinuity} $n$ denotes the normal on the
79 jgs 102 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 jfenwick 3295 n_{j} J^{0}_{ij}=n_{j} J^{1}_{ij}=y^{contact}_{i} - d^{contact}_{ik} [u]_{k} \; .
83 jgs 102 \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 gross 660 The coefficient $d^{contact}$ is a \RankTwo and $y^{contact}$ is a
88 jgs 102 \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 jfenwick 3295 n_{j} J^{0}_{j}=n_{j} J^{1}_{j}=y^{contact} - d^{contact}[u]
92 jgs 102 \end{equation}
93 ksteube 1316 In this case the the coefficient $d^{contact}$ and $y^{contact}$ are each \Scalar
94 jgs 102 both in the \FunctionOnContactZero or \FunctionOnContactOne.
95 gross 625
96     The PDE is symmetrical \index{symmetrical} if
97     \begin{equation}\label{LINEARPDE.SINGLE.4}
98 jfenwick 3295 A_{jl}=A_{lj} \mbox{ and } B_{j}=C_{j}
99 gross 625 \end{equation}
100     The system of PDEs is symmetrical \index{symmetrical} if
101     \begin{eqnarray}
102     \label{LINEARPDE.SYSTEM.4}
103 jfenwick 3295 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 gross 625 \end{eqnarray}
109 jfenwick 1959 Note that in contrast with the scalar case~\eqn{LINEARPDE.SINGLE.4} now the coefficients $D$, $d$ abd $d^{contact}$
110 gross 625 have to be inspected.
111    
112 gross 2474 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 gross 999
125 gross 2474 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 artak 2559 mypde.getSolverOptions().setIterMax(1000)
140 gross 2474 u=mypde.getSolution()
141     \end{python}
142 jfenwick 3301 In this example, the preconditioned conjugate gradient method \PCG is used
143 gross 2864 with preconditioner \AMG. The relative tolerance is set to $10^{-8}$ and
144 gross 2474 the maximum number of iteration steps to $1000$.
145 jfenwick 3301 After a completed solution call,
146 gross 2474 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 lgao 2596 print 'Net time =', mypde.getDiagnostics('net_time')
153 gross 2474 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 gross 999 \subsection{Classes}
158 caltinay 3306 %\declaremodule{extension}{esys.escript.linearPDEs}
159     %\modulesynopsis{Linear partial differential equation handler}
160 gross 999 The module \linearPDEs provides an interface to define and solve linear partial
161 jfenwick 1959 differential equations within \escript. The module \linearPDEs does not provide any
162 gross 999 solver capabilities in itself but hands the PDE over to
163 gross 2474 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 gross 999 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 ksteube 1316 This is the general class to define a linear PDE in \escript. We list a selection of the most
170 jfenwick 1959 important methods of the class. For a complete list, see the reference at \ReferenceGuide.
171 gross 625
172 jgs 102 \begin{classdesc}{LinearPDE}{domain,numEquations=0,numSolutions=0}
173 jfenwick 3301 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 ksteube 1316 and the number solutions, respectively, stay undefined until a coefficient is
177 gross 660 defined.
178 jgs 102 \end{classdesc}
179    
180 jfenwick 1959 \subsubsection{\LinearPDE methods}
181    
182 gross 625 \begin{methoddesc}[LinearPDE]{setValue}{
183 gross 660 \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 ksteube 1316 assigns new values to coefficients. By default all values are assumed to be zero\footnote{
190 gross 660 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 gross 625 If the new coefficient value is not a \Data object, it is converted into a \Data object in the
194 jgs 102 appropriate \FunctionSpace.
195     \end{methoddesc}
196    
197     \begin{methoddesc}[LinearPDE]{getCoefficient}{name}
198 gross 660 return the value assigned to coefficient \var{name}. If \var{name} is not a valid name
199     an exception is raised.
200 jgs 102 \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 gross 625 \begin{methoddesc}[LinearPDE]{getFunctionSpaceForCoefficient}{name}
207 jgs 102 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 jfenwick 1959 switches on debug mode.
212 jgs 102 \end{methoddesc}
213    
214     \begin{methoddesc}[LinearPDE]{setDebugOff}{}
215 jfenwick 1959 switches off debug mode.
216 jgs 102 \end{methoddesc}
217    
218 gross 2474 \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 jgs 102 \end{methoddesc}
223    
224 gross 2474 \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 jgs 102 \end{methoddesc}
228    
229 gross 653
230 gross 2474 \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 gross 653 \end{methoddesc}
234    
235    
236 gross 625 \begin{methoddesc}[LinearPDE]{getDomain}{}
237     returns the \Domain of the PDE.
238 jgs 102 \end{methoddesc}
239    
240 gross 625 \begin{methoddesc}[LinearPDE]{getDim}{}
241     returns the spatial dimension of the PDE.
242 jgs 102 \end{methoddesc}
243    
244 gross 625 \begin{methoddesc}[LinearPDE]{getNumEquations}{}
245     returns the number of equations.
246     \end{methoddesc}
247 jgs 102
248 gross 625 \begin{methoddesc}[LinearPDE]{getNumSolutions}{}
249     returns the number of components of the solution.
250 jgs 102 \end{methoddesc}
251    
252 gross 625 \begin{methoddesc}[LinearPDE]{checkSymmetry}{verbose=\False}
253 gross 660 returns \True if the PDE is symmetric and \False otherwise.
254 jfenwick 1959 The method is very computationally expensive and should only be
255 gross 625 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 jgs 102 \end{methoddesc}
259    
260 gross 625 \begin{methoddesc}[LinearPDE]{getFlux}{u}
261 jfenwick 3295 returns the flux $J_{ij}$ \index{flux} for given solution \var{u}
262 gross 625 defined by \eqn{LINEARPDE.SYSTEM.5} and \eqn{LINEARPDE.SINGLE.5}, respectively.
263 jgs 102 \end{methoddesc}
264    
265 gross 625
266 jgs 102 \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 gross 660 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 gross 625 be supported by all PDE libraries.
283 jgs 102 \end{methoddesc}
284    
285     \begin{methoddesc}[LinearPDE]{setReducedOrderOff}{}
286 gross 660 switches off the reduction of polynomial order for the solution and
287 jgs 102 equation evaluation.
288     \end{methoddesc}
289    
290     \begin{methoddesc}[LinearPDE]{getOperator}{}
291     returns the \Operator of the PDE.
292     \end{methoddesc}
293    
294 gross 625 \begin{methoddesc}[LinearPDE]{getRightHandSide}{}
295 jgs 102 returns the right hand side of the PDE as a \Data object. If
296 jfenwick 1959 \var{ignoreConstraint}=\True, then the constraints are not considered
297 jgs 102 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 gross 2474 \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 jgs 102 \end{methoddesc}
310    
311 jfenwick 1959
312 gross 2474
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 jfenwick 3295 -u_{,ii}=f\; .
318 gross 2474 \end{equation}
319     with homogeneous boundary conditions
320     \begin{equation}\label{POISSON.2}
321 jfenwick 3295 n_{i}u_{,i}=0
322 gross 2474 \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 jfenwick 3295 \omega \; u - (k\; u_{,j})_{,j} = f
341 gross 2474 \end{equation}
342     with natural boundary conditions
343     \begin{equation}\label{HZ.2}
344 jfenwick 3295 k\; u_{,j} n_{,j} = g- \alpha \; u
345 gross 2474 \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 jfenwick 3295 -(\mu (u_{i,j}+u_{j,i})+\lambda u_{k,k}\delta_{ij})_{j} = F_{i}-\sigma_{ij,j}
365 gross 2474 \end{equation}
366     with natural boundary conditions:
367     \begin{equation}\label{LE.2}
368 jfenwick 3295 n_{j}(\mu \; (u_{i,j}+u_{j,i})+\lambda u_{k,k}\delta_{ij}) = f_{i}+n_{j}\sigma_{ij}
369 gross 2474 \end{equation}
370     and constraint
371     \begin{equation}\label{LE.3}
372 jfenwick 3295 u_{i}=r_{i} \mbox{ where } q_{i}>0
373 gross 2474 \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 gross 2864
396    
397     \section{Projection}
398 caltinay 3306 %\declaremodule{extension}{esys.escript.pdetools}
399 gross 2864 \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 jfenwick 3295 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 gross 2864 \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 gross 2474 % \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 jfenwick 3301 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 gross 2558 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 gross 2474 \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 jfenwick 3301 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 gross 2474 Not all packages support all preconditioner. It can be assumed that a package makes a reasonable choice if it encounters
517 gross 2558 an unknown preconditioner. See Table~\ref{TAB FINLEY SOLVER OPTIONS 2} for the solvers supported by \finley.
518 gross 2474 \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 jfenwick 3301 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 gross 2748 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 gross 2474 \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 lgao 2596 \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 gross 2474 \item "residual_norm": norm of the final residual
567 gross 3094 \item "converged": status of convergence
568     \item "preconditioner_size": size of precondtioner in Mbytes.
569 gross 2474 \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 jfenwick 3301 The value of \var{method} must be one of the constants:\\
581     \member{SolverOptions.DEFAULT}\\
582     \member{SolverOptions.STANDARD_COARSENING}\\
583 jfenwick 2651 \member{SolverOptions.YAIR_SHAPIRA_COARSENING}, \\
584 jfenwick 3301 \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 gross 2474 \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 jfenwick 3301 Sets the number of residuals in \GMRES to be stored for orthogonalization. The more residuals are stored the faster \GMRES converges but
613 gross 2474 \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 artak 2976 \begin{methoddesc}[SolverOptions]{setCoarseningThreshold}{\optional{theta=0.25}}
637 gross 2474 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 artak 2524 \begin{methoddesc}[SolverOptions]{setMinCoarseMatrixSize}{\optional{size=500}}
645 artak 2976 Sets the minumum size of the coarsest level matrix in \AMG.
646 artak 2524 \end{methoddesc}
647    
648     \begin{methoddesc}[SolverOptions]{getMinCoarseMatrixSize}{}
649 artak 2976 Returns the minumum size of the coarsest level matrix in \AMG.
650 artak 2524 \end{methoddesc}
651    
652 artak 2976 \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 gross 2474 \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 gross 660 default method, preconditioner or package to be used to solve the PDE. An appropriate method should be
808 gross 625 chosen by the used PDE solver library.
809     \end{memberdesc}
810 jgs 102
811 gross 2474 \begin{memberdesc}[SolverOptions]{MKL}
812 gross 2558 the \MKL library by Intel,~\Ref{MKL}\footnote{The \MKL library will only be available when the Intel compilation environment is used.}.
813 gross 625 \end{memberdesc}
814 jgs 102
815 gross 2474 \begin{memberdesc}[SolverOptions]{UMFPACK}
816 gross 2558 the \UMFPACK,~\Ref{UMFPACK}. Remark: \UMFPACK is not parallelized.
817 gross 625 \end{memberdesc}
818 jgs 102
819 gross 2474 \begin{memberdesc}[SolverOptions]{PASO}
820 gross 2558 \PASO is the solver library of \finley, see \Sec{CHAPTER ON FINLEY}.
821 gross 625 \end{memberdesc}
822 jgs 102
823 gross 2474 \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 gross 625 \end{memberdesc}
826 jgs 102
827 gross 2474 \begin{memberdesc}[SolverOptions]{DIRECT}
828 gross 660 the default direct linear solver.
829 gross 625 \end{memberdesc}
830 jgs 102
831 gross 2474 \begin{memberdesc}[SolverOptions]{CHOLEVSKY}
832 gross 660 direct solver based on Cholevsky factorization (or similar), see~\Ref{Saad}. The solver will require a symmetric PDE.
833 gross 625 \end{memberdesc}
834 jgs 110
835 gross 2474 \begin{memberdesc}[SolverOptions]{PCG}
836 gross 653 preconditioned conjugate gradient method, see~\Ref{WEISS}\index{linear solver!PCG}\index{PCG}. The solver will require a symmetric PDE.
837 gross 625 \end{memberdesc}
838 jgs 110
839 gross 2474 \begin{memberdesc}[SolverOptions]{TFQMR}
840 artak 1978 transpose-free quasi-minimal residual method, see~\Ref{WEISS}\index{linear solver!TFQMR}\index{TFQMR}. \end{memberdesc}
841    
842 gross 2474 \begin{memberdesc}[SolverOptions]{GMRES}
843 gross 653 the GMRES method, see~\Ref{WEISS}\index{linear solver!GMRES}\index{GMRES}. Truncation and restart are controlled by the parameters
844 gross 625 \var{truncation} and \var{restart} of \method{getSolution}.
845     \end{memberdesc}
846 jgs 102
847 gross 2474 \begin{memberdesc}[SolverOptions]{MINRES}
848 artak 1978 minimal residual method method, \index{linear solver!MINRES}\index{MINRES} \end{memberdesc}
849    
850 gross 2474 \begin{memberdesc}[SolverOptions]{LUMPING}
851 gross 660 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 gross 653 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 jfenwick 1959 but is expected to converge to zero when the mesh gets finer.
855 gross 660 Lumping does not use the linear system solver library.
856 gross 625 \end{memberdesc}
857 jgs 107
858 gross 2474 \begin{memberdesc}[SolverOptions]{PRES20}
859 gross 653 the GMRES method with truncation after five residuals and
860 gross 625 restart after 20 steps, see~\Ref{WEISS}.
861 gross 999 \end{memberdesc}
862 gross 625
863 gross 2474 \begin{memberdesc}[SolverOptions]{CGS}
864 gross 625 conjugate gradient squared method, see~\Ref{WEISS}.
865 jgs 107 \end{memberdesc}
866    
867 gross 2474 \begin{memberdesc}[SolverOptions]{BICGSTAB}
868 gross 660 stabilized bi-conjugate gradients methods, see~\Ref{WEISS}.
869 jgs 107 \end{memberdesc}
870    
871 gross 2474 \begin{memberdesc}[SolverOptions]{SSOR}
872 gross 653 symmetric successive over-relaxation method, see~\Ref{WEISS}. Typically used as preconditioner but some linear solver libraries support
873 gross 660 this as a solver.
874 gross 625 \end{memberdesc}
875 gross 2474
876     \begin{memberdesc}[SolverOptions]{ILU0}
877 gross 660 the incomplete LU factorization preconditioner with no fill-in, see~\Ref{Saad}.
878 gross 653 \end{memberdesc}
879    
880 gross 2474 \begin{memberdesc}[SolverOptions]{ILUT}
881 gross 653 the incomplete LU factorization preconditioner with fill-in, see~\Ref{Saad}. During the LU-factorization element with
882 gross 2474 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 gross 660 \method{getSolution} call.
885 gross 653 \end{memberdesc}
886    
887 gross 2474 \begin{memberdesc}[SolverOptions]{JACOBI}
888 gross 653 the Jacobi preconditioner, see~\Ref{Saad}.
889     \end{memberdesc}
890    
891 gross 2474
892     \begin{memberdesc}[SolverOptions]{AMG}
893 gross 660 the algebraic--multi grid method, see~\Ref{AMG}. This method can be used as linear solver method but is more robust when used
894 gross 653 in a preconditioner.
895     \end{memberdesc}
896    
897 gross 2474 \begin{memberdesc}[SolverOptions]{GAUSS_SEIDEL}
898 artak 1978 the symmetric Gauss-Seidel preconditioner, see~\Ref{Saad}.
899 gross 2474 \member{getNumSweeps()} is the number of sweeps used.
900 artak 1978 \end{memberdesc}
901    
902 gross 2474 \begin{memberdesc}[SolverOptions]{RILU}
903 jfenwick 3301 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 gross 653 \end{memberdesc}
906 jgs 107
907 gross 2474 \begin{memberdesc}[SolverOptions]{REC_ILU}
908 jfenwick 3301 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 gross 2474 \end{memberdesc}
910    
911     \begin{memberdesc}[SolverOptions]{NO_REORDERING}
912 gross 653 no ordering is used during factorization.
913     \end{memberdesc}
914 gross 625
915 gross 2474 \begin{memberdesc}[SolverOptions]{DEFAULT_REORDERING}
916     the default reordering method during factorization.
917     \end{memberdesc}
918    
919     \begin{memberdesc}[SolverOptions]{MINIMUM_FILL_IN}
920 gross 653 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 gross 625
924 gross 2474 \begin{memberdesc}[SolverOptions]{NESTED_DISSECTION}
925 gross 653 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 gross 625
929 gross 2474 \begin{memberdesc}[SolverOptions]{TRILINOS}
930     the Trilinos library is used as a solver~\Ref{TRILINOS}
931     \end{memberdesc}
932 jgs 102
933 gross 2474 \begin{memberdesc}[SolverOptions]{SUPER_LU}
934     the SuperLU library is used as a solver~\Ref{SuperLU}
935     \end{memberdesc}
936 gross 625
937 gross 2474 \begin{memberdesc}[SolverOptions]{PASTIX}
938     the Pastix library is used as a solver~\Ref{PASTIX}
939     \end{memberdesc}
940 gross 625
941 gross 660
942 artak 2976 \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 gross 2474 \begin{memberdesc}[SolverOptions]{YAIR_SHAPIRA_COARSENING}
947     \AMG coarsening method by Yair-Shapira
948     \end{memberdesc}
949 gross 625
950 artak 2976 \begin{memberdesc}[SolverOptions]{RUGE_STUEBEN_COARSENING} \AMG coarsening method by Ruge and Stueben using greedy algorithm for splitting.
951 gross 2474 \end{memberdesc}
952 gross 660
953 artak 2976 \begin{memberdesc}[SolverOptions]{AGGREGATION_COARSENING} \AMG coarsening using (symmetric) aggregation using greedy algorithm for splitting.
954 gross 2474 \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