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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 999 - (hide annotations)
Tue Feb 27 08:12:37 2007 UTC (12 years, 1 month ago) by gross
File MIME type: application/x-tex
File size: 48272 byte(s)
start to put some pycad documentation into the users guide
1 jgs 82 % $Id$
2 gross 625 %
3     % Copyright © 2006 by ACcESS MNRF
4     % http://www.access.edu.au
5     % Primary Business: Queensland, Australia.
6     % Licensed under the Open Software License version 3.0
7     % http://www.opensource.org/licenses/osl-3.0.php
8     %
9 jgs 82
10 gross 625
11 jgs 82 \chapter{The module \escript}
12 gross 660 \label{ESCRIPT CHAP}
13 jgs 82
14    
15 jgs 102 \begin{figure}
16 gross 599 \includegraphics[width=\textwidth]{figures/EscriptDiagram1.eps}
17 jgs 102 \caption{\label{ESCRIPT DEP}Dependency of Function Spaces. An arrow indicates that a function in the
18     function space at the starting point can be interpreted as a function in the function space of the arrow target.}
19     \end{figure}
20 jgs 82
21 jgs 102 \escript is an extension of Python to handle functions represented by their values on
22 jgs 107 \DataSamplePoints for the geometrical region on which
23 jgs 102 the function is defined. The region as well as the method which is used
24     to interpolate value on the \DataSamplePoints is defined by
25     \Domain class objects. For instance when using
26     the finite element method (FEM) \index{finite element method}
27     \Domain object holds the information about the FEM mesh, eg.
28     a table of nodes and a table of elements. Although \Domain contains
29     the discretization method to be used \escript does not use this information directly.
30     \Domain objects are created from a module which want to make use
31     \escript, e.g. \finley.
32 jgs 82
33 jgs 102 The solution of a PDE is a function of its location in the domain of interest $\Omega$.
34     When solving a partial differential equation \index{partial differential equation} (PDE) using FEM
35     the solution is (piecewise) differentiable but, in general, its gradient
36     is discontinuous. To reflect these different degrees of smoothness different
37     representations of the functions are used. For instance; in FEM
38     the displacement field is represented by its values at the nodes of the mesh, while the
39     strain, which is the symmetric part of the gradient of the displacement field, is stored on the
40     element centers. To be able to classify functions with respect to their smoothness, \escript has the
41     concept of the "function space". A function space is described by a \FunctionSpace object.
42     The following statement generates the object \var{solution_space} which is
43     a \FunctionSpace object and provides access to the function space of
44     PDE solutions on the \Domain \var{mydomain}:
45     \begin{python}
46     solution_space=Solution(mydomain)
47     \end{python}
48 jgs 107 The following generators for function spaces on a \Domain \var{mydomain} are available:
49 jgs 102 \begin{itemize}
50 gross 599 \item \var{Solution(mydomain)}: solutions of a PDE.
51     \item \var{ReducedSolution(mydomain)}: solutions of a PDE with a reduced smoothness requirement.
52 jgs 102 \item \var{ContinuousFunction(mydomain)}: continuous functions, eg. a temperature distribution.
53     \item \var{Function(mydomain)}: general functions which are not necessarily continuous, eg. a stress field.
54     \item \var{FunctionOnBoundary(mydomain)}: functions on the boundary of the domain, eg. a surface pressure.
55     \item \var{FunctionOnContact0(mydomain)}: functions on side $0$ of the discontinuity.
56     \item \var{FunctionOnContact1(mydomain)}: functions on side $1$ of the discontinuity.
57     \end{itemize}
58 gross 599 The reduced smoothness for PDE solution is often used to fulfill the Ladyzhenskaya–-Babuska–-Brezzi condition \cite{LBB} when
59     solving saddle point problems \index{saddle point problems}, eg. the Stokes equation.
60 jgs 102 A discontinuity \index{discontinuity} is a region within the domain across which functions may be discontinuous.
61     The location of discontinuity is defined in the \Domain object.
62     \fig{ESCRIPT DEP} shows the dependency between the types of function spaces.
63     The solution of a PDE is a continuous function. Any continuous function can be seen as a general function
64     on the domain and can be restricted to the boundary as well as to any side of the
65     discontinuity (the result will be different depending on
66     which side is chosen). Functions on any side of the
67     discontinuity can be seen as a function on the corresponding other side.
68     A function on the boundary or on one side of
69     the discontinuity cannot be seen as a general function on the domain as there are no values
70     defined for the interior. For most PDE solver libraries
71     the space of the solution and continuous functions is identical, however in some cases, eg.
72     when periodic boundary conditions are used in \finley, a solution
73     fulfils periodic boundary conditions while a continuous function does not have to be periodic.
74    
75     The concept of function spaces describes the properties of
76     functions and allows abstraction from the actual representation
77     of the function in the context of a particular application. For instance,
78     in the FEM context a
79     function in the \Function function space
80     is typically represented by its values at the element center,
81     but in a finite difference scheme the edge midpoint of cells is preferred.
82     Using the concept of function spaces
83     allows the user to run the same script on different
84     PDE solver libraries by just changing the creator of the \Domain object.
85     Changing the function space of a particular function
86     will typically lead to a change of its representation.
87     So, when seen as a general function,
88     a continuous function which is typically represented by its values
89     on the node of the FEM mesh or finite difference grid
90 jgs 107 must be interpolated to the element centers or the cell edges,
91 jgs 102 respectively.
92 jgs 82
93 jgs 102 \Data class objects store functions of the location in a domain.
94     The function is represented through its values on \DataSamplePoints where
95     the \DataSamplePoints are chosen according to the function space
96     of the function.
97     \Data class objects are used to define the coefficients
98     of the PDEs to be solved by a PDE solver library
99     and to store the returned solutions.
100 jgs 82
101 jgs 102 The values of the function have a rank which gives the
102 jgs 107 number of indices, and a \Shape defining the range of each index.
103 jgs 102 The rank in \escript is limited to the range $0$ through $4$ and
104     it is assumed that the rank and \Shape is the same for all \DataSamplePoints.
105     The \Shape of a \Data object is a tuple \var{s} of integers. The length
106     of \var{s} is the rank of the \Data object and \var{s[i]} is the maximum
107     value for the \var{i}-th index.
108     For instance, a stress field has rank $2$ and
109     \Shape $(d,d)$ where $d$ is the spatial dimension.
110     The following statement creates the \Data object
111     \var{mydat} representing a
112     continuous function with values
113     of \Shape $(2,3)$ and rank $2$:
114     \begin{python}
115     mydat=Data(value=1,what=ContinuousFunction(myDomain),shape=(2,3))
116     \end{python}
117     The initial value is the constant $1$ for all \DataSamplePoints and
118     all components.
119 jgs 82
120 jgs 102 \Data objects can also be created from any \numarray
121     array or any object, such as a list of floating point numbers,
122 gross 593 that can be converted into a \numarray.NumArray \Ref{NUMARRAY}.
123 jgs 102 The following two statements
124     create objects which are equivalent to \var{mydat}:
125     \begin{python}
126     mydat1=Data(value=numarray.ones((2,3)),what=ContinuousFunction(myDomain))
127     mydat2=Data(value=[[1,1],[1,1],[1,1]],what=ContinuousFunction(myDomain))
128     \end{python}
129     In the first case the initial value is \var{numarray.ones((2,3))}
130 gross 593 which generates a $2 \times 3$ matrix as a \numarray.NumArray
131 jgs 102 filled with ones. The \Shape of the created \Data object
132     it taken from the \Shape of the array. In the second
133     case, the creator converts the initial value, which is a list of lists,
134 gross 593 and converts it into a \numarray.NumArray before creating the actual
135 jgs 102 \Data object.
136 jgs 82
137 jgs 102 For convenience \escript provides creators for the most common types
138     of \Data objects in the following forms (\var{d} defines the
139     spatial dimension):
140     \begin{itemize}
141     \item \var{Scalar(0,Function(mydomain))} is the same as \var{Data(0,Function(myDomain),(,))},
142     e.g a temperature field.
143     \item \var{Vector(0,Function(mydomain))}is the same as \var{Data(0,Function(myDomain),(d))}, e.g
144     a velocity field.
145     \item \var{Tensor(0,Function(mydomain))} is the same as \var{Data(0,Function(myDomain),(d,d))},
146     eg. a stress field.
147     \item \var{Tensor4(0,Function(mydomain))} is the same as \var{Data(0,Function(myDomain),(d,d,d,d))}
148     eg. a Hook tensor field.
149     \end{itemize}
150 gross 593 Here the initial value is $0$ but any object that can be converted into a \numarray.NumArray and whose \Shape
151 jgs 102 is consistent with \Shape of the \Data object to be created can be used as the initial value.
152 jgs 82
153 jgs 102 \Data objects can be manipulated by applying unitary operations (eg. cos, sin, log)
154 jgs 107 and can be combined by applying binary operations (eg. +, - ,* , /).
155     It is to be emphasized that \escript itself does not handle any spatial dependencies as
156 jgs 102 it does not know how values are interpreted by the processing PDE solver library.
157     However \escript invokes interpolation if this is needed during data manipulations.
158     Typically, this occurs in binary operation when both arguments belong to different
159     function spaces or when data are handed over to a PDE solver library
160     which requires functions to be represented in a particular way.
161 jgs 82
162 jgs 102 The following example shows the usage of {\tt Data} objects: Assume we have a
163     displacement field $u$ and we want to calculate the corresponding stress field
164     $\sigma$ using the linear--elastic isotropic material model
165     \begin{eqnarray}\label{eq: linear elastic stress}
166     \sigma\hackscore {ij}=\lambda u\hackscore {k,k} \delta\hackscore {ij} + \mu ( u\hackscore {i,j} + u\hackscore {j,i})
167     \end{eqnarray}
168     where $\delta\hackscore {ij}$ is the Kronecker symbol and
169     $\lambda$ and $\mu$ are the Lame coefficients. The following function
170     takes the displacement {\tt u} and the Lame coefficients
171     \var{lam} and \var{mu} as arguments and returns the corresponding stress:
172     \begin{python}
173 gross 599 from esys.escript import *
174 jgs 102 def getStress(u,lam,mu):
175     d=u.getDomain().getDim()
176     g=grad(u)
177 gross 599 stress=lam*trace(g)*kronecker(d)+mu*(g+transpose(g))
178 jgs 102 return stress
179     \end{python}
180     The variable
181     \var{d} gives the spatial dimension of the
182     domain on which the displacements are defined.
183 gross 599 \var{kronecker} returns the Kronecker symbol with indexes
184 jgs 102 $i$ and $j$ running from $0$ to \var{d}-1. The call \var{grad(u)} requires
185     the displacement field \var{u} to be in the \var{Solution} or \ContinuousFunction
186     function space. The result \var{g} as well as the returned stress will be in the \Function function space.
187     If \var{u} is available, eg. by solving a PDE, \var{getStress} might be called
188     in the following way:
189     \begin{python}
190     s=getStress(u,1.,2.)
191     \end{python}
192     However \var{getStress} can also be called with \Data objects as values for
193     \var{lam} and \var{mu} which,
194     for instance in the case of a temperature dependency, are calculated by an expression.
195     The following call is equivalent to the previous example:
196     \begin{python}
197     lam=Scalar(1.,ContinuousFunction(mydomain))
198     mu=Scalar(2.,Function(mydomain))
199     s=getStress(u,lam,mu)
200     \end{python}
201     The function \var{lam} belongs to the \ContinuousFunction function space
202     but with \var{g} the function \var{trace(g)} is in the \Function function space.
203     Therefore the evaluation of the product \var{lam*trace(g)} in the stress calculation
204     produces a problem, as both functions are represented differently, eg. in FEM
205     \var{lam} by its values on the node, and in \var{trace(g)} by its values at the element centers.
206     In the case of inconsistent function spaces of arguments in a binary operation, \escript
207     interprets the arguments in the appropriate function space according to the inclusion
208     defined in Table~\ref{ESCRIPT DEP}. In this example that means
209     \escript sees \var{lam} as a function of the \Function function space.
210     In the context of FEM this means the nodal values of
211     \var{lam} are interpolated to the element centers. Behind the scenes
212     \escript calls the appropriate function from the PDE solver library.
213 jgs 82
214 jgs 102 \begin{figure}
215 gross 599 \includegraphics[width=\textwidth]{figures/EscriptDiagram2.eps}
216 jgs 102 \caption{\label{Figure: tag}Element Tagging. A rectangular mesh over a region with two rock types {\it white} and {\it gray}.
217     The number in each cell refers to the major rock type present in the cell ($1$ for {\it white} and $2$ for {\it gray}).
218     }
219     \end{figure}
220 jgs 82
221 jgs 102 Material parameters such as the Lame coefficients are typically dependent on rock types present in the
222     area of interest. A common technique to handle these kinds of material parameters is "tagging". \fig{Figure: tag}
223     shows an example. In this case two rock types {\it white} and {\it gray} can be found in the domain. The domain
224 gross 599 is subdivided into triangular shaped cells. Each
225 jgs 102 cell has a tag indicating the rock type predominately found in this cell. Here $1$ is used to indicate
226     rock type {\it white} and $2$ for rock type {\it gray}. The tags are assigned at the time when the cells are generated
227     and stored in the \Domain class object. The following statements show how for the
228     example of \fig{Figure: tag} and the stress calculation discussed before tagged values are used for
229     \var{lam}:
230     \begin{python}
231     lam=Scalar(value=2.,what=Function(mydomain))
232     lam.setTaggedValue(1,30.)
233     lam.setTaggedValue(2,5000.)
234     s=getStress(u,lam,2.)
235     \end{python}
236     In this example \var{lam} is set to $30$ for those cells with tag $1$ and to $5000.$ for those cells
237     with tag $2$. The initial value $2$ of \var{lam} is used as a default value for the case when a tag
238     is encountered which has not been linked with a value. Note that the \var{getStress} method
239     is called without modification. \escript resolves the tags when \var{lam*trace(g)} is calculated.
240 jgs 82
241 jgs 102 The \Data class provides a transparent interface to various data representations and the
242     translations between them. As shown in the example of stress calculation, this allows the user to
243     develop and test algorithms for a simple case (for instance with the Lame coefficients as constants)
244     and then without further modifications of the program code to apply the algorithm in a
245     more complex application (for instance a definition of the Lame coefficients using tags).
246 gross 599 As described here, there are three ways in which \Data objects are represented internally, constant,
247     tagged, and expanded (other representations will become available in later versions of \escript):
248 jgs 102 In the constant case, if the same value is used at each sample point a single value is stored to save memory and compute time.
249     Any operation on this constant data will only be performed on the single value.
250     In the expanded case, each sample point has an individual value, eg. the solution of a PDE,
251     and the values are stored as a complete array. The tagged case has already been discussed above.
252    
253     Values are accessed through a sample reference number. Operations on expanded \Data
254     objects have to be performed for each sample point individually. If tagged values are used values are
255     held in a dictionary. Operations on tagged data require processing the set of tagged values only, rather than
256     processing the value for each individual sample point.
257     \escript allows use of constant, tagged and expanded data in a single expression.
258 jgs 82
259 gross 983 The \var{dump} method provides a possibility to save \Data objects to a file, for instance to restart a simuation
260 gross 999 or to save data for visualization. The file format uses \netCDF which commonly is using the file extension
261 gross 983 {\tt nc}. For instance to save the coordinates of the data points of the \FunctionSpace
262     \ContinuousFunction to the file {\tt x.nc} one uses:
263     \begin{python}
264     x=ContinuousFunction(mydomain).getX()
265     x.dump("x.nc")
266     \end{python}
267     In order to keep the dump files small {\tt x.nc} does not contain a representation of the \Domain. It has to be saved using
268     apropriated methods of \var{mydomain} to be loaded before \var{x}. Alternatively, the \Domain can be reconstructed.
269     To recover the object \var{x} one uses
270     \begin{python}
271     x=load("x.nc", mydomain)
272     \end{python}
273     The \Data object represented by {\tt x.nc} is tight to a \FunctionSpace - in this case \ContinuousFunction - but not
274     o a \Domain. That means that \Data objects that are constant or tagged can be recovered with any \Domain. If the \Data object
275     is expanded, the number of data points in the file and of the \Domain for the particular \FunctionSpace must match.
276     Moreover, the ordering of the value is checked using the reference identifiers provided by
277     \FunctionSpace on the \Domain. In some cases, data points will be reordered.
278    
279    
280 gross 999 \section{\escript Classes}
281     \declaremodule{extension}{esys.escript}
282     \modulesynopsis{Data manipulation}
283    
284     \subsection{\Domain class}
285 jgs 102 \begin{classdesc}{Domain}{}
286 jgs 107 A \Domain object is used to describe a geometrical region together with
287 jgs 102 a way of representing functions over this region.
288     The \Domain class provides an abstract access to the domain of \FunctionSpace and \Data objects.
289     \Domain itself has no initialization but implementations of \Domain are
290     instantiated by numerical libraries making use of \Data objects.
291 jgs 82 \end{classdesc}
292 gross 593 The following methds are available:
293 jgs 102 \begin{methoddesc}[Domain]{getDim}{}
294     returns the spatial dimension of the \Domain.
295     \end{methoddesc}
296    
297     \begin{methoddesc}[Domain]{getX}{}
298     returns the locations in the \Domain. The \FunctionSpace of the returned
299     \Data object is chosen by the \Domain implementation. Typically it will be
300     in the \Function.
301     \end{methoddesc}
302    
303     \begin{methoddesc}[Domain]{setX}{newX}
304     assigns a new location to the \Domain. \var{newX} has to have \Shape $(d,)$
305     where $d$ is the spatial dimension of the domain. Typically \var{newX} must be
306     in the \ContinuousFunction but the space actually to be used depends on the \Domain implementation.
307     \end{methoddesc}
308    
309     \begin{methoddesc}[Domain]{getNormal}{}
310     returns the surface normals on the boundary of the \Domain as \Data object.
311     \end{methoddesc}
312    
313     \begin{methoddesc}[Domain]{getSize}{}
314     returns the local sample size, e.g. the element diameter, as \Data object.
315     \end{methoddesc}
316    
317     \begin{methoddesc}[Domain]{__eq__}{arg}
318     returns \True of the \Domain \var{arg} describes the same domain. Otherwise
319     \False is returned.
320     \end{methoddesc}
321    
322     \begin{methoddesc}[Domain]{__ne__}{arg}
323     returns \True of the \Domain \var{arg} does not describe the same domain.
324     Otherwise \False is returned.
325     \end{methoddesc}
326    
327 gross 593 \begin{methoddesc}[Domain]{__str__}{g}
328     returns string represention of the \Domain.
329     \end{methoddesc}
330    
331 gross 999 \subsection{\FunctionSpace class}
332 jgs 102 \begin{classdesc}{FunctionSpace}{}
333     \FunctionSpace objects are used to define properties of \Data objects, such as continuity. \FunctionSpace objects
334     are instantiated by generator functions. \Data objects in particular \FunctionSpace are
335     represented by their values at \DataSamplePoints which are defined by the type and the \Domain of the
336     \FunctionSpace.
337 jgs 82 \end{classdesc}
338 gross 593 The following methds are available:
339 jgs 102 \begin{methoddesc}[FunctionSpace]{getDim}{}
340     returns the spatial dimension of the \Domain of the \FunctionSpace.
341     \end{methoddesc}
342 jgs 82
343 jgs 102 \begin{methoddesc}[FunctionSpace]{getX}{}
344     returns the location of the \DataSamplePoints.
345     \end{methoddesc}
346 jgs 82
347 jgs 102 \begin{methoddesc}[FunctionSpace]{getNormal}{}
348     If the domain of functions in the \FunctionSpace
349     is a hypermanifold (e.g. the boundary of a domain)
350     the method returns the outer normal at each of the
351     \DataSamplePoints. Otherwise an exception is raised.
352     \end{methoddesc}
353 jgs 82
354 jgs 102 \begin{methoddesc}[FunctionSpace]{getSize}{}
355     returns a \Data objects measuring the spacing of the \DataSamplePoints.
356     The size may be zero.
357     \end{methoddesc}
358 jgs 82
359 jgs 102 \begin{methoddesc}[FunctionSpace]{getDomain}{}
360     returns the \Domain of the \FunctionSpace.
361     \end{methoddesc}
362 jgs 82
363 jgs 102 \begin{methoddesc}[FunctionSpace]{__eq__}{arg}
364     returns \True of the \Domain \var{arg} describes the same domain. Otherwise
365     \False is returned.
366     \end{methoddesc}
367 jgs 82
368 jgs 102 \begin{methoddesc}[FunctionSpace]{__ne__}{arg}
369     returns \True of the \Domain \var{arg} describes the note same domain.
370     Otherwise \False is returned.
371     \end{methoddesc}
372 jgs 82
373 gross 593 \begin{methoddesc}[Domain]{__str__}{g}
374     returns string represention of the \Domain.
375     \end{methoddesc}
376    
377 jgs 102 The following function provide generators for \FunctionSpace objects:
378     \begin{funcdesc}{Function}{domain}
379     returns the \Function on the \Domain \var{domain}. \Data objects in this type of \Function
380     are defined over the whole geometrical region defined by \var{domain}.
381 jgs 82 \end{funcdesc}
382    
383 jgs 102 \begin{funcdesc}{ContinuousFunction}{domain}
384     returns the \ContinuousFunction on the \Domain domain. \Data objects in this type of \Function
385     are defined over the whole geometrical region defined by \var{domain} and assumed to represent
386     a continuous function.
387 jgs 82 \end{funcdesc}
388    
389 jgs 102 \begin{funcdesc}{FunctionOnBoundary}{domain}
390     returns the \ContinuousFunction on the \Domain domain. \Data objects in this type of \Function
391     are defined on the boundary of the geometrical region defined by \var{domain}.
392 jgs 82 \end{funcdesc}
393    
394 jgs 102 \begin{funcdesc}{FunctionOnContactZero}{domain}
395     returns the \FunctionOnContactZero the \Domain domain. \Data objects in this type of \Function
396     are defined on side 0 of a discontinutiy within the geometrical region defined by \var{domain}.
397     The discontinutiy is defined when \var{domain} is instantiated.
398 jgs 82 \end{funcdesc}
399    
400 jgs 102 \begin{funcdesc}{FunctionOnContactOne}{domain}
401     returns the \FunctionOnContactOne on the \Domain domain.
402     \Data objects in this type of \Function
403     are defined on side 1 of a discontinutiy within the geometrical region defined by \var{domain}.
404     The discontinutiy is defined when \var{domain} is instantiated.
405 jgs 82 \end{funcdesc}
406    
407 jgs 102 \begin{funcdesc}{Solution}{domain}
408     returns the \SolutionFS on the \Domain domain. \Data objects in this type of \Function
409     are defined on geometrical region defined by \var{domain} and are solutions of
410     partial differential equations \index{partial differential equation}.
411 jgs 82 \end{funcdesc}
412    
413 jgs 102 \begin{funcdesc}{ReducedSolution}{domain}
414     returns the \ReducedSolutionFS on the \Domain domain. \Data objects in this type of \Function
415     are defined on geometrical region defined by \var{domain} and are solutions of
416     partial differential equations \index{partial differential equation} with a reduced smoothness
417     for the solution approximation.
418 jgs 82 \end{funcdesc}
419    
420 gross 999 \subsection{\Data Class}
421 jgs 107 \label{SEC ESCRIPT DATA}
422 jgs 82
423 jgs 102 The following table shows binary and unitary operations that can be applied to
424     \Data objects:
425     \begin{tableii}{l|l}{textrm}{expression}{Description}
426 gross 625 \lineii{+\var{arg0}} {just \var{arg} \index{+}}
427     \lineii{-\var{arg0}} {swapping the sign\index{-}}
428     \lineii{\var{arg0}+\var{arg1}} {adds \var{arg0} and \var{arg1} \index{+}}
429     \lineii{\var{arg0}*\var{arg1}} {multiplies \var{arg0} and \var{arg1} \index{*}}
430     \lineii{\var{arg0}-\var{arg1}} {difference \var{arg1} from\var{arg1} \index{-}}
431     \lineii{\var{arg0}/\var{arg1}} {ratio \var{arg0} by \var{arg1} \index{/}}
432     \lineii{\var{arg0}**\var{arg1}} {raises \var{arg0} to the power of \var{arg1} \index{**}}
433 jgs 102 \end{tableii}
434 gross 625 At least one of the arguments \var{arg0} or \var{arg1} must be a
435 jgs 102 \Data object. One of the arguments may be an object that can be
436 gross 625 converted into a \Data object. If \var{arg0} or \var{arg1} are
437     defined on different \FunctionSpace an attempt is made to embed \var{arg0}
438     into the \FunctionSpace of \var{arg1} or to embed \var{arg1} into
439     the \FunctionSpace of \var{arg0}. Boths arguments must have the same
440     \Shape or one of the arguments my be of rank 0. In the
441 jgs 102 latter case it is assumed that the particular argument is of the same
442 jgs 107 \Shape as the other argument but constant over all components.
443 jgs 82
444 jgs 102 The returned \Data object has the same \Shape and is defined on
445 gross 625 the \DataSamplePoints as \var{arg0} or \var{arg1}.
446 jgs 82
447 jgs 102 The following table shows the update operations that can be applied to
448     \Data objects:
449     \begin{tableii}{l|l}{textrm}{expression}{Description}
450 gross 625 \lineii{\var{arg0}+=\var{arg2}} {adds \var{arg0} to \var{arg2} \index{+}}
451     \lineii{\var{arg0}*=\var{arg2}} {multiplies \var{arg0} with \var{arg2} \index{*}}
452     \lineii{\var{arg0}-=\var{arg2}} {subtracts \var{arg2} from\var{arg2} \index{-}}
453     \lineii{\var{arg0}/=\var{arg2}} {divides \var{arg0} by \var{arg2} \index{/}}
454     \lineii{\var{arg0}**=\var{arg2}} {raises \var{arg0} by \var{arg2} \index{**}}
455 jgs 102 \end{tableii}
456 gross 625 \var{arg0} must be a \Data object. \var{arg1} must be a
457 jgs 102 \Data object or an object that can be converted into a
458     \Data object. \var{arg1} must have the same \Shape like
459 gross 625 \var{arg1} or has rank 0. In the latter case it is
460 jgs 102 assumed that the values of \var{arg1} are constant for all
461 gross 625 components. \var{arg1} must be defined in the same \FunctionSpace as
462     \var{arg0} or it must be possible to interpolate \var{arg1} onto the
463     \FunctionSpace of \var{arg1}.
464 jgs 82
465 jgs 102 The \Data class supports getting slices as well as assigning new values to components in an existing
466 jgs 107 \Data object. \index{slicing}
467 jgs 102 The following expression for getting (expression on the right hand side of the
468     equal sign) and setting slices (expression on the left hand side of the
469     equal sign) are valid:
470     \begin{tableiii}{l|ll}{textrm}{rank of \var{arg}}{slicing expression}{\Shape of returned and assigned object}
471     \lineiii{0}{ no slicing } {-}
472     \lineiii{1}{\var{arg[l0:u0]}} {(\var{u0}-\var{l0},)}
473     \lineiii{2}{\var{arg[l0:u0,l1:u1]}} {(\var{u0}-\var{l0},\var{u1}-\var{l1})}
474     \lineiii{3}{\var{arg[l0:u0,l1:u1,l2:u2]} } {(\var{u0}-\var{l0},\var{u1}-\var{l1},\var{u2}-\var{l2})}
475     \lineiii{4}{\var{arg[l0:u0,l1:u1,l2:u2,l3:u3]}} {(\var{u0}-\var{l0},\var{u1}-\var{l1},\var{u2}-\var{l2},\var{u3}-\var{l3})}
476     \end{tableiii}
477     where
478     $0 \le \var{l0} \le \var{u0} \le \var{s[0]}$,
479     $0 \le \var{l1} \le \var{u1} \le \var{s[1]}$,
480     $0 \le \var{l2} \le \var{u2} \le \var{s[2]}$,
481     $0 \le \var{l3} \le \var{u3} \le \var{s[3]}$ and \var{s} the \Shape if \var{arg}.
482     Any of the lower indexes \var{l0}, \var{l1}, \var{l2} and \var{l3} may not be present in which case
483     $0$ is assumed.
484     Any of the upper indexes \var{u0}, \var{u1}, \var{u2} and \var{u3} may not be present in which case
485     \var{s} is assumed. The lower and upper index may be identical, in which case the column and the lower or upper
486     index may be dropped. In the returned or in the object assigned to a slice the corresponding component is dropped,
487     i.e. the rank is reduced by one in comparison to \var{arg}.
488 jgs 107 The following examples show slicing usage:
489 jgs 102 \begin{python}
490 gross 593 t=Data(1.,(4,4,6,6),Function(mydomain))
491 jgs 102 t[1,1,1,0]=9.
492     s=t[:2,:,2:6,5] # s has rank 3
493     s[:,:,1]=1.
494     t[:2,:2,5,5]=s[2:4,1,:2]
495     \end{python}
496    
497 gross 593 \subsection{Generation of \Data class objects}
498     \begin{classdesc}{Data}{value=0,shape=(,),what=FunctionSpace(),expand=\False}
499 jgs 102 creates a \Data object with \Shape \var{shape} in the \FunctionSpace \var{what}.
500     The values at all \DataSamplePoints are set to the double value \var{value}. If \var{expanded} is \True
501     the \Data object is represented in expanded from.
502 jgs 82 \end{classdesc}
503    
504 gross 593 \begin{classdesc}{Data}{value,what=FunctionSpace(),expand=\False}
505 jgs 102 creates a \Data object in the \FunctionSpace \var{what}.
506 gross 593 The value for each \DataSamplePoints is set to \numarray, \Data object \var{value} or a dictionary of
507     \numarray or floating point numbers. In the latter case the keys muts be integers and are used
508     as tags.
509 jgs 102 The \Shape of the returned object is equal to the \Shape of \var{value}. If \var{expanded} is \True
510     the \Data object is represented in expanded from.
511     \end{classdesc}
512    
513     \begin{classdesc}{Data}{}
514     creates an \EmptyData object. The \EmptyData object is used to indicate that an argument is not present
515     where a \Data object is required.
516     \end{classdesc}
517    
518 gross 593 \begin{funcdesc}{Scalar}{value=0.,what=escript::FunctionSpace(),expand=\False}
519     returns a \Data object of rank 0 in the \FunctionSpace \var{what}.
520     Values are initialed with the double \var{value}. If \var{expanded} is \True
521     the \Data object is represented in expanded from.
522     \end{funcdesc}
523    
524     \begin{funcdesc}{Vector}{value=0.,what=escript::FunctionSpace(),expand=\False}
525     returns a \Data object of \Shape \var{(d,)} in the \FunctionSpace \var{what}
526     where \var{d} is the spatial dimension of the \Domain of \var{what}.
527     Values are initialed with the double \var{value}. If \var{expanded} is \True
528     the \Data object is represented in expanded from.
529     \end{funcdesc}
530    
531     \begin{funcdesc}{Tensor}{value=0.,what=escript::FunctionSpace(),expand=\False}
532     returns a \Data object of \Shape \var{(d,d)} in the \FunctionSpace \var{what}
533     where \var{d} is the spatial dimension of the \Domain of \var{what}.
534     Values are initialed with the double \var{value}. If \var{expanded} is \True
535     the \Data object is represented in expanded from.
536     \end{funcdesc}
537    
538     \begin{funcdesc}{Tensor3}{value=0.,what=escript::FunctionSpace(),expand=\False}
539     returns a \Data object of \Shape \var{(d,d,d)} in the \FunctionSpace \var{what}
540     where \var{d} is the spatial dimension of the \Domain of \var{what}.
541     Values are initialed with the double \var{value}. If \var{expanded} is \True
542     the \Data object is re\var{arg}presented in expanded from.
543     \end{funcdesc}
544    
545     \begin{funcdesc}{Tensor4}{value=0.,what=escript::FunctionSpace(),expand=\False}
546     returns a \Data object of \Shape \var{(d,d,d,d)} in the \FunctionSpace \var{what}
547     where \var{d} is the spatial dimension of the \Domain of \var{what}.
548     Values are initialed with the double \var{value}. If \var{expanded} is \True
549     the \Data object is represented in expanded from.
550     \end{funcdesc}
551    
552 gross 983 \begin{funcdesc}{load}{filename,domain}
553     recovers a \Data object on \Domain \var{domain} from the dump file \var{filename}.
554     \end{funcdesc}
555    
556 gross 593 \subsection{\Data class methods}
557     This is a list of frequently used methods of the
558     \Data class. A complete list can be fond on \ReferenceGuide.
559 jgs 102 \begin{methoddesc}[Data]{getFunctionSpace}{}
560     returns the \FunctionSpace of the object.
561 jgs 82 \end{methoddesc}
562    
563 gross 593 \begin{methoddesc}[Data]{getDomain}{}
564 jgs 102 returns the \Domain of the object.
565     \end{methoddesc}
566    
567 jgs 82 \begin{methoddesc}[Data]{getShape}{}
568 jgs 102 returns the \Shape of the object as a \class{tuple} of
569     integers.
570 jgs 82 \end{methoddesc}
571    
572     \begin{methoddesc}[Data]{getRank}{}
573     returns the rank of the data on each data point. \index{rank}
574     \end{methoddesc}
575    
576 jgs 102 \begin{methoddesc}[Data]{isEmpty}{}
577     returns \True id the \Data object is the \EmptyData object.
578     Otherwise \False is returned.
579 jgs 82 \end{methoddesc}
580    
581 jgs 102 \begin{methoddesc}[Data]{setTaggedValue}{tag,value}
582     assigns the \var{value} to all \DataSamplePoints which have the tag
583     \var{tag}. \var{value} must be an object of class
584 gross 593 \class{numarray.NumArray} or must be convertible into a
585     \class{numarray.NumArray} object. \var{value} (or the corresponding
586     \class{numarray.NumArray} object) must be of rank $0$ or must have the
587 jgs 102 same rank like the object.
588     If a value has already be defined for tag \var{tag} within the object
589     it is overwritten by the new \var{value}. If the object is expanded,
590     the value assigned to \DataSamplePoints with tag \var{tag} is replaced by
591     \var{value}.
592 jgs 82 \end{methoddesc}
593    
594 gross 983 \begin{methoddesc}[Data]{dump}{filename}
595     dumps the \Data object to the file \var{filename}. The file stores the
596     function space but not the \Domain. It is in the responsibilty of the user to
597     save the \Domain.
598     \end{methoddesc}
599    
600 gross 593 \begin{methoddesc}[Data]{__str__}{}
601     returns a string representation of the object.
602     \end{methoddesc}
603    
604 gross 999 \subsection{Functions of \Data class objects}
605 gross 593 This section lists the most important functions for \Data class objects \var{a}.
606     A complete list and a more detailed description of the functionality can be fond on \ReferenceGuide.
607 gross 599 \begin{funcdesc}{saveVTK}{filename,**kwdata}
608     writes \Data defined by keywords in the file with \var{filename} using the
609     vtk file format \VTK file format. The key word is used as an identifier. The statement
610     \begin{python}
611     saveVTK("out.xml",temperature=T,velocity=v)
612     \end{python}
613     will write the scalar \var{T} as \var{temperature} and the vector \var{v} as \var{velocity} into the
614     file \file{out.xml}. Restrictions on the allowed combinations of \FunctionSpace apply.
615 gross 593 \end{funcdesc}
616 gross 599 \begin{funcdesc}{saveDX}{filename,**kwdata}
617     writes \Data defined by keywords in the file with \var{filename} using the
618     vtk file format \OpenDX file format. The key word is used as an identifier. The statement
619     \begin{python}
620     saveDX("out.dx",temperature=T,velocity=v)
621     \end{python}
622     will write the scalar \var{T} as \var{temperature} and the vector \var{v} as \var{velocity} into the
623     file \file{out.dx}. Restrictions on the allowed combinations of \FunctionSpace apply.
624 gross 593 \end{funcdesc}
625     \begin{funcdesc}{kronecker}{d}
626 gross 599 returns a \RankTwo \Data object in \FunctionSpace \var{d} such that
627 gross 593 \begin{equation}
628 gross 599 \code{kronecker(d)}\left[ i,j\right] = \left\{
629 gross 593 \begin{array}{cc}
630     1 & \mbox{ if } i=j \\
631     0 & \mbox{ otherwise }
632     \end{array}
633     \right.
634     \end{equation}
635 gross 599 If \var{d} is an integer a $(d,d)$ \numarray array is returned.
636 gross 593 \end{funcdesc}
637     \begin{funcdesc}{identityTensor}{d}
638 gross 599 returns a \RankTwo \Data object in \FunctionSpace \var{d} such that
639     \begin{equation}
640     \code{identityTensor(d)}\left[ i,j\right] = \left\{
641     \begin{array}{cc}
642     1 & \mbox{ if } i=j \\
643     0 & \mbox{ otherwise }
644     \end{array}
645     \right.
646     \end{equation}
647     If \var{d} is an integer a $(d,d)$ \numarray array is returned.
648 gross 593 \end{funcdesc}
649     \begin{funcdesc}{identityTensor4}{d}
650 gross 599 returns a \RankFour \Data object in \FunctionSpace \var{d} such that
651     \begin{equation}
652     \code{identityTensor(d)}\left[ i,j,k,l\right] = \left\{
653     \begin{array}{cc}
654     1 & \mbox{ if } i=k \mbox{ and } j=l\\
655     0 & \mbox{ otherwise }
656     \end{array}
657     \right.
658     \end{equation}
659     If \var{d} is an integer a $(d,d,d,d)$ \numarray array is returned.
660 gross 593 \end{funcdesc}
661     \begin{funcdesc}{unitVector}{i,d}
662 gross 599 returns a \RankOne \Data object in \FunctionSpace \var{d} such that
663     \begin{equation}
664     \code{identityTensor(d)}\left[ j \right] = \left\{
665     \begin{array}{cc}
666     1 & \mbox{ if } j=i\\
667     0 & \mbox{ otherwise }
668     \end{array}
669     \right.
670     \end{equation}
671     If \var{d} is an integer a $(d,)$ \numarray array is returned.
672    
673 gross 593 \end{funcdesc}
674    
675     \begin{funcdesc}{Lsup}{a}
676     returns the $L^{sup}$ norm of \var{arg}. This is the maximum of the absolute values
677     over all components and all \DataSamplePoints of \var{a}.
678     \end{funcdesc}
679    
680     \begin{funcdesc}{sup}{a}
681     returns the maximum value over all components and all \DataSamplePoints of \var{a}.
682     \end{funcdesc}
683    
684     \begin{funcdesc}{inf}{a}
685     returns the minimum value over all components and all \DataSamplePoints of \var{a}
686     \end{funcdesc}
687    
688     \begin{funcdesc}{sin}{a}
689     applies sine function to \var{a}.
690     \end{funcdesc}
691    
692     \begin{funcdesc}{cos}{a}
693     applies cosine function to \var{a}.
694     \end{funcdesc}
695    
696     \begin{funcdesc}{tan}{a}
697     applies tangent function to \var{a}.
698     \end{funcdesc}
699    
700     \begin{funcdesc}{asin}{a}
701     applies arc (inverse) sine function to \var{a}.
702     \end{funcdesc}
703    
704     \begin{funcdesc}{acos}{a}
705     applies arc (inverse) cosine function to \var{a}.
706     \end{funcdesc}
707    
708     \begin{funcdesc}{atan}{a}
709     applies arc (inverse) tangent function to \var{a}.
710     \end{funcdesc}
711    
712     \begin{funcdesc}{sinh}{a}
713     applies hyperbolic sine function to \var{a}.
714     \end{funcdesc}
715    
716     \begin{funcdesc}{cosh}{a}
717     applies hyperbolic cosine function to \var{a}.
718     \end{funcdesc}
719    
720     \begin{funcdesc}{tanh}{a}
721     applies hyperbolic tangent function to \var{a}.
722     \end{funcdesc}
723    
724     \begin{funcdesc}{asinh}{a}
725     applies arc (inverse) hyperbolic sine function to \var{a}.
726     \end{funcdesc}
727    
728     \begin{funcdesc}{acosh}{a}
729     applies arc (inverse) hyperbolic cosine function to \var{a}.
730     \end{funcdesc}
731    
732     \begin{funcdesc}{atanh}{a}
733     applies arc (inverse) hyperbolic tangent function to \var{a}.
734     \end{funcdesc}
735    
736     \begin{funcdesc}{exp}{a}
737     applies exponential function to \var{a}.
738     \end{funcdesc}
739    
740     \begin{funcdesc}{sqrt}{a}
741     applies square root function to \var{a}.
742     \end{funcdesc}
743    
744     \begin{funcdesc}{log}{a}
745 gross 599 applies the natural logarithm to \var{a}.
746 gross 593 \end{funcdesc}
747    
748     \begin{funcdesc}{log10}{a}
749 gross 599 applies the base-$10$ logarithm to \var{a}.
750 gross 593 \end{funcdesc}
751    
752     \begin{funcdesc}{sign}{a}
753 gross 599 applies the sign function to \var{a}, that is $1$ where \var{a} is positive,
754     $-1$ where \var{a} is negative and $0$ otherwise.
755 gross 593 \end{funcdesc}
756    
757     \begin{funcdesc}{wherePositive}{a}
758 gross 599 returns a function which is $1$ where \var{a} is positive and $0$ otherwise.
759 gross 593 \end{funcdesc}
760 gross 599
761 gross 593 \begin{funcdesc}{whereNegative}{a}
762 gross 599 returns a function which is $1$ where \var{a} is negative and $0$ otherwise.
763 gross 593 \end{funcdesc}
764 gross 599
765 gross 593 \begin{funcdesc}{whereNonNegative}{a}
766 gross 599 returns a function which is $1$ where \var{a} is non--negative and $0$ otherwise.
767 gross 593 \end{funcdesc}
768 gross 599
769 gross 593 \begin{funcdesc}{whereNonPositive}{a}
770 gross 599 returns a function which is $1$ where \var{a} is non--positive and $0$ otherwise.
771 gross 593 \end{funcdesc}
772 gross 599
773     \begin{funcdesc}{whereZero}{a\optional{, tol=0.}}
774     returns a function which is $1$ where \var{a} equals zero with tolerance \var{tol} and $0$ otherwise.
775 gross 593 \end{funcdesc}
776 gross 599
777     \begin{funcdesc}{whereNonZero}{a\optional{, tol=0.}}
778     returns a function which is $1$ where \var{a} different from zero with tolerance \var{tol} and $0$ otherwise.
779 gross 593 \end{funcdesc}
780 gross 599
781 gross 593 \begin{funcdesc}{minval}{a}
782 gross 599 returns at each \DataSamplePoints the minumum value over all components.
783 gross 593 \end{funcdesc}
784 gross 599
785 gross 593 \begin{funcdesc}{maxval}{a}
786 gross 599 returns at each \DataSamplePoints the maximum value over all components.
787 gross 593 \end{funcdesc}
788 gross 599
789 gross 593 \begin{funcdesc}{length}{a}
790 gross 599 returns at Euclidean norm at each \DataSamplePoints. For a \RankFour function \var{a} this is
791     \begin{equation}
792     \code{length(a)}=\sqrt{\sum\hackscore{ijkl} \var{a} \left[i,j,k,l\right]^2}
793     \end{equation}
794 gross 593 \end{funcdesc}
795 gross 599 \begin{funcdesc}{trace}{a\optional{,axis_offset=0}}
796     returns the trace of \var{a}. This is the sum over components \var{axis_offset} and \var{axis_offset+1} with the same index. For instance in the
797     case of a \RankTwo function and this is
798     \begin{equation}
799     \code{trace(a)}=\sum\hackscore{i} \var{a} \left[i,i\right]
800     \end{equation}
801     and for a \RankFour function and \code{axis_offset=1} this is
802     \begin{equation}
803     \code{trace(a,1)}\left[i,j\right]=\sum\hackscore{k} \var{a} \left[i,k,k,j\right]
804     \end{equation}
805 gross 593 \end{funcdesc}
806 gross 804
807 gross 599 \begin{funcdesc}{transpose}{a\optional{, axis_offset=None}}
808     returns the transpose of \var{a}. This swaps the first \var{axis_offset} components of \var{a} with the rest. If \var{axis_offset} is not
809     present \code{int(r/2)} is used where \var{r} is the rank of \var{a}.
810     the sum over components \var{axis_offset} and \var{axis_offset+1} with the same index. For instance in the
811     case of a \RankTwo function and this is
812     \begin{equation}
813     \code{transpose(a)}\left[i,j\right]=\var{a} \left[j,i\right]
814     \end{equation}
815     and for a \RankFour function and \code{axis_offset=1} this is
816     \begin{equation}
817     \code{transpose(a,1)}\left[i,j,k,l\right]=\var{a} \left[j,k,l,i\right]
818     \end{equation}
819 gross 593 \end{funcdesc}
820 gross 804
821     \begin{funcdesc}{swap_axes}{a\optional{, axis0=0 \optional{, axis1=1 }}}
822     returns \var{a} but with swapped componets \var{axis0} and \var{axis1}. The argument \var{a} must be
823     at least of \RankTwo. For instance in the
824     for a \RankFour argument, \code{axis0=1} and \code{axis1=2} this is
825     \begin{equation}
826     \code{swap_axes(a,1,2)}\left[i,j,k,l\right]=\var{a} \left[i,k,j,l\right]
827     \end{equation}
828     \end{funcdesc}
829    
830 gross 593 \begin{funcdesc}{symmetric}{a}
831 gross 599 returns the symmetric part of \var{a}. This is \code{(a+transpose(a))/2}.
832 gross 593 \end{funcdesc}
833     \begin{funcdesc}{nonsymmetric}{a}
834 gross 599 returns the non--symmetric part of \var{a}. This is \code{(a-transpose(a))/2}.
835 gross 593 \end{funcdesc}
836     \begin{funcdesc}{inverse}{a}
837 gross 599 return the inverse of \var{a}. This is
838     \begin{equation}
839 gross 809 \code{matrix_mult(inverse(a),a)=kronecker(d)}
840 gross 599 \end{equation}
841     if \var{a} has shape \code{(d,d)}. The current implementation is restricted to arguments of shape
842     \code{(2,2)} and \code{(3,3)}.
843 gross 593 \end{funcdesc}
844     \begin{funcdesc}{eigenvalues}{a}
845 gross 599 return the eigenvalues of \var{a}. This is
846     \begin{equation}
847 gross 809 \code{matrix_mult(a,V)=e[i]*V}
848 gross 599 \end{equation}
849     where \code{e=eigenvalues(a)} and \var{V} is suitable non--zero vector \var{V}.
850     The eigenvalues are ordered in increasing size.
851     The argument \var{a} has to be the symmetric, ie. \code{a=symmetric(a)}.
852     The current implementation is restricted to arguments of shape
853     \code{(2,2)} and \code{(3,3)}.
854 gross 593 \end{funcdesc}
855     \begin{funcdesc}{eigenvalues_and_eigenvectors}{a}
856 gross 599 return the eigenvalues and eigenvectors of \var{a}. This is
857     \begin{equation}
858 gross 809 \code{matrix_mult(a,V[:,i])=e[i]*V[:,i]}
859 gross 599 \end{equation}
860     where \code{e,V=eigenvalues_and_eigenvectors(a)}. The eigenvectors \var{V} are orthogonal and normalized, ie.
861     \begin{equation}
862 gross 809 \code{matrix_mult(transpose(V),V)=kronecker(d)}
863 gross 599 \end{equation}
864     if \var{a} has shape \code{(d,d)}. The eigenvalues are ordered in increasing size.
865     The argument \var{a} has to be the symmetric, ie. \code{a=symmetric(a)}.
866     The current implementation is restricted to arguments of shape
867     \code{(2,2)} and \code{(3,3)}.
868 gross 593 \end{funcdesc}
869 gross 599 \begin{funcdesc}{maximum}{*a}
870     returns the maximum value over all arguments at all \DataSamplePoints and for each component.
871     For instance
872     \begin{equation}
873     \code{maximum(a0,a1)}\left[i,j\right]=max(\var{a0} \left[i,j\right],\var{a1} \left[i,j\right])
874     \end{equation}
875     at all \DataSamplePoints.
876 gross 593 \end{funcdesc}
877 gross 599 \begin{funcdesc}{minimum}{*a}
878     returns the minimum value over all arguments at all \DataSamplePoints and for each component.
879     For instance
880     \begin{equation}
881     \code{minimum(a0,a1)}\left[i,j\right]=min(\var{a0} \left[i,j\right],\var{a1} \left[i,j\right])
882     \end{equation}
883     at all \DataSamplePoints.
884 gross 593 \end{funcdesc}
885 gross 599
886     \begin{funcdesc}{clip}{a\optional{, minval=0.}\optional{, maxval=1.}}
887     cuts back \var{a} into the range between \var{minval} and \var{maxval}. A value in the returned object equals
888     \var{minval} if the corresponding value of \var{a} is less than \var{minval}, equals \var{maxval} if the
889     corresponding value of \var{a} is greater than \var{maxval}
890     or corresponding value of \var{a} otherwise.
891 gross 593 \end{funcdesc}
892     \begin{funcdesc}{inner}{a0,a1}
893 gross 599 returns the inner product of \var{a0} and \var{a1}. For instance in the
894     case of \RankTwo arguments and this is
895     \begin{equation}
896     \code{inner(a)}=\sum\hackscore{ij}\var{a0} \left[j,i\right] \cdot \var{a1} \left[j,i\right]
897     \end{equation}
898     and for a \RankFour arguments this is
899     \begin{equation}
900     \code{inner(a)}=\sum\hackscore{ijkl}\var{a0} \left[i,j,k,l\right] \cdot \var{a1} \left[j,i,k,l\right]
901     \end{equation}
902 gross 593 \end{funcdesc}
903 gross 809
904     \begin{funcdesc}{matrix_mult}{a0,a1}
905 gross 599 returns the matrix product of \var{a0} and \var{a1}. If \var{a1} is \RankOne this is
906     \begin{equation}
907 gross 809 \code{matrix_mult(a)}\left[i\right]=\sum\hackscore{k}\var{a0} \cdot \left[i,k\right]\var{a1} \left[k\right]
908 gross 599 \end{equation}
909     and if \var{a1} is \RankTwo this is
910     \begin{equation}
911 gross 809 \code{matrix_mult(a)}\left[i,j\right]=\sum\hackscore{k}\var{a0} \cdot \left[i,k\right]\var{a1} \left[k,j\right]
912 gross 599 \end{equation}
913 gross 593 \end{funcdesc}
914 gross 809
915     \begin{funcdesc}{transposed_matrix_mult}{a0,a1}
916     returns the matrix product of the transposed of \var{a0} and \var{a1}. The function is equivalent to
917     \code{matrix_mult(transpose(a0),a1)}.
918     If \var{a1} is \RankOne this is
919     \begin{equation}
920     \code{transposed_matrix_mult(a)}\left[i\right]=\sum\hackscore{k}\var{a0} \cdot \left[k,i\right]\var{a1} \left[k\right]
921     \end{equation}
922     and if \var{a1} is \RankTwo this is
923     \begin{equation}
924     \code{transposed_matrix_mult(a)}\left[i,j\right]=\sum\hackscore{k}\var{a0} \cdot \left[k,i\right]\var{a1} \left[k,j\right]
925     \end{equation}
926     \end{funcdesc}
927    
928     \begin{funcdesc}{matrix_transposed_mult}{a0,a1}
929     returns the matrix product of \var{a0} and the transposed of \var{a1}.
930     The function is equivalent to
931     \code{matrix_mult(a0,transpose(a1))}.
932     If \var{a1} is \RankTwo this is
933     \begin{equation}
934     \code{matrix_transposed_mult(a)}\left[i,j\right]=\sum\hackscore{k}\var{a0} \cdot \left[i,k\right]\var{a1} \left[j,k\right]
935     \end{equation}
936     \end{funcdesc}
937    
938 gross 593 \begin{funcdesc}{outer}{a0,a1}
939 gross 599 returns the outer product of \var{a0} and \var{a1}. For instance if \var{a0} and \var{a1} both are \RankOne then
940     \begin{equation}
941     \code{outer(a)}\left[i,j\right]=\var{a0} \left[i\right] \cdot \var{a1}\left[j\right]
942     \end{equation}
943     and if \var{a0} is \RankOne and \var{a1} is \RankThree
944     \begin{equation}
945     \code{outer(a)}\left[i,j,k\right]=\var{a0} \left[i\right] \cdot \var{a1}\left[j,k\right]
946     \end{equation}
947 gross 593 \end{funcdesc}
948 gross 809
949     \begin{funcdesc}{tensor_mult}{a0,a1}
950 gross 599 returns the tensor product of \var{a0} and \var{a1}. If \var{a1} is \RankTwo this is
951     \begin{equation}
952 gross 809 \code{tensor_mult(a)}\left[i,j\right]=\sum\hackscore{kl}\var{a0}\left[i,j,k,l\right] \cdot \var{a1} \left[k,l\right]
953 gross 599 \end{equation}
954     and if \var{a1} is \RankFour this is
955     \begin{equation}
956 gross 809 \code{tensor_mult(a)}\left[i,j,k,l\right]=\sum\hackscore{mn}\var{a0} \left[i,j,m,n\right] \cdot \var{a1} \left[m,n,k,l\right]
957 gross 599 \end{equation}
958 gross 593 \end{funcdesc}
959 gross 809
960     \begin{funcdesc}{transposed_tensor_mult}{a0,a1}
961     returns the tensor product of the transposed of \var{a0} and \var{a1}. The function is equivalent to
962     \code{tensor_mult(transpose(a0),a1)}.
963     If \var{a1} is \RankTwo this is
964     \begin{equation}
965     \code{transposed_tensor_mult(a)}\left[i,j\right]=\sum\hackscore{kl}\var{a0}\left[k,l,i,j\right] \cdot \var{a1} \left[k,l\right]
966     \end{equation}
967     and if \var{a1} is \RankFour this is
968     \begin{equation}
969     \code{transposed_tensor_mult(a)}\left[i,j,k,l\right]=\sum\hackscore{mn}\var{a0} \left[m,n,i,j\right] \cdot \var{a1} \left[m,n,k,l\right]
970     \end{equation}
971     \end{funcdesc}
972    
973     \begin{funcdesc}{tensor_transposed_mult}{a0,a1}
974     returns the tensor product of \var{a0} and the transposed of \var{a1}.
975     The function is equivalent to
976     \code{tensor_mult(a0,transpose(a1))}.
977     If \var{a1} is \RankTwo this is
978     \begin{equation}
979     \code{tensor_transposed_mult(a)}\left[i,j\right]=\sum\hackscore{kl}\var{a0}\left[i,j,k,l\right] \cdot \var{a1} \left[l,k\right]
980     \end{equation}
981     and if \var{a1} is \RankFour this is
982     \begin{equation}
983     \code{tensor_transposed_mult(a)}\left[i,j,k,l\right]=\sum\hackscore{mn}\var{a0} \left[i,j,m,n\right] \cdot \var{a1} \left[k,l,m,n\right]
984     \end{equation}
985     \end{funcdesc}
986    
987 gross 599 \begin{funcdesc}{grad}{a\optional{, where=None}}
988     returns the gradient of \var{a}. If \var{where} is present the gradient will be calculated in \FunctionSpace \var{where} otherwise a
989     default \FunctionSpace is used. In case that \var{a} has \RankTwo one has
990     \begin{equation}
991     \code{grad(a)}\left[i,j,k\right]=\frac{\partial \var{a} \left[i,j\right]}{\partial x\hackscore{k}}
992     \end{equation}
993 gross 593 \end{funcdesc}
994 gross 599 \begin{funcdesc}{integrate}{a\optional{ ,where=None}}
995     returns the integral of \var{a} where the domain of integration is defined by the \FunctionSpace of \var{a}. If \var{where} is
996     present the argument is interpolated into \FunctionSpace \var{where} before integration. For instance in the case of
997     a \RankTwo argument in \ContinuousFunction it is
998     \begin{equation}
999     \code{integrate(a)}\left[i,j\right]=\int\hackscore{\Omega}\var{a} \left[i,j\right] \; d\Omega
1000     \end{equation}
1001     where $\Omega$ is the spatial domain and $d\Omega$ volume integration. To integrate over the boundary of the domain one uses
1002     \begin{equation}
1003     \code{integrate(a,where=FunctionOnBoundary(a.getDomain))}\left[i,j\right]=\int\hackscore{\partial \Omega} a\left[i,j\right] \; ds
1004     \end{equation}
1005     where $\partial \Omega$ is the surface of the spatial domain and $ds$ area or line integration.
1006 gross 593 \end{funcdesc}
1007     \begin{funcdesc}{interpolate}{a,where}
1008 gross 599 interpolates argument \var{a} into the \FunctionSpace \var{where}.
1009 gross 593 \end{funcdesc}
1010 gross 599 \begin{funcdesc}{div}{a\optional{ ,where=None}}
1011     returns the divergence of \var{a}. This
1012     \begin{equation}
1013     \code{div(a)}=trace(grad(a),where)
1014     \end{equation}
1015 gross 593 \end{funcdesc}
1016 gross 599 \begin{funcdesc}{jump}{a\optional{ ,domain=None}}
1017     returns the jump of \var{a} over the discontinuity in its domain or if \Domain \var{domain} is present
1018     in \var{domain}.
1019     \begin{equation}
1020 gross 809 \begin{array}{rcl}
1021     \code{jump(a)}& = &\code{interpolate(a,FunctionOnContactOne(domain))} \\
1022     & & \hfill - \code{interpolate(a,FunctionOnContactZero(domain))}
1023     \end{array}
1024 gross 599 \end{equation}
1025 gross 593 \end{funcdesc}
1026     \begin{funcdesc}{L2}{a}
1027 gross 599 returns the $L^2$-norm of \var{a} in its function space. This is
1028     \begin{equation}
1029 gross 809 \code{L2(a)=integrate(length(a)}^2\code{)} \; .
1030 gross 599 \end{equation}
1031 gross 593 \end{funcdesc}
1032    
1033 gross 999 \subsection{\Operator Class}
1034 jgs 102 The \Operator class provides an abstract access to operators build
1035     within the \LinearPDE class. \Operator objects are created
1036     when a PDE is handed over to a PDE solver library and handled
1037     by the \LinearPDE class defining the PDE. The user can gain access
1038     to the \Operator of a \LinearPDE object through the \var{getOperator}
1039     method.
1040    
1041     \begin{classdesc}{Operator}{}
1042     creates an empty \Operator object.
1043     \end{classdesc}
1044    
1045     \begin{methoddesc}[Operator]{isEmpty}{fileName}
1046     returns \True is the object is empty. Otherwise \True is returned.
1047 jgs 82 \end{methoddesc}
1048    
1049 jgs 102 \begin{methoddesc}[Operator]{setValue}{value}
1050     resets all entires in the obeject representation to \var{value}
1051 jgs 82 \end{methoddesc}
1052    
1053 jgs 102 \begin{methoddesc}[Operator]{solves}{rhs}
1054     solves the operator equation with right hand side \var{rhs}
1055 jgs 82 \end{methoddesc}
1056    
1057 jgs 102 \begin{methoddesc}[Operator]{of}{u}
1058     applies the operator to the \Data object \var{u}
1059 jgs 82 \end{methoddesc}
1060    
1061 jgs 102 \begin{methoddesc}[Operator]{saveMM}{fileName}
1062 jgs 82 saves the object to a matrix market format file of name
1063     \var{fileName}, see
1064     \ulink{maths.nist.gov/MatrixMarket}{\url{http://maths.nist.gov/MatrixMarket}}.
1065     \index{Matrix Market}
1066     \end{methoddesc}
1067    

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26