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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3293 - (show annotations)
Thu Oct 21 23:18:32 2010 UTC (8 years, 8 months ago) by caltinay
File MIME type: application/x-tex
File size: 42656 byte(s)
user's guide builds again with new class file. The cleanup can commence...

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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26