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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3298 - (hide annotations)
Fri Oct 22 06:49:04 2010 UTC (11 years, 11 months ago) by caltinay
File MIME type: application/x-tex
File size: 66564 byte(s)


1 ksteube 1811
2     %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 ksteube 1316 %
4 jfenwick 2881 % Copyright (c) 2003-2010 by University of Queensland
5 ksteube 1811 % Earth Systems Science Computational Center (ESSCC)
6     % http://www.uq.edu.au/esscc
7 gross 625 %
8 ksteube 1811 % Primary Business: Queensland, Australia
9     % Licensed under the Open Software License version 3.0
10     % http://www.opensource.org/licenses/osl-3.0.php
11 gross 625 %
12 ksteube 1811 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13 jgs 82
14 caltinay 3293 \chapter{The \escript Module}\label{ESCRIPT CHAP}
15 ksteube 1811
16 caltinay 3291 \section{Concepts}
17     \escript is a \PYTHON module that allows you to represent the values of
18 ksteube 1318 a function at points in a \Domain in such a way that the function will
19 caltinay 3291 be useful for the Finite Element Method (FEM) simulation. It also
20 ksteube 1318 provides what we call a function space that describes how the data is
21 caltinay 3291 used in the simulation. Stored along with the data is information
22 ksteube 1318 about the elements and nodes which will be used by \finley.
23 jgs 82
24 caltinay 3291 \subsection{Function spaces}
25 jfenwick 1957 In order to understand what we mean by the term 'function space',
26 caltinay 3291 consider that the solution of a partial differential
27     equation\index{partial differential equation} (PDE) is a function on a domain
28 jfenwick 1957 $\Omega$. When solving a PDE using FEM, the solution is
29 caltinay 3291 piecewise-differentiable but, in general, its gradient is discontinuous.
30     To reflect these different degrees of smoothness, different function spaces
31     are used.
32     For instance, in FEM, the displacement field is represented by its values at
33     the nodes of the mesh, and so is continuous.
34     The strain, which is the symmetric part of the gradient of the displacement
35     field, is stored on the element centers, and so is considered to be
36     discontinuous.
37 ksteube 1318
38 caltinay 3291 A function space is described by a \FunctionSpace object.
39     The following statement generates the object \var{solution_space} which is
40 ksteube 1318 a \FunctionSpace object and provides access to the function space of
41 jgs 102 PDE solutions on the \Domain \var{mydomain}:
42 ksteube 1318
43 jgs 102 \begin{python}
44 ksteube 1318 solution_space=Solution(mydomain)
45 jgs 102 \end{python}
46 caltinay 3296 The following generators for function spaces on a \Domain \var{mydomain} are commonly used:
47 jgs 102 \begin{itemize}
48 caltinay 3291 \item \var{Solution(mydomain)}: solutions of a PDE
49     \item \var{ReducedSolution(mydomain)}: solutions of a PDE with a reduced
50     smoothness requirement, e.g. using a lower order approximation on the same
51     element or using macro elements\index{macro elements}
52     \item \var{ContinuousFunction(mydomain)}: continuous functions, e.g. a temperature distribution
53     \item \var{Function(mydomain)}: general functions which are not necessarily continuous, e.g. a stress field
54     \item \var{FunctionOnBoundary(mydomain)}: functions on the boundary of the domain, e.g. 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 jgs 102 \end{itemize}
58 gross 2647 In some cases under-integration is used. For these cases the user may use a
59 gross 2864 \FunctionSpace from the following list:
60 gross 2647 \begin{itemize}
61     \item \var{ReducedFunction(mydomain)}
62     \item \var{ReducedFunctionOnBoundary(mydomain)}
63 caltinay 3296 \item \var{ReducedFunctionOnContact0(mydomain)}
64 gross 2647 \item \var{ReducedFunctionOnContact1(mydomain)}
65     \end{itemize}
66 caltinay 3291 In comparison to the corresponding full version they use a reduced number of
67     integration nodes (typically one only) to represent values.
68 ksteube 1318
69 caltinay 3291 \begin{figure}
70     \centering
71     \includegraphics{EscriptDiagram1}
72     \caption{\label{ESCRIPT DEP}Dependency of function spaces in \finley.
73     An arrow indicates that a function in the \FunctionSpace at the starting point
74     can be interpolated to the \FunctionSpace of the arrow target.
75     All function spaces above the dotted line can be interpolated to any of
76     the function spaces below the line. See also \Sec{SEC Projection}.}
77     \end{figure}
78 gross 2647
79 caltinay 3291 The reduced smoothness for a PDE solution is often used to fulfill the
80     Ladyzhenskaya-Babuska-Brezzi condition\cite{LBB} when solving saddle point
81     problems\index{saddle point problems}, e.g. the Stokes equation.
82     A discontinuity\index{discontinuity} is a region within the domain across
83     which functions may be discontinuous.
84     The location of a discontinuity is defined in the \Domain object.
85     \fig{ESCRIPT DEP} shows the dependency between the types of function spaces
86 caltinay 3296 in \finley (other libraries may have different relationships).
87 ksteube 1318
88 caltinay 3291 The solution of a PDE is a continuous function. Any continuous function can
89     be seen as a general function on the domain and can be restricted to the
90     boundary as well as to one side of a discontinuity (the result will be
91     different depending on which side is chosen). Functions on any side of the
92     discontinuity can be seen as a function on the corresponding other side.
93 ksteube 1318
94 caltinay 3291 A function on the boundary or on one side of the discontinuity cannot be seen
95     as a general function on the domain as there are no values defined for the
96     interior. For most PDE solver libraries the space of the solution and
97     continuous functions is identical, however in some cases, for example when
98     periodic boundary conditions are used in \finley, a solution fulfills periodic
99     boundary conditions while a continuous function does not have to be periodic.
100 ksteube 1318
101 caltinay 3291 The concept of function spaces describes the properties of functions and
102     allows abstraction from the actual representation of the function in the
103     context of a particular application. For instance, in the FEM context a
104     function of the \Function type (written as \emph{Function()} in \fig{ESCRIPT DEP})
105     is usually represented by its values at the element center,
106     but in a finite difference scheme the edge midpoint of cells is preferred.
107     By changing its function space you can use the same function in a Finite
108     Difference scheme instead of Finite Element scheme.
109     Changing the function space of a particular function will typically lead to
110 caltinay 3296 a change of its representation.
111 caltinay 3291 So, when seen as a general function, a continuous function which is typically
112     represented by its values on the nodes of the FEM mesh or finite difference
113     grid must be interpolated to the element centers or the cell edges,
114     respectively. Interpolation happens automatically in \escript whenever it is
115     required\index{interpolation}. The user needs to be aware that an
116     interpolation is not always possible, see \fig{ESCRIPT DEP} for \finley.
117 caltinay 3296 An alternative approach to change the representation (=\FunctionSpace) is
118 caltinay 3291 projection\index{projection}, see \Sec{SEC Projection}.
119 jgs 82
120 caltinay 3298 \subsection{\Data Objects}
121 ksteube 1318 In \escript the class that stores these functions is called \Data.
122 jgs 102 The function is represented through its values on \DataSamplePoints where
123 caltinay 3291 the \DataSamplePoints are chosen according to the function space of the
124 caltinay 3296 function.
125 caltinay 3291 \Data class objects are used to define the coefficients of the PDEs to be
126     solved by a PDE solver library and also to store the solutions of the PDE.
127 jgs 82
128 caltinay 3291 The values of the function have a rank which gives the number of indices,
129     and a \Shape defining the range of each index.
130     The rank in \escript is limited to the range 0 through 4 and it is assumed
131     that the rank and \Shape is the same for all \DataSamplePoints.
132     The \Shape of a \Data object is a tuple (list) \var{s} of integers.
133     The length of \var{s} is the rank of the \Data object and the \var{i}-th
134     index ranges between 0 and $\var{s[i]}-1$.
135     For instance, a stress field has rank 2 and \Shape $(d,d)$ where $d$ is the
136     spatial dimension.
137     The following statement creates the \Data object \var{mydat} representing a
138     continuous function with values of \Shape $(2,3)$ and rank $2$:
139 jgs 102 \begin{python}
140 caltinay 3291 mydat=Data(value=1, what=ContinuousFunction(myDomain), shape=(2,3))
141 jgs 102 \end{python}
142 caltinay 3291 The initial value is the constant 1 for all \DataSamplePoints and all
143     components.
144 jgs 82
145 caltinay 3291 \Data objects can also be created from any \numpy array or any object, such
146     as a list of floating point numbers, that can be converted into
147 caltinay 3296 a \numpyNDA\cite{NUMPY}.
148 caltinay 3291 The following two statements create objects which are equivalent
149     to \var{mydat}:
150 jgs 102 \begin{python}
151 caltinay 3291 mydat1=Data(value=numpy.ones((2,3)), what=ContinuousFunction(myDomain))
152     mydat2=Data(value=[[1,1], [1,1], [1,1]], what=ContinuousFunction(myDomain))
153 jgs 102 \end{python}
154 caltinay 3291 In the first case the initial value is \var{numpy.ones((2,3))} which generates
155     a $2 \times 3$ matrix as a \numpyNDA filled with ones.
156     The \Shape of the created \Data object is taken from the \Shape of the array.
157     In the second case, the creator converts the initial value, which is a list of
158 caltinay 3296 lists, into a \numpyNDA before creating the actual \Data object.
159 jgs 82
160 jgs 102 For convenience \escript provides creators for the most common types
161 caltinay 3291 of \Data objects in the following forms (\var{d} defines the spatial dimension):
162 jgs 102 \begin{itemize}
163 caltinay 3291 \item \code{Scalar(0, Function(mydomain))} is the same as \code{Data(0, Function(myDomain),(,))}
164     (each value is a scalar), e.g. a temperature field
165     \item \code{Vector(0, Function(mydomain))} is the same as \code{Data(0, Function(myDomain),(d))}
166     (each value is a vector), e.g. a velocity field
167     \item \code{Tensor(0, Function(mydomain))} is the same as \code{Data(0, Function(myDomain), (d,d))},
168     e.g. a stress field
169     \item \code{Tensor4(0,Function(mydomain))} is the same as \code{Data(0,Function(myDomain), (d,d,d,d))}
170     e.g. a Hook tensor field
171 jgs 102 \end{itemize}
172 caltinay 3291 Here the initial value is 0 but any object that can be converted into
173     a \numpyNDA and whose \Shape is consistent with \Shape of the \Data object to
174     be created can be used as the initial value.
175 jgs 82
176 caltinay 3291 \Data objects can be manipulated by applying unary operations (e.g. cos, sin,
177     log), and they can be combined point-wise by applying arithmetic operations
178     (e.g. +, - ,* , /).
179     We emphasize that \escript itself does not handle any spatial dependencies as
180     it does not know how values are interpreted by the processing PDE solver library.
181     However \escript invokes interpolation if this is needed during data manipulations.
182     Typically, this occurs in binary operations when both arguments belong to
183     different function spaces or when data are handed over to a PDE solver library
184     which requires functions to be represented in a particular way.
185 jgs 82
186 caltinay 3291 The following example shows the usage of \Data objects. Assume we have a
187 jgs 102 displacement field $u$ and we want to calculate the corresponding stress field
188 caltinay 3291 $\sigma$ using the linear-elastic isotropic material model
189 jgs 102 \begin{eqnarray}\label{eq: linear elastic stress}
190 caltinay 3296 \sigma_{ij}=\lambda u_{k,k} \delta_{ij} + \mu ( u_{i,j} + u_{j,i})
191 jgs 102 \end{eqnarray}
192 caltinay 3296 where $\delta_{ij}$ is the Kronecker symbol and
193 jgs 102 $\lambda$ and $\mu$ are the Lame coefficients. The following function
194 caltinay 3291 takes the displacement \var{u} and the Lame coefficients \var{lam} and \var{mu}
195     as arguments and returns the corresponding stress:
196 jgs 102 \begin{python}
197 ksteube 1318 from esys.escript import *
198 caltinay 3291 def getStress(u, lam, mu):
199 ksteube 1318 d=u.getDomain().getDim()
200     g=grad(u)
201     stress=lam*trace(g)*kronecker(d)+mu*(g+transpose(g))
202 caltinay 3291 return stress
203 jgs 102 \end{python}
204 caltinay 3291 The variable \var{d} gives the spatial dimension of the domain on which the
205     displacements are defined.
206     \var{kronecker} returns the Kronecker symbol with indexes $i$ and $j$ running
207     from 0 to \var{d}-1.
208     The call \var{grad(u)} requires the displacement field \var{u} to be in
209     the \var{Solution} or \ContinuousFunction.
210 caltinay 3296 The result \var{g} as well as the returned stress will be in the \Function.
211 caltinay 3291 If, for example, \var{u} is the solution of a PDE then \code{getStress} might
212     be called in the following way:
213 jgs 102 \begin{python}
214 caltinay 3291 s=getStress(u, 1., 2.)
215 jgs 102 \end{python}
216 caltinay 3291 However \code{getStress} can also be called with \Data objects as values for
217     \var{lam} and \var{mu} which, for instance in the case of a temperature
218     dependency, are calculated by an expression.
219 jgs 102 The following call is equivalent to the previous example:
220     \begin{python}
221 caltinay 3291 lam=Scalar(1., ContinuousFunction(mydomain))
222     mu=Scalar(2., Function(mydomain))
223     s=getStress(u, lam, mu)
224 jgs 102 \end{python}
225 caltinay 3298 %
226 caltinay 3291 The function \var{lam} belongs to the \ContinuousFunction but with \var{g} the
227     function \var{trace(g)} is in the \Function.
228 ksteube 1318 In the evaluation of the product \var{lam*trace(g)} we have different function
229     spaces (on the nodes versus in the centers) and at first glance we have incompatible data.
230 caltinay 3291 \escript converts the arguments into an appropriate function space according
231     to \fig{ESCRIPT DEP}.
232     In this example that means \escript sees \var{lam} as a function of the \Function.
233     In the context of FEM this means the nodal values of \var{lam} are
234     interpolated to the element centers.
235 ksteube 1318 The interpolation is automatic and requires no special handling.
236 jgs 82
237 jgs 102 \begin{figure}
238 caltinay 3291 \centering
239     \includegraphics{EscriptDiagram2}
240     \caption{\label{Figure: tag}Element Tagging. A rectangular mesh over a region
241     with two rock types {\it white} and {\it gray} is shown.
242     The number in each cell refers to the major rock type present in the cell
243     ($1$ for {\it white} and $2$ for {\it gray}).}
244 jgs 102 \end{figure}
245 jgs 82
246 caltinay 3291 \subsection{Tagged, Expanded and Constant Data}
247     Material parameters such as the Lame coefficients are typically dependent on
248     rock types present in the area of interest.
249     A common technique to handle these kinds of material parameters is
250     \emph{tagging}\index{tagging}, which uses storage efficiently.
251     \fig{Figure: tag} shows an example. In this case two rock types {\it white}
252     and {\it gray} can be found in the domain.
253     The domain is subdivided into triangular shaped cells.
254     Each cell has a tag indicating the rock type predominantly found in this cell.
255     Here $1$ is used to indicate rock type {\it white} and $2$ for rock type {\it gray}.
256     The tags are assigned at the time when the cells are generated and stored in
257     the \Domain class object. To allow easier usage of tags, names can be used
258     instead of numbers. These names are typically defined at the time when the
259     geometry is generated.
260 gross 1044
261 caltinay 3291 The following statements show how to use tagged values for \var{lam} as shown
262     in \fig{Figure: tag} for the stress calculation discussed above:
263 jgs 102 \begin{python}
264 caltinay 3291 lam=Scalar(value=2., what=Function(mydomain))
265     insertTaggedValue(lam, white=30., gray=5000.)
266     s=getStress(u, lam, 2.)
267 jgs 102 \end{python}
268 caltinay 3291 In this example \var{lam} is set to $30$ for those cells with tag {\it white}
269     (=$1$) and to $5000$ for cells with tag {\it gray} (=$2$).
270     The initial value $2$ of \var{lam} is used as a default value for the case
271     when a tag is encountered which has not been linked with a value.
272     The \code{getStress} method does not need to be changed now that we are using tags.
273 ksteube 1318 \escript resolves the tags when \var{lam*trace(g)} is calculated.
274 jgs 82
275 ksteube 1318 This brings us to a very important point about \escript.
276 caltinay 3291 You can develop a simulation with constant Lame coefficients, and then later
277 caltinay 3298 switch to tagged Lame coefficients without otherwise changing your \PYTHON script.
278 caltinay 3291 In short, you can use the same script for models with different domains and
279     different types of input data.
280 ksteube 1318
281 caltinay 3291 There are three main ways in which \Data objects are represented internally --
282     constant, tagged, and expanded.
283     In the constant case, the same value is used at each sample point while only a
284     single value is stored to save memory.
285 ksteube 1318 In the expanded case, each sample point has an individual value (such as for the solution of a PDE).
286 caltinay 3291 This is where your largest data sets will be created because the values are
287     stored as a complete array.
288 ksteube 1318 The tagged case has already been discussed above.
289 caltinay 3298 Expanded data is created when specifying \code{expanded=True} in the \Data
290     object constructor, while tagged data requires calling the \member{insertTaggedValue}
291 caltinay 3291 method as shown above.
292 caltinay 3296
293 caltinay 3291 Values are accessed through a sample reference number.
294     Operations on expanded \Data objects have to be performed for each sample
295     point individually.
296     When tagged values are used, the values are held in a dictionary.
297     Operations on tagged data require processing the set of tagged values only,
298     rather than processing the value for each individual sample point.
299 ksteube 1318 \escript allows any mixture of constant, tagged and expanded data in a single expression.
300 jgs 82
301 caltinay 3291 \subsection{Saving and Restoring Simulation Data}
302     \Data objects can be written to disk files with the \member{dump} method and
303     read back using the \member{load} method, both of which use the
304     \netCDF\cite{NETCDF} file format.
305     Use these to save data for checkpoint/restart or simply to save and reuse data
306     that was expensive to compute.
307     For instance, to save the coordinates of the data points of a
308     \ContinuousFunction to the file \file{x.nc} use
309 gross 983 \begin{python}
310 ksteube 1318 x=ContinuousFunction(mydomain).getX()
311     x.dump("x.nc")
312 caltinay 3291 mydomain.dump("dom.nc")
313 gross 983 \end{python}
314 caltinay 3298 To recover the object \var{x}, and you know that \var{mydomain} was an \finley
315     mesh, use
316 gross 983 \begin{python}
317 gross 2417 from esys.finley import LoadMesh
318 caltinay 3291 mydomain=LoadMesh("dom.nc")
319 ksteube 1318 x=load("x.nc", mydomain)
320 gross 983 \end{python}
321 caltinay 3291 Obviously, it is possible to execute the same steps that were originally used
322     to generate \var{mydomain} to recreate it. However, in most cases using
323     \member{dump} and \member{load} is faster, particularly if optimization has
324     been applied.
325     If \escript is running on more than one \MPI process \member{dump} will create
326     an individual file for each process containing the local data.
327     In order to avoid conflicts the file names are extended by the \MPI processor
328     rank, that is instead of one file \file{dom.nc} you would get
329     \file{dom.nc.0000}, \file{dom.nc.0001}, etc. You still call
330 caltinay 3298 \code{LoadMesh("dom.nc")} to load the domain but you have to make sure that
331 caltinay 3291 the appropriate file is accessible from the corresponding rank, and loading
332     will only succeed if you run with as many processes as were used when calling
333     \member{dump}.
334 ksteube 1318
335 caltinay 3291 The function space of the \Data is stored in \file{x.nc}.
336     If the \Data object is expanded, the number of data points in the file and of
337     the \Domain for the particular \FunctionSpace must match.
338     Moreover, the ordering of the values is checked using the reference
339     identifiers provided by \FunctionSpace on the \Domain.
340     In some cases, data points will be reordered so be aware and confirm that you
341     get what you wanted.
342 gross 983
343 caltinay 3291 A newer, more flexible way of saving and restoring \escript simulation data
344     is through a \class{DataManager} class object.
345     It has the advantage of allowing to save and load not only a \Domain and
346     \Data objects but also other values\footnote{The \PYTHON \emph{pickle} module
347     is used for other types.} you compute in your simulation script.
348     Further, \class{DataManager} objects can simultaneously create files for
349 caltinay 3298 visualization so no extra calls to \code{saveVTK} etc. are needed.
350 gross 983
351 caltinay 3291 The following example shows how the \class{DataManager} class can be used.
352     For an explanation of all member functions and options see the relevant
353     reference section.
354     \begin{python}
355     from esys.escript import DataManager, Scalar, Function
356     from esys.finley import Rectangle
357    
358     dm = DataManager(formats=[DataManager.RESTART, DataManager.VTK])
359     if dm.hasData():
360     mydomain=dm.getDomain()
361     val=dm.getValue("val")
362     t=dm.getValue("t")
363     t_max=dm.getValue("t_max")
364     else:
365     mydomain=Rectangle()
366     val=Function(mydomain).getX()
367     t=0.
368     t_max=2.5
369    
370     while t<t_max:
371     t+=.01
372     val=val+t/2
373     dm.addData(val=val, t=t, t_max=t_max)
374     dm.export()
375     \end{python}
376     In the constructor we specify that we want \code{RESTART} (i.e. dump) files
377     and \code{VTK} files to be saved.
378     By default, the constructor will look for previously saved \code{RESTART}
379     files under the current directory and load them.
380     We can then enquire if such files were found by calling the \member{hasData}
381     method. If it returns \True we retrieve the domain and values into local
382     variables. Otherwise the same variables are initialized with appropriate
383     values to start a new simulation.
384     Note, that \var{t} and \var{t_max} are regular floating point values and not
385 caltinay 3298 \Data objects. Yet they are treated the same way by the \class{DataManager}.
386 caltinay 3291
387     After this initialization step the script enters the main simulation loop
388     where calculations are performed.
389     When these are finalized for a time step we call the \member{addData} method
390     to let the manager know which variables to store on disk.
391 caltinay 3298 This does not actually save the data yet and it is allowed to call
392 caltinay 3291 \member{addData} more than once to add information incrementally, e.g. from
393     separate functions that have access to the \class{DataManager} instance.
394     Once all variables have been added the \member{export} method has to be called
395     to flush all data to disk and clear the manager.
396     In this example, this call dumps \var{mydomain} and \var{val} to files
397     in a restart directory and also stores \var{t} and \var{t_max} on disk.
398     Additionally, it generates a \VTK file for visualization of the data.
399 caltinay 3298 If the script would stop running before its completion for some reason (e.g.
400     because its runtime limit was exceeded in a multiuser environment), you could
401     simply run it again and it would resume at the point it stopped before.
402 caltinay 3291
403 gross 999 \section{\escript Classes}
404    
405 caltinay 3296 \subsection{The \Domain class}
406 jgs 102 \begin{classdesc}{Domain}{}
407 caltinay 3291 A \Domain object is used to describe a geometric region together with
408 jgs 102 a way of representing functions over this region.
409 jfenwick 1959 The \Domain class provides an abstract interface to the domain of \FunctionSpace and \Data objects.
410     \Domain needs to be subclassed in order to provide a complete implementation.
411 jgs 82 \end{classdesc}
412 caltinay 3298 %
413 ksteube 1316 The following methods are available:
414 caltinay 3298 %
415 jgs 102 \begin{methoddesc}[Domain]{getDim}{}
416 caltinay 3298 returns the spatial dimension of the \Domain.
417 jgs 102 \end{methoddesc}
418 caltinay 3298 %
419 gross 2417 \begin{methoddesc}[Domain]{dump}{filename}
420 caltinay 3298 writes the \Domain to the file \var{filename} using the \netCDF file format.
421 gross 2417 \end{methoddesc}
422 caltinay 3298 %
423 jgs 102 \begin{methoddesc}[Domain]{getX}{}
424 caltinay 3298 returns the locations in the \Domain. The \FunctionSpace of the returned
425     \Data object is chosen by the \Domain implementation. Typically it will be
426     in the \Function.
427 jgs 102 \end{methoddesc}
428 caltinay 3298 %
429 jgs 102 \begin{methoddesc}[Domain]{setX}{newX}
430 caltinay 3298 assigns new locations to the \Domain. \var{newX} has to have \Shape $(d,)$
431     where $d$ is the spatial dimension of the domain. Typically \var{newX}
432     must be in the \ContinuousFunction but the space actually to be used
433     depends on the \Domain implementation.
434 jgs 102 \end{methoddesc}
435 caltinay 3298 %
436 jgs 102 \begin{methoddesc}[Domain]{getNormal}{}
437 caltinay 3298 returns the surface normals on the boundary of the \Domain as a \Data object.
438 jgs 102 \end{methoddesc}
439 caltinay 3298 %
440 jgs 102 \begin{methoddesc}[Domain]{getSize}{}
441 caltinay 3298 returns the local sample size, i.e. the element diameter, as a \Data object.
442 jgs 102 \end{methoddesc}
443 caltinay 3298 %
444 gross 1044 \begin{methoddesc}[Domain]{setTagMap}{tag_name, tag}
445 caltinay 3298 defines a mapping of the tag name \var{tag_name} to the \var{tag}.
446 gross 1044 \end{methoddesc}
447 caltinay 3298 %
448 gross 1044 \begin{methoddesc}[Domain]{getTag}{tag_name}
449 caltinay 3298 returns the tag associated with the tag name \var{tag_name}.
450 gross 1044 \end{methoddesc}
451 caltinay 3298 %
452 gross 1044 \begin{methoddesc}[Domain]{isValidTagName}{tag_name}
453 caltinay 3298 returns \True if \var{tag_name} is a valid tag name.
454 gross 1044 \end{methoddesc}
455 caltinay 3298 %
456 jgs 102 \begin{methoddesc}[Domain]{__eq__}{arg}
457 caltinay 3298 (\PYTHON \var{==} operator) returns \True if the \Domain \var{arg}
458     describes the same domain, \False otherwise.
459 jgs 102 \end{methoddesc}
460 caltinay 3298 %
461 jgs 102 \begin{methoddesc}[Domain]{__ne__}{arg}
462 caltinay 3298 (\PYTHON \var{!=} operator) returns \True if the \Domain \var{arg} does
463     not describe the same domain, \False otherwise.
464 jgs 102 \end{methoddesc}
465 caltinay 3298 %
466     \begin{methoddesc}[Domain]{__str__}{}
467     (\PYTHON \var{str()} function) returns a string representation of the
468     \Domain.
469 gross 593 \end{methoddesc}
470 caltinay 3298 %
471 gross 2318 \begin{methoddesc}[Domain]{onMasterProcessor)}{}
472 caltinay 3298 returns \True if the processor is the master processor within the \MPI
473     processor group used by the \Domain. This is the processor with rank 0.
474     If \MPI support is not enabled the return value is always \True.
475 jfenwick 1966 \end{methoddesc}
476 caltinay 3298 %
477 gross 2318 \begin{methoddesc}[Domain]{getMPISize}{}
478 caltinay 3298 returns the number of \MPI processors used for this \Domain. If \MPI
479     support is not enabled 1 is returned.
480 jfenwick 1966 \end{methoddesc}
481 caltinay 3298 %
482 gross 2318 \begin{methoddesc}[Domain]{getMPIRank}{}
483 caltinay 3298 returns the rank of the processor executing the statement within the
484     \MPI processor group used by the \Domain. If \MPI support is not enabled
485     0 is returned.
486 jfenwick 1966 \end{methoddesc}
487 caltinay 3298 %
488 gross 2318 \begin{methoddesc}[Domain]{MPIBarrier}{}
489 caltinay 3298 executes barrier synchronization within the \MPI processor group used by
490     the \Domain. If \MPI support is not enabled, this command does nothing.
491 jfenwick 1966 \end{methoddesc}
492    
493 caltinay 3296 \subsection{The \FunctionSpace class}
494 jgs 102 \begin{classdesc}{FunctionSpace}{}
495 caltinay 3298 \FunctionSpace objects are used to define properties of \Data objects such as continuity.
496     \FunctionSpace objects are instantiated by generator functions.
497     A \Data object in a particular \FunctionSpace is represented by its values at
498     \DataSamplePoints which are defined by the type and the \Domain of the \FunctionSpace.
499 jgs 82 \end{classdesc}
500 caltinay 3298 %
501 gross 1044 The following methods are available:
502 caltinay 3298 %
503 jgs 102 \begin{methoddesc}[FunctionSpace]{getDim}{}
504 caltinay 3298 returns the spatial dimension of the \Domain of the \FunctionSpace.
505 jgs 102 \end{methoddesc}
506 caltinay 3298 %
507 jgs 102 \begin{methoddesc}[FunctionSpace]{getX}{}
508 caltinay 3298 returns the location of the \DataSamplePoints.
509 jgs 102 \end{methoddesc}
510 caltinay 3298 %
511 jgs 102 \begin{methoddesc}[FunctionSpace]{getNormal}{}
512 caltinay 3298 If the domain of functions in the \FunctionSpace is a hyper-manifold (e.g.
513     the boundary of a domain) the method returns the outer normal at each of
514     the \DataSamplePoints. Otherwise an exception is raised.
515 jgs 102 \end{methoddesc}
516 caltinay 3298 %
517 jgs 102 \begin{methoddesc}[FunctionSpace]{getSize}{}
518 caltinay 3298 returns a \Data object measuring the spacing of the \DataSamplePoints.
519     The size may be zero.
520 jgs 102 \end{methoddesc}
521 caltinay 3298 %
522 jgs 102 \begin{methoddesc}[FunctionSpace]{getDomain}{}
523 caltinay 3298 returns the \Domain of the \FunctionSpace.
524 jgs 102 \end{methoddesc}
525 caltinay 3298 %
526 gross 1044 \begin{methoddesc}[FunctionSpace]{setTags}{new_tag, mask}
527 caltinay 3298 assigns a new tag \var{new_tag} to all data samples where \var{mask} is
528     positive for a least one data point.
529     \var{mask} must be defined on this \FunctionSpace.
530     Use the \var{setTagMap} to assign a tag name to \var{new_tag}.
531 gross 1044 \end{methoddesc}
532 caltinay 3298 %
533 jgs 102 \begin{methoddesc}[FunctionSpace]{__eq__}{arg}
534 caltinay 3298 (\PYTHON \var{==} operator) returns \True if the \FunctionSpace \var{arg}
535     describes the same function space, \False otherwise.
536 jgs 102 \end{methoddesc}
537 caltinay 3298 %
538 jgs 102 \begin{methoddesc}[FunctionSpace]{__ne__}{arg}
539 caltinay 3298 (\PYTHON \var{!=} operator) returns \True if the \FunctionSpace \var{arg}
540     does not describe the same function space, \False otherwise.
541 jgs 102 \end{methoddesc}
542 jgs 82
543 caltinay 3298 \begin{methoddesc}[Domain]{__str__}{}
544     (\PYTHON \var{str()} function) returns a string representation of the
545     \FunctionSpace.
546 gross 593 \end{methoddesc}
547 caltinay 3298 %
548     The following functions provide generators for \FunctionSpace objects:
549     %
550 jgs 102 \begin{funcdesc}{Function}{domain}
551 caltinay 3298 returns the \Function on the \Domain \var{domain}. \Data objects in this
552     type of \Function are defined over the whole geometric region defined by
553     \var{domain}.
554 jgs 82 \end{funcdesc}
555 caltinay 3298 %
556 jgs 102 \begin{funcdesc}{ContinuousFunction}{domain}
557 caltinay 3298 returns the \ContinuousFunction on the \Domain domain. \Data objects in
558     this type of \Function are defined over the whole geometric region defined
559     by \var{domain} and assumed to represent a continuous function.
560 jgs 82 \end{funcdesc}
561 caltinay 3298 %
562 jgs 102 \begin{funcdesc}{FunctionOnBoundary}{domain}
563 caltinay 3298 returns the \FunctionOnBoundary on the \Domain domain. \Data objects in
564     this type of \Function are defined on the boundary of the geometric region
565     defined by \var{domain}.
566 jgs 82 \end{funcdesc}
567 caltinay 3298 %
568 jgs 102 \begin{funcdesc}{FunctionOnContactZero}{domain}
569 caltinay 3298 returns the \FunctionOnContactZero the \Domain domain. \Data objects in
570     this type of \Function are defined on side 0 of a discontinuity within
571     the geometric region defined by \var{domain}.
572     The discontinuity is defined when \var{domain} is instantiated.
573 jgs 82 \end{funcdesc}
574 caltinay 3298 %
575 jgs 102 \begin{funcdesc}{FunctionOnContactOne}{domain}
576 caltinay 3298 returns the \FunctionOnContactOne on the \Domain domain. \Data objects in
577     this type of \Function are defined on side 1 of a discontinuity within
578     the geometric region defined by \var{domain}.
579     The discontinuity is defined when \var{domain} is instantiated.
580 jgs 82 \end{funcdesc}
581 caltinay 3298 %
582 jgs 102 \begin{funcdesc}{Solution}{domain}
583 caltinay 3298 returns the \SolutionFS on the \Domain domain. \Data objects in this type
584     of \Function are defined on the geometric region defined by \var{domain}
585     and are solutions of partial differential equations\index{partial differential equation}.
586 jgs 82 \end{funcdesc}
587 caltinay 3298 %
588 jgs 102 \begin{funcdesc}{ReducedSolution}{domain}
589 caltinay 3298 returns the \ReducedSolutionFS on the \Domain domain. \Data objects in
590     this type of \Function are defined on the geometric region defined by
591     \var{domain} and are solutions of partial differential
592     equations\index{partial differential equation} with a reduced smoothness
593     for the solution approximation.
594 jgs 82 \end{funcdesc}
595    
596 caltinay 3296 \subsection{The \Data Class}
597 jgs 107 \label{SEC ESCRIPT DATA}
598 jgs 82
599 caltinay 3298 The following table shows arithmetic operations that can be performed
600     point-wise on \Data objects:
601     \begin{center}
602 caltinay 3293 \begin{tabular}{l|l}
603 caltinay 3298 \textbf{Expression} & \textbf{Description}\\
604 caltinay 3293 \hline
605 caltinay 3298 \code{+arg} & identical to \var{arg}\index{+}\\
606     \code{-arg} & negation of \var{arg}\index{-}\\
607     \code{arg0+arg1} & adds \var{arg0} and \var{arg1}\index{+}\\
608     \code{arg0*arg1} & multiplies \var{arg0} and \var{arg1}\index{*}\\
609     \code{arg0-arg1} & subtracts \var{arg1} from \var{arg0}\index{-}\\
610     \code{arg0/arg1} & divides \var{arg0} by \var{arg1}\index{/}\\
611     \code{arg0**arg1} & raises \var{arg0} to the power of \var{arg1}\index{**}\\
612 caltinay 3293 \end{tabular}
613 caltinay 3298 \end{center}
614     At least one of the arguments \var{arg0} or \var{arg1} must be a \Data object.
615     Either of the arguments may be a \Data object, a \PYTHON number or a \numpy
616     object.
617     If \var{arg0} or \var{arg1} are not defined on the same \FunctionSpace, then
618     an attempt is made to convert \var{arg0} to the \FunctionSpace of \var{arg1}
619     or to convert \var{arg1} to the \FunctionSpace of \var{arg0}.
620     Both arguments must have the same \Shape or one of the arguments may be of
621     rank 0 (a constant).
622 jgs 102 The returned \Data object has the same \Shape and is defined on
623 gross 625 the \DataSamplePoints as \var{arg0} or \var{arg1}.
624 jgs 82
625 jgs 102 The following table shows the update operations that can be applied to
626     \Data objects:
627 caltinay 3298 \begin{center}
628 caltinay 3293 \begin{tabular}{l|l}
629 caltinay 3298 \textbf{Expression} & \textbf{Description}\\
630 caltinay 3293 \hline
631 caltinay 3298 \code{arg0+=arg1} & adds \var{arg1} to \var{arg0}\index{+}\\
632     \code{arg0*=arg1} & multiplies \var{arg0} by \var{arg1}\index{*}\\
633     \code{arg0-=arg1} & subtracts \var{arg1} from\var{arg0}\index{-}\\
634     \code{arg0/=arg1} & divides \var{arg0} by \var{arg1}\index{/}\\
635     \code{arg0**=arg1} & raises \var{arg0} to the power of \var{arg1}\index{**}\\
636 caltinay 3293 \end{tabular}
637 caltinay 3298 \end{center}
638     \var{arg0} must be a \Data object. \var{arg1} must be a \Data object or an
639     object that can be converted into a \Data object.
640     \var{arg1} must have the same \Shape as \var{arg0} or have rank 0.
641     In the latter case it is assumed that the values of \var{arg1} are constant
642     for all components. \var{arg1} must be defined in the same \FunctionSpace as
643 gross 625 \var{arg0} or it must be possible to interpolate \var{arg1} onto the
644 jfenwick 1959 \FunctionSpace of \var{arg0}.
645 jgs 82
646 caltinay 3298 The \Data class supports taking slices as well as assigning new values to a
647     slice of an existing \Data object\index{slicing}.
648 ksteube 1318 The following expressions for taking and setting slices are valid:
649 caltinay 3298 \begin{center}
650 caltinay 3293 \begin{tabular}{l|ll}
651 caltinay 3298 \textbf{Rank of \var{arg}} & \textbf{Slicing expression} & \textbf{\Shape of returned and assigned object}\\
652 caltinay 3293 \hline
653 caltinay 3298 0 & no slicing & N/A\\
654 caltinay 3293 1 & \var{arg[l0:u0]} & (\var{u0}-\var{l0},)\\
655     2 & \var{arg[l0:u0,l1:u1]} & (\var{u0}-\var{l0},\var{u1}-\var{l1})\\
656     3 & \var{arg[l0:u0,l1:u1,l2:u2]} & (\var{u0}-\var{l0},\var{u1}-\var{l1},\var{u2}-\var{l2})\\
657     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})\\
658     \end{tabular}
659 caltinay 3298 \end{center}
660 caltinay 3296 where \var{s} is the \Shape of \var{arg} and
661 jfenwick 1959 \[0 \le \var{l0} \le \var{u0} \le \var{s[0]},\]
662 caltinay 3296 \[0 \le \var{l1} \le \var{u1} \le \var{s[1]},\]
663     \[0 \le \var{l2} \le \var{u2} \le \var{s[2]},\]
664 jfenwick 1959 \[0 \le \var{l3} \le \var{u3} \le \var{s[3]}.\]
665 caltinay 3296 Any of the lower indexes \var{l0}, \var{l1}, \var{l2} and \var{l3} may not be present in which case
666     $0$ is assumed.
667     Any of the upper indexes \var{u0}, \var{u1}, \var{u2} and \var{u3} may be omitted, in which case, the upper limit for that dimension is assumed.
668 jfenwick 1959 The lower and upper index may be identical, in which case the column and the lower or upper
669     index may be dropped. In the returned or in the object assigned to a slice, the corresponding component is dropped,
670 jgs 102 i.e. the rank is reduced by one in comparison to \var{arg}.
671 ksteube 1318 The following examples show slicing in action:
672 jgs 102 \begin{python}
673 ksteube 1318 t=Data(1.,(4,4,6,6),Function(mydomain))
674     t[1,1,1,0]=9.
675     s=t[:2,:,2:6,5] # s has rank 3
676     s[:,:,1]=1.
677     t[:2,:2,5,5]=s[2:4,1,:2]
678 jgs 102 \end{python}
679    
680 jfenwick 1959 \subsection{Generation of \Data objects}
681 gross 593 \begin{classdesc}{Data}{value=0,shape=(,),what=FunctionSpace(),expand=\False}
682 jgs 102 creates a \Data object with \Shape \var{shape} in the \FunctionSpace \var{what}.
683     The values at all \DataSamplePoints are set to the double value \var{value}. If \var{expanded} is \True
684     the \Data object is represented in expanded from.
685 jgs 82 \end{classdesc}
686    
687 gross 593 \begin{classdesc}{Data}{value,what=FunctionSpace(),expand=\False}
688 caltinay 3296 creates a \Data object in the \FunctionSpace \var{what}.
689     The value for each \DataSamplePoints is set to \var{value}, which could be a \numpy, \Data object \var{value} or a dictionary of
690 gross 2484 \numpy or floating point numbers. In the latter case the keys must be integers and are used
691 gross 593 as tags.
692 jgs 102 The \Shape of the returned object is equal to the \Shape of \var{value}. If \var{expanded} is \True
693 ksteube 1318 the \Data object is represented in expanded form.
694 jgs 102 \end{classdesc}
695    
696     \begin{classdesc}{Data}{}
697     creates an \EmptyData object. The \EmptyData object is used to indicate that an argument is not present
698     where a \Data object is required.
699     \end{classdesc}
700    
701 jfenwick 1959 \begin{funcdesc}{Scalar}{value=0.,what=FunctionSpace(),expand=\False}
702 ksteube 1318 returns a \Data object of rank 0 (a constant) in the \FunctionSpace \var{what}.
703 gross 2404 Values are initialized with \var{value}, a double precision quantity. If \var{expanded} is \True
704 gross 593 the \Data object is represented in expanded from.
705     \end{funcdesc}
706    
707 jfenwick 1959 \begin{funcdesc}{Vector}{value=0.,what=FunctionSpace(),expand=\False}
708     returns a \Data object of \Shape \var{(d,)} in the \FunctionSpace \var{what},
709 gross 593 where \var{d} is the spatial dimension of the \Domain of \var{what}.
710 ksteube 1318 Values are initialed with \var{value}, a double precision quantity. If \var{expanded} is \True
711 gross 593 the \Data object is represented in expanded from.
712     \end{funcdesc}
713    
714 jfenwick 1959 \begin{funcdesc}{Tensor}{value=0.,what=FunctionSpace(),expand=\False}
715     returns a \Data object of \Shape \var{(d,d)} in the \FunctionSpace \var{what},
716 gross 593 where \var{d} is the spatial dimension of the \Domain of \var{what}.
717 ksteube 1318 Values are initialed with \var{value}, a double precision quantity. If \var{expanded} is \True
718 gross 593 the \Data object is represented in expanded from.
719     \end{funcdesc}
720    
721 jfenwick 1959 \begin{funcdesc}{Tensor3}{value=0.,what=FunctionSpace(),expand=\False}
722     returns a \Data object of \Shape \var{(d,d,d)} in the \FunctionSpace \var{what},
723 gross 593 where \var{d} is the spatial dimension of the \Domain of \var{what}.
724 ksteube 1318 Values are initialed with \var{value}, a double precision quantity. If \var{expanded} is \True
725 gross 593 the \Data object is re\var{arg}presented in expanded from.
726     \end{funcdesc}
727    
728 jfenwick 1959 \begin{funcdesc}{Tensor4}{value=0.,what=FunctionSpace(),expand=\False}
729     returns a \Data object of \Shape \var{(d,d,d,d)} in the \FunctionSpace \var{what},
730 gross 593 where \var{d} is the spatial dimension of the \Domain of \var{what}.
731 gross 2404 Values are initialized with \var{value}, a double precision quantity. If \var{expanded} is \True
732 gross 593 the \Data object is represented in expanded from.
733     \end{funcdesc}
734    
735 gross 983 \begin{funcdesc}{load}{filename,domain}
736 gross 2316 recovers a \Data object on \Domain \var{domain} from the file \var{filename}, which was created by \function{dump}.
737 gross 983 \end{funcdesc}
738    
739 jfenwick 1959 \subsection{\Data methods}
740 caltinay 3296 These are the most frequently-used methods of the
741 ksteube 1318 \Data class. A complete list of methods can be found on \ReferenceGuide.
742 jgs 102 \begin{methoddesc}[Data]{getFunctionSpace}{}
743     returns the \FunctionSpace of the object.
744 jgs 82 \end{methoddesc}
745    
746 gross 593 \begin{methoddesc}[Data]{getDomain}{}
747 jgs 102 returns the \Domain of the object.
748     \end{methoddesc}
749    
750 jgs 82 \begin{methoddesc}[Data]{getShape}{}
751 jgs 102 returns the \Shape of the object as a \class{tuple} of
752     integers.
753 jgs 82 \end{methoddesc}
754    
755     \begin{methoddesc}[Data]{getRank}{}
756     returns the rank of the data on each data point. \index{rank}
757     \end{methoddesc}
758    
759 jgs 102 \begin{methoddesc}[Data]{isEmpty}{}
760     returns \True id the \Data object is the \EmptyData object.
761     Otherwise \False is returned.
762 jfenwick 1959 Note that this is not the same as asking if the object contains no \DataSamplePoints.
763 jgs 82 \end{methoddesc}
764    
765 gross 1044 \begin{methoddesc}[Data]{setTaggedValue}{tag_name,value}
766 jgs 102 assigns the \var{value} to all \DataSamplePoints which have the tag
767 gross 1044 assigned to \var{tag_name}. \var{value} must be an object of class
768 gross 2484 \class{numpy.ndarray} or must be convertible into a
769     \class{numpy.ndarray} object. \var{value} (or the corresponding
770     \class{numpy.ndarray} object) must be of rank $0$ or must have the
771 jgs 102 same rank like the object.
772 gross 1044 If a value has already be defined for tag \var{tag_name} within the object
773 jgs 102 it is overwritten by the new \var{value}. If the object is expanded,
774 gross 1044 the value assigned to \DataSamplePoints with tag \var{tag_name} is replaced by
775 gross 1045 \var{value}. If no tag is assigned tag name \var{tag_name}, no value is set.
776 jgs 82 \end{methoddesc}
777    
778 gross 983 \begin{methoddesc}[Data]{dump}{filename}
779     dumps the \Data object to the file \var{filename}. The file stores the
780 ksteube 1316 function space but not the \Domain. It is in the responsibility of the user to
781 caltinay 3296 save the \Domain.
782 gross 983 \end{methoddesc}
783    
784 gross 593 \begin{methoddesc}[Data]{__str__}{}
785     returns a string representation of the object.
786     \end{methoddesc}
787    
788 jfenwick 1959 \subsection{Functions of \Data objects}
789 gross 593 This section lists the most important functions for \Data class objects \var{a}.
790 jfenwick 1959 A complete list and a more detailed description of the functionality can be found on \ReferenceGuide.
791 gross 599 \begin{funcdesc}{saveVTK}{filename,**kwdata}
792 caltinay 3296 writes \Data defined by keywords in the file with \var{filename} using the
793 gross 599 vtk file format \VTK file format. The key word is used as an identifier. The statement
794     \begin{python}
795 ksteube 1318 saveVTK("out.xml",temperature=T,velocity=v)
796 caltinay 3296 \end{python}
797     will write the scalar \var{T} as \var{temperature} and the vector \var{v} as \var{velocity} into the
798 gross 599 file \file{out.xml}. Restrictions on the allowed combinations of \FunctionSpace apply.
799 gross 593 \end{funcdesc}
800 gross 599 \begin{funcdesc}{saveDX}{filename,**kwdata}
801 caltinay 3296 writes \Data defined by keywords in the file with \var{filename} using the
802 gross 599 vtk file format \OpenDX file format. The key word is used as an identifier. The statement
803     \begin{python}
804 ksteube 1318 saveDX("out.dx",temperature=T,velocity=v)
805 caltinay 3296 \end{python}
806     will write the scalar \var{T} as \var{temperature} and the vector \var{v} as \var{velocity} into the
807 gross 599 file \file{out.dx}. Restrictions on the allowed combinations of \FunctionSpace apply.
808 gross 593 \end{funcdesc}
809     \begin{funcdesc}{kronecker}{d}
810 gross 599 returns a \RankTwo \Data object in \FunctionSpace \var{d} such that
811 gross 593 \begin{equation}
812 caltinay 3296 \code{kronecker(d)}\left[ i,j\right] = \left\{
813 gross 593 \begin{array}{cc}
814     1 & \mbox{ if } i=j \\
815     0 & \mbox{ otherwise }
816     \end{array}
817     \right.
818     \end{equation}
819 gross 2484 If \var{d} is an integer a $(d,d)$ \numpy array is returned.
820 gross 593 \end{funcdesc}
821     \begin{funcdesc}{identityTensor}{d}
822 jfenwick 1959 is a synonym for \code{kronecker} (see above).
823     % returns a \RankTwo \Data object in \FunctionSpace \var{d} such that
824     % \begin{equation}
825 caltinay 3296 % \code{identityTensor(d)}\left[ i,j\right] = \left\{
826 jfenwick 1959 % \begin{array}{cc}
827     % 1 & \mbox{ if } i=j \\
828     % 0 & \mbox{ otherwise }
829     % \end{array}
830     % \right.
831     % \end{equation}
832 gross 2484 % If \var{d} is an integer a $(d,d)$ \numpy array is returned.
833 gross 593 \end{funcdesc}
834     \begin{funcdesc}{identityTensor4}{d}
835 gross 599 returns a \RankFour \Data object in \FunctionSpace \var{d} such that
836     \begin{equation}
837 caltinay 3296 \code{identityTensor(d)}\left[ i,j,k,l\right] = \left\{
838 gross 599 \begin{array}{cc}
839     1 & \mbox{ if } i=k \mbox{ and } j=l\\
840     0 & \mbox{ otherwise }
841     \end{array}
842     \right.
843     \end{equation}
844 gross 2484 If \var{d} is an integer a $(d,d,d,d)$ \numpy array is returned.
845 gross 593 \end{funcdesc}
846     \begin{funcdesc}{unitVector}{i,d}
847 gross 599 returns a \RankOne \Data object in \FunctionSpace \var{d} such that
848     \begin{equation}
849 caltinay 3296 \code{identityTensor(d)}\left[ j \right] = \left\{
850 gross 599 \begin{array}{cc}
851     1 & \mbox{ if } j=i\\
852     0 & \mbox{ otherwise }
853     \end{array}
854     \right.
855     \end{equation}
856 gross 2484 If \var{d} is an integer a $(d,)$ \numpy array is returned.
857 gross 599
858 gross 593 \end{funcdesc}
859    
860     \begin{funcdesc}{Lsup}{a}
861     returns the $L^{sup}$ norm of \var{arg}. This is the maximum of the absolute values
862 caltinay 3296 over all components and all \DataSamplePoints of \var{a}.
863 gross 593 \end{funcdesc}
864    
865     \begin{funcdesc}{sup}{a}
866     returns the maximum value over all components and all \DataSamplePoints of \var{a}.
867     \end{funcdesc}
868    
869     \begin{funcdesc}{inf}{a}
870     returns the minimum value over all components and all \DataSamplePoints of \var{a}
871     \end{funcdesc}
872    
873    
874    
875     \begin{funcdesc}{minval}{a}
876 ksteube 1316 returns at each \DataSamplePoints the minimum value over all components.
877 gross 593 \end{funcdesc}
878 gross 599
879 gross 593 \begin{funcdesc}{maxval}{a}
880 gross 599 returns at each \DataSamplePoints the maximum value over all components.
881 gross 593 \end{funcdesc}
882 gross 599
883 gross 593 \begin{funcdesc}{length}{a}
884 jfenwick 1959 returns at Euclidean norm at each \DataSamplePoints. For a \RankFour \var{a} this is
885 gross 599 \begin{equation}
886 caltinay 3296 \code{length(a)}=\sqrt{\sum_{ijkl} \var{a} \left[i,j,k,l\right]^2}
887     \end{equation}
888 gross 593 \end{funcdesc}
889 gross 599 \begin{funcdesc}{trace}{a\optional{,axis_offset=0}}
890     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
891 caltinay 3296 case of a \RankTwo function and this is
892 gross 599 \begin{equation}
893 caltinay 3296 \code{trace(a)}=\sum_{i} \var{a} \left[i,i\right]
894     \end{equation}
895 gross 599 and for a \RankFour function and \code{axis_offset=1} this is
896     \begin{equation}
897 caltinay 3296 \code{trace(a,1)}\left[i,j\right]=\sum_{k} \var{a} \left[i,k,k,j\right]
898     \end{equation}
899 gross 593 \end{funcdesc}
900 gross 804
901 gross 599 \begin{funcdesc}{transpose}{a\optional{, axis_offset=None}}
902     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
903 caltinay 3296 present \code{int(r/2)} is used where \var{r} is the rank of \var{a}.
904 gross 599 the sum over components \var{axis_offset} and \var{axis_offset+1} with the same index. For instance in the
905 caltinay 3296 case of a \RankTwo function and this is
906 gross 599 \begin{equation}
907     \code{transpose(a)}\left[i,j\right]=\var{a} \left[j,i\right]
908 caltinay 3296 \end{equation}
909 gross 599 and for a \RankFour function and \code{axis_offset=1} this is
910     \begin{equation}
911     \code{transpose(a,1)}\left[i,j,k,l\right]=\var{a} \left[j,k,l,i\right]
912 caltinay 3296 \end{equation}
913 gross 593 \end{funcdesc}
914 gross 804
915     \begin{funcdesc}{swap_axes}{a\optional{, axis0=0 \optional{, axis1=1 }}}
916 ksteube 1316 returns \var{a} but with swapped components \var{axis0} and \var{axis1}. The argument \var{a} must be
917 caltinay 3296 at least of \RankTwo. For instance in the
918 gross 804 for a \RankFour argument, \code{axis0=1} and \code{axis1=2} this is
919     \begin{equation}
920     \code{swap_axes(a,1,2)}\left[i,j,k,l\right]=\var{a} \left[i,k,j,l\right]
921 caltinay 3296 \end{equation}
922 gross 804 \end{funcdesc}
923    
924 gross 593 \begin{funcdesc}{symmetric}{a}
925 gross 599 returns the symmetric part of \var{a}. This is \code{(a+transpose(a))/2}.
926 gross 593 \end{funcdesc}
927     \begin{funcdesc}{nonsymmetric}{a}
928 gross 599 returns the non--symmetric part of \var{a}. This is \code{(a-transpose(a))/2}.
929 gross 593 \end{funcdesc}
930     \begin{funcdesc}{inverse}{a}
931 caltinay 3296 return the inverse of \var{a}. This is
932 gross 599 \begin{equation}
933 gross 809 \code{matrix_mult(inverse(a),a)=kronecker(d)}
934 caltinay 3296 \end{equation}
935     if \var{a} has shape \code{(d,d)}. The current implementation is restricted to arguments of shape
936 gross 599 \code{(2,2)} and \code{(3,3)}.
937 gross 593 \end{funcdesc}
938     \begin{funcdesc}{eigenvalues}{a}
939 caltinay 3296 return the eigenvalues of \var{a}. This is
940 gross 599 \begin{equation}
941 gross 809 \code{matrix_mult(a,V)=e[i]*V}
942 caltinay 3296 \end{equation}
943     where \code{e=eigenvalues(a)} and \var{V} is suitable non--zero vector \var{V}.
944 gross 599 The eigenvalues are ordered in increasing size.
945 caltinay 3296 The argument \var{a} has to be the symmetric, ie. \code{a=symmetric(a)}.
946     The current implementation is restricted to arguments of shape
947 gross 599 \code{(2,2)} and \code{(3,3)}.
948 gross 593 \end{funcdesc}
949     \begin{funcdesc}{eigenvalues_and_eigenvectors}{a}
950 caltinay 3296 return the eigenvalues and eigenvectors of \var{a}. This is
951 gross 599 \begin{equation}
952 gross 809 \code{matrix_mult(a,V[:,i])=e[i]*V[:,i]}
953 caltinay 3296 \end{equation}
954 gross 599 where \code{e,V=eigenvalues_and_eigenvectors(a)}. The eigenvectors \var{V} are orthogonal and normalized, ie.
955     \begin{equation}
956 gross 809 \code{matrix_mult(transpose(V),V)=kronecker(d)}
957 caltinay 3296 \end{equation}
958 gross 599 if \var{a} has shape \code{(d,d)}. The eigenvalues are ordered in increasing size.
959 caltinay 3296 The argument \var{a} has to be the symmetric, ie. \code{a=symmetric(a)}.
960     The current implementation is restricted to arguments of shape
961 gross 599 \code{(2,2)} and \code{(3,3)}.
962 gross 593 \end{funcdesc}
963 gross 599 \begin{funcdesc}{maximum}{*a}
964     returns the maximum value over all arguments at all \DataSamplePoints and for each component.
965 caltinay 3296 For instance
966 gross 599 \begin{equation}
967     \code{maximum(a0,a1)}\left[i,j\right]=max(\var{a0} \left[i,j\right],\var{a1} \left[i,j\right])
968     \end{equation}
969     at all \DataSamplePoints.
970 gross 593 \end{funcdesc}
971 gross 599 \begin{funcdesc}{minimum}{*a}
972     returns the minimum value over all arguments at all \DataSamplePoints and for each component.
973 caltinay 3296 For instance
974 gross 599 \begin{equation}
975     \code{minimum(a0,a1)}\left[i,j\right]=min(\var{a0} \left[i,j\right],\var{a1} \left[i,j\right])
976     \end{equation}
977     at all \DataSamplePoints.
978 gross 593 \end{funcdesc}
979 gross 599
980     \begin{funcdesc}{clip}{a\optional{, minval=0.}\optional{, maxval=1.}}
981 caltinay 3296 cuts back \var{a} into the range between \var{minval} and \var{maxval}. A value in the returned object equals
982     \var{minval} if the corresponding value of \var{a} is less than \var{minval}, equals \var{maxval} if the
983 gross 599 corresponding value of \var{a} is greater than \var{maxval}
984     or corresponding value of \var{a} otherwise.
985 gross 593 \end{funcdesc}
986     \begin{funcdesc}{inner}{a0,a1}
987 gross 599 returns the inner product of \var{a0} and \var{a1}. For instance in the
988 caltinay 3296 case of \RankTwo arguments and this is
989 gross 599 \begin{equation}
990 caltinay 3296 \code{inner(a)}=\sum_{ij}\var{a0} \left[j,i\right] \cdot \var{a1} \left[j,i\right]
991     \end{equation}
992 gross 599 and for a \RankFour arguments this is
993     \begin{equation}
994 caltinay 3296 \code{inner(a)}=\sum_{ijkl}\var{a0} \left[i,j,k,l\right] \cdot \var{a1} \left[j,i,k,l\right]
995     \end{equation}
996 gross 593 \end{funcdesc}
997 gross 809
998     \begin{funcdesc}{matrix_mult}{a0,a1}
999 gross 599 returns the matrix product of \var{a0} and \var{a1}. If \var{a1} is \RankOne this is
1000     \begin{equation}
1001 caltinay 3296 \code{matrix_mult(a)}\left[i\right]=\sum_{k}\var{a0} \cdot \left[i,k\right]\var{a1} \left[k\right]
1002     \end{equation}
1003 gross 599 and if \var{a1} is \RankTwo this is
1004     \begin{equation}
1005 caltinay 3296 \code{matrix_mult(a)}\left[i,j\right]=\sum_{k}\var{a0} \cdot \left[i,k\right]\var{a1} \left[k,j\right]
1006     \end{equation}
1007 gross 593 \end{funcdesc}
1008 gross 809
1009     \begin{funcdesc}{transposed_matrix_mult}{a0,a1}
1010 caltinay 3296 returns the matrix product of the transposed of \var{a0} and \var{a1}. The function is equivalent to
1011 gross 809 \code{matrix_mult(transpose(a0),a1)}.
1012     If \var{a1} is \RankOne this is
1013     \begin{equation}
1014 caltinay 3296 \code{transposed_matrix_mult(a)}\left[i\right]=\sum_{k}\var{a0} \cdot \left[k,i\right]\var{a1} \left[k\right]
1015     \end{equation}
1016 gross 809 and if \var{a1} is \RankTwo this is
1017     \begin{equation}
1018 caltinay 3296 \code{transposed_matrix_mult(a)}\left[i,j\right]=\sum_{k}\var{a0} \cdot \left[k,i\right]\var{a1} \left[k,j\right]
1019     \end{equation}
1020 gross 809 \end{funcdesc}
1021    
1022     \begin{funcdesc}{matrix_transposed_mult}{a0,a1}
1023     returns the matrix product of \var{a0} and the transposed of \var{a1}.
1024     The function is equivalent to
1025 caltinay 3296 \code{matrix_mult(a0,transpose(a1))}.
1026 gross 809 If \var{a1} is \RankTwo this is
1027     \begin{equation}
1028 caltinay 3296 \code{matrix_transposed_mult(a)}\left[i,j\right]=\sum_{k}\var{a0} \cdot \left[i,k\right]\var{a1} \left[j,k\right]
1029     \end{equation}
1030 gross 809 \end{funcdesc}
1031    
1032 gross 593 \begin{funcdesc}{outer}{a0,a1}
1033 gross 599 returns the outer product of \var{a0} and \var{a1}. For instance if \var{a0} and \var{a1} both are \RankOne then
1034     \begin{equation}
1035     \code{outer(a)}\left[i,j\right]=\var{a0} \left[i\right] \cdot \var{a1}\left[j\right]
1036 caltinay 3296 \end{equation}
1037 gross 599 and if \var{a0} is \RankOne and \var{a1} is \RankThree
1038     \begin{equation}
1039     \code{outer(a)}\left[i,j,k\right]=\var{a0} \left[i\right] \cdot \var{a1}\left[j,k\right]
1040 caltinay 3296 \end{equation}
1041 gross 593 \end{funcdesc}
1042 gross 809
1043     \begin{funcdesc}{tensor_mult}{a0,a1}
1044 gross 599 returns the tensor product of \var{a0} and \var{a1}. If \var{a1} is \RankTwo this is
1045     \begin{equation}
1046 caltinay 3296 \code{tensor_mult(a)}\left[i,j\right]=\sum_{kl}\var{a0}\left[i,j,k,l\right] \cdot \var{a1} \left[k,l\right]
1047     \end{equation}
1048 gross 599 and if \var{a1} is \RankFour this is
1049     \begin{equation}
1050 caltinay 3296 \code{tensor_mult(a)}\left[i,j,k,l\right]=\sum_{mn}\var{a0} \left[i,j,m,n\right] \cdot \var{a1} \left[m,n,k,l\right]
1051     \end{equation}
1052 gross 593 \end{funcdesc}
1053 gross 809
1054     \begin{funcdesc}{transposed_tensor_mult}{a0,a1}
1055     returns the tensor product of the transposed of \var{a0} and \var{a1}. The function is equivalent to
1056     \code{tensor_mult(transpose(a0),a1)}.
1057     If \var{a1} is \RankTwo this is
1058     \begin{equation}
1059 caltinay 3296 \code{transposed_tensor_mult(a)}\left[i,j\right]=\sum_{kl}\var{a0}\left[k,l,i,j\right] \cdot \var{a1} \left[k,l\right]
1060     \end{equation}
1061 gross 809 and if \var{a1} is \RankFour this is
1062     \begin{equation}
1063 caltinay 3296 \code{transposed_tensor_mult(a)}\left[i,j,k,l\right]=\sum_{mn}\var{a0} \left[m,n,i,j\right] \cdot \var{a1} \left[m,n,k,l\right]
1064     \end{equation}
1065 gross 809 \end{funcdesc}
1066    
1067     \begin{funcdesc}{tensor_transposed_mult}{a0,a1}
1068 caltinay 3296 returns the tensor product of \var{a0} and the transposed of \var{a1}.
1069 gross 809 The function is equivalent to
1070     \code{tensor_mult(a0,transpose(a1))}.
1071     If \var{a1} is \RankTwo this is
1072     \begin{equation}
1073 caltinay 3296 \code{tensor_transposed_mult(a)}\left[i,j\right]=\sum_{kl}\var{a0}\left[i,j,k,l\right] \cdot \var{a1} \left[l,k\right]
1074     \end{equation}
1075 gross 809 and if \var{a1} is \RankFour this is
1076     \begin{equation}
1077 caltinay 3296 \code{tensor_transposed_mult(a)}\left[i,j,k,l\right]=\sum_{mn}\var{a0} \left[i,j,m,n\right] \cdot \var{a1} \left[k,l,m,n\right]
1078     \end{equation}
1079 gross 809 \end{funcdesc}
1080    
1081 gross 599 \begin{funcdesc}{grad}{a\optional{, where=None}}
1082 caltinay 3296 returns the gradient of \var{a}. If \var{where} is present the gradient will be calculated in \FunctionSpace \var{where} otherwise a
1083 gross 599 default \FunctionSpace is used. In case that \var{a} has \RankTwo one has
1084     \begin{equation}
1085 caltinay 3296 \code{grad(a)}\left[i,j,k\right]=\frac{\partial \var{a} \left[i,j\right]}{\partial x_{k}}
1086     \end{equation}
1087 gross 593 \end{funcdesc}
1088 gross 599 \begin{funcdesc}{integrate}{a\optional{ ,where=None}}
1089 caltinay 3296 returns the integral of \var{a} where the domain of integration is defined by the \FunctionSpace of \var{a}. If \var{where} is
1090     present the argument is interpolated into \FunctionSpace \var{where} before integration. For instance in the case of
1091 gross 599 a \RankTwo argument in \ContinuousFunction it is
1092     \begin{equation}
1093 caltinay 3296 \code{integrate(a)}\left[i,j\right]=\int_{\Omega}\var{a} \left[i,j\right] \; d\Omega
1094     \end{equation}
1095     where $\Omega$ is the spatial domain and $d\Omega$ volume integration. To integrate over the boundary of the domain one uses
1096 gross 599 \begin{equation}
1097 caltinay 3296 \code{integrate(a,where=FunctionOnBoundary(a.getDomain))}\left[i,j\right]=\int_{\partial \Omega} a\left[i,j\right] \; ds
1098     \end{equation}
1099 gross 599 where $\partial \Omega$ is the surface of the spatial domain and $ds$ area or line integration.
1100 gross 593 \end{funcdesc}
1101     \begin{funcdesc}{interpolate}{a,where}
1102 caltinay 3296 interpolates argument \var{a} into the \FunctionSpace \var{where}.
1103 gross 593 \end{funcdesc}
1104 gross 599 \begin{funcdesc}{div}{a\optional{ ,where=None}}
1105 caltinay 3296 returns the divergence of \var{a}. This
1106 gross 599 \begin{equation}
1107     \code{div(a)}=trace(grad(a),where)
1108     \end{equation}
1109 gross 593 \end{funcdesc}
1110 gross 599 \begin{funcdesc}{jump}{a\optional{ ,domain=None}}
1111     returns the jump of \var{a} over the discontinuity in its domain or if \Domain \var{domain} is present
1112     in \var{domain}.
1113     \begin{equation}
1114 gross 809 \begin{array}{rcl}
1115     \code{jump(a)}& = &\code{interpolate(a,FunctionOnContactOne(domain))} \\
1116     & & \hfill - \code{interpolate(a,FunctionOnContactZero(domain))}
1117     \end{array}
1118 gross 599 \end{equation}
1119 gross 593 \end{funcdesc}
1120     \begin{funcdesc}{L2}{a}
1121 caltinay 3296 returns the $L^2$-norm of \var{a} in its function space. This is
1122 gross 599 \begin{equation}
1123 gross 809 \code{L2(a)=integrate(length(a)}^2\code{)} \; .
1124 caltinay 3296 \end{equation}
1125 gross 593 \end{funcdesc}
1126    
1127 jfenwick 1966 The following functions operate ``point-wise''. That is, the operation is applied to each component of each point
1128     individually.
1129    
1130     \begin{funcdesc}{sin}{a}
1131     applies sine function to \var{a}.
1132     \end{funcdesc}
1133    
1134     \begin{funcdesc}{cos}{a}
1135     applies cosine function to \var{a}.
1136     \end{funcdesc}
1137    
1138     \begin{funcdesc}{tan}{a}
1139     applies tangent function to \var{a}.
1140     \end{funcdesc}
1141    
1142     \begin{funcdesc}{asin}{a}
1143     applies arc (inverse) sine function to \var{a}.
1144     \end{funcdesc}
1145    
1146     \begin{funcdesc}{acos}{a}
1147     applies arc (inverse) cosine function to \var{a}.
1148     \end{funcdesc}
1149    
1150     \begin{funcdesc}{atan}{a}
1151     applies arc (inverse) tangent function to \var{a}.
1152     \end{funcdesc}
1153    
1154     \begin{funcdesc}{sinh}{a}
1155     applies hyperbolic sine function to \var{a}.
1156     \end{funcdesc}
1157    
1158     \begin{funcdesc}{cosh}{a}
1159     applies hyperbolic cosine function to \var{a}.
1160     \end{funcdesc}
1161    
1162     \begin{funcdesc}{tanh}{a}
1163     applies hyperbolic tangent function to \var{a}.
1164     \end{funcdesc}
1165    
1166     \begin{funcdesc}{asinh}{a}
1167     applies arc (inverse) hyperbolic sine function to \var{a}.
1168     \end{funcdesc}
1169    
1170     \begin{funcdesc}{acosh}{a}
1171     applies arc (inverse) hyperbolic cosine function to \var{a}.
1172     \end{funcdesc}
1173    
1174     \begin{funcdesc}{atanh}{a}
1175     applies arc (inverse) hyperbolic tangent function to \var{a}.
1176     \end{funcdesc}
1177    
1178     \begin{funcdesc}{exp}{a}
1179     applies exponential function to \var{a}.
1180     \end{funcdesc}
1181    
1182     \begin{funcdesc}{sqrt}{a}
1183     applies square root function to \var{a}.
1184     \end{funcdesc}
1185    
1186     \begin{funcdesc}{log}{a}
1187     applies the natural logarithm to \var{a}.
1188     \end{funcdesc}
1189    
1190     \begin{funcdesc}{log10}{a}
1191     applies the base-$10$ logarithm to \var{a}.
1192     \end{funcdesc}
1193    
1194     \begin{funcdesc}{sign}{a}
1195     applies the sign function to \var{a}, that is $1$ where \var{a} is positive,
1196     $-1$ where \var{a} is negative and $0$ otherwise.
1197     \end{funcdesc}
1198    
1199     \begin{funcdesc}{wherePositive}{a}
1200     returns a function which is $1$ where \var{a} is positive and $0$ otherwise.
1201     \end{funcdesc}
1202    
1203     \begin{funcdesc}{whereNegative}{a}
1204     returns a function which is $1$ where \var{a} is negative and $0$ otherwise.
1205     \end{funcdesc}
1206    
1207     \begin{funcdesc}{whereNonNegative}{a}
1208     returns a function which is $1$ where \var{a} is non--negative and $0$ otherwise.
1209     \end{funcdesc}
1210    
1211     \begin{funcdesc}{whereNonPositive}{a}
1212     returns a function which is $1$ where \var{a} is non--positive and $0$ otherwise.
1213     \end{funcdesc}
1214    
1215 gross 2304 \begin{funcdesc}{whereZero}{a\optional{, tol=None, \optional{, rtol=1.e-8}}}
1216     returns a function which is $1$ where \var{a} equals zero with tolerance \var{tol} and $0$ otherwise. If \var{tol} is not present, the absolute maximum value of C{a} times C{rtol} is used.
1217 jfenwick 1966 \end{funcdesc}
1218    
1219 gross 2304 \begin{funcdesc}{whereNonZero}{a, \optional{, tol=None, \optional{, rtol=1.e-8}}}
1220     returns a function which is $1$ where \var{a} different from zero with tolerance \var{tol} and $0$ otherwise. If \var{tol} is not present, the absolute maximum value of C{a} times C{rtol} is used.
1221 jfenwick 1966 \end{funcdesc}
1222    
1223 jfenwick 2646 \subsection{Interpolating Data}
1224     \index{interpolateTable}
1225     In some cases, it may be useful to produce Data objects which fit some user defined function.
1226 caltinay 3296 Manually modifying each value in the Data object is not a good idea since it depends on
1227 jfenwick 2646 knowing the location and order of each datapoint in the domain.
1228     Instead \escript can use an interpolation table to produce a Data object.
1229    
1230 gross 2668 The following example is available as \file{int_save.py} in the examples directory.
1231 jfenwick 2646 We will produce a \Data object which aproximates a sine curve.
1232    
1233     \begin{python}
1234     from esys.escript import saveDataCSV, sup
1235     import numpy
1236     from esys.finley import Rectangle
1237    
1238 gross 2668 n=4
1239 jfenwick 2646 r=Rectangle(n,n)
1240     x=r.getX()
1241     x0=x[0]
1242     x1=x[1] #we'll use this later
1243     toobig=100
1244     \end{python}
1245    
1246     First we produce an interpolation table.
1247     \begin{python}
1248 caltinay 3296 sine_table=[0, 0.70710678118654746, 1, 0.70710678118654746, 0,
1249 jfenwick 2677 -0.70710678118654746, -1, -0.70710678118654746, 0]
1250 jfenwick 2646 \end{python}
1251    
1252     We wish to identify $0$ and $1$ with the ends of the curve.
1253 caltinay 3296 That is, with the first and eighth values in the table.
1254 jfenwick 2646
1255     \begin{python}
1256     numslices=len(sine_table)-1
1257    
1258     minval=0
1259 jfenwick 2677 maxval=1
1260 jfenwick 2646
1261     step=sup(maxval-minval)/numslices
1262     \end{python}
1263    
1264     So the values $v$ from the input lie in the interval minval$\leq v < $maxval.
1265     \var{step} represents the gap (in the input range) between entries in the table.
1266 gross 2668 By default values of $v$ outside the table argument range (minval, maxval) will
1267     be pushed back into the range, ie. if $v <$ minval the value minval will be used to
1268 gross 2864 evaluate the table. Similarly, for values $v>$ maxval the value maxval is used.
1269 gross 2668
1270 jfenwick 2646 Now we produce our new \Data object.
1271    
1272     \begin{python}
1273     result=x0.interpolateTable(sine_table, minval, step, toobig)
1274     \end{python}
1275 caltinay 3296 Any values which interpolate to larger than \var{toobig} will raise an exception. You can
1276 gross 2668 switch on boundary checking by adding ''check_boundaries=True`` the argument list.
1277 jfenwick 2646
1278 gross 2668
1279 jfenwick 2646 Now for a 2D example.
1280     We will interpolate a surface such that the bottom edge is the sine curve described above.
1281     The amplitude of the curve decreases as we move towards the top edge.
1282    
1283     Our interpolation table will have three rows.
1284     \begin{python}
1285     st=numpy.array(sine_table)
1286    
1287     table=[st, 0.5*st, 0*st ]
1288     \end{python}
1289    
1290     The use of numpy and multiplication here is just to save typing.
1291    
1292     \begin{python}
1293     result2=x1.interpolateTable(table, 0, 0.55, x0, minval, step, toobig)
1294     \end{python}
1295    
1296 caltinay 3296 In the 2D case, the parameters for the x1 direction (min=0, step=0.55) come first followed by the x0 data object and
1297 gross 2864 its parameters.
1298 jfenwick 2677 By default, if a point is specified which is outside the boundary, then \var{interpolateTable} will operate
1299     as if the point was on the boundary.
1300     Passing \var{check_boundaries}=\var{True} will \var{interpolateTable} to reject any points outside the boundaries.
1301 jfenwick 2646
1302     \subsection{Saving Data as CSV}
1303     \index{saveDataCSV}
1304     \index{CSV}
1305     For simple post-processing, \Data objects can be saved in comma separated value format.
1306    
1307     If \var{mydata1} and \var{mydata2} are scalar data, the following command:
1308     \begin{python}
1309     saveDataCSV('output.csv',U=mydata1, V=mydata2)
1310     \end{python}
1311     will record the values of mydata in \texttt{output.csv} in the following format:
1312     \begin{verbatim}
1313     U, V
1314     1.0000000e+0, 2.0000000e-1
1315     5.0000000e-0, 1.0000000e+1
1316     ...
1317     \end{verbatim}
1318    
1319 gross 2864 The names of the keyword parameters form the names of columns in the output.
1320 jfenwick 2646 If the data objects are over different function spaces, then saveDataCSV will attempt to
1321     interpolate to a common function space.
1322     If this is not possible, then an exception will be raised.
1323    
1324     Output can be restricted using a scalar mask.
1325     \begin{python}
1326     saveDataCSV('outfile.csv', U=mydata1, V=mydata2, mask=myscalar)
1327     \end{python}
1328     Will only output those rows which correspond to to positive values of \var{myscalar}.
1329 gross 2864 Some aspects of the output can be tuned using additional parameters.
1330 jfenwick 2646 \begin{python}
1331     saveDataCSV('data.csv', append=True, sep=' ', csep='/', mask=mymask, e=mat1)
1332     \end{python}
1333    
1334     \begin{itemize}
1335     \item \var{append} - specifies that the output should be written to the end of an existing file.
1336     \item \var{sep} - defines the separator between fields.
1337 caltinay 3296 \item \var{csep} - defines the separator between components in the header line. For example between the components of a matrix.
1338 jfenwick 2646 \end{itemize}
1339    
1340     The above command would produce output like this:
1341     \begin{verbatim}
1342     e/0/0 e/1/0 e/0/1 e/1/1
1343     1.0000000000e+00 2.0000000000e+00 3.0000000000e+00 4.0000000000e+00
1344 caltinay 3296 ...
1345 jfenwick 2646 \end{verbatim}
1346    
1347 jfenwick 2766 Note that while the order in which rows are output can vary, all the elements in a given row
1348     always correspond to the same input.
1349 jfenwick 2646
1350    
1351 caltinay 3296 \subsection{The \Operator Class}
1352 jgs 102 The \Operator class provides an abstract access to operators build
1353 caltinay 3296 within the \LinearPDE class. \Operator objects are created
1354 jgs 102 when a PDE is handed over to a PDE solver library and handled
1355 jfenwick 1959 by the \LinearPDE object defining the PDE. The user can gain access
1356 jgs 102 to the \Operator of a \LinearPDE object through the \var{getOperator}
1357     method.
1358    
1359     \begin{classdesc}{Operator}{}
1360     creates an empty \Operator object.
1361     \end{classdesc}
1362    
1363     \begin{methoddesc}[Operator]{isEmpty}{fileName}
1364     returns \True is the object is empty. Otherwise \True is returned.
1365 jgs 82 \end{methoddesc}
1366    
1367 jgs 102 \begin{methoddesc}[Operator]{setValue}{value}
1368 ksteube 1316 resets all entries in the object representation to \var{value}
1369 jgs 82 \end{methoddesc}
1370    
1371 jgs 102 \begin{methoddesc}[Operator]{solves}{rhs}
1372     solves the operator equation with right hand side \var{rhs}
1373 jgs 82 \end{methoddesc}
1374    
1375 jgs 102 \begin{methoddesc}[Operator]{of}{u}
1376     applies the operator to the \Data object \var{u}
1377 jgs 82 \end{methoddesc}
1378    
1379 jgs 102 \begin{methoddesc}[Operator]{saveMM}{fileName}
1380 jgs 82 saves the object to a matrix market format file of name
1381     \var{fileName}, see
1382 jfenwick 2335 \url{http://maths.nist.gov/MatrixMarket}
1383     % \ulink{maths.nist.gov/MatrixMarket}{\url{http://maths.nist.gov/MatrixMarket}}.
1384 jgs 82 \index{Matrix Market}
1385     \end{methoddesc}
1386    
1387 gross 2404 \section{Physical Units}
1388     \escript provides support for physical units in the SI system \index{SI units} including unit conversion. So the
1389     user can define variables in the form
1390     \begin{python}
1391     from esys.escript.unitsSI import *
1392     l=20*m
1393     w=30*kg
1394     w2=40*lb
1395     T=100*Celsius
1396     \end{python}
1397 caltinay 3296 In the two latter cases an conversion from pounds\index{pounds} and degree Celsius\index{Celsius} is performed into the appropriate SI units kg and Kelvin is performed. In addition
1398 gross 2404 composed units can be used, for instance
1399     \begin{python}
1400     from esys.escript.unitsSI import *
1401     rho=40*lb/cm**3
1402     \end{python}
1403 caltinay 3296 to define the density in the units of pounds per cubic centimeter. The value $40$ will be converted
1404 gross 2404 into SI units, in this case kg per cubic meter.
1405     Moreover unit prefixes are supported:
1406     \begin{python}
1407     from esys.escript.unitsSI import *
1408     p=40*Mega*Pa
1409     \end{python}
1410     to the the pressure to 40 Mega Pascal. Units can also be converted back from the SI system into
1411     a desired unit, e.g
1412     \begin{python}
1413     from esys.escript.unitsSI import *
1414     print p/atm
1415     \end{python}
1416 caltinay 3296 can be used print the pressure in units of atmosphere\index{atmosphere}.
1417 gross 2404
1418     This is an incomplete list of supported physical units:
1419    
1420     \begin{datadesc}{km}
1421     unit of kilo meter
1422     \end{datadesc}
1423    
1424     \begin{datadesc}{m}
1425     unit of meter
1426     \end{datadesc}
1427    
1428     \begin{datadesc}{cm}
1429     unit of centi meter
1430     \end{datadesc}
1431    
1432     \begin{datadesc}{mm}
1433     unit of milli meter
1434     \end{datadesc}
1435    
1436     \begin{datadesc}{sec}
1437     unit of second
1438     \end{datadesc}
1439    
1440     \begin{datadesc}{minute}
1441     unit of minute
1442     \end{datadesc}
1443    
1444     \begin{datadesc}{h}
1445 caltinay 3296 unit of hour
1446 gross 2404 \end{datadesc}
1447     \begin{datadesc}{day}
1448 caltinay 3296 unit of day
1449 gross 2404 \end{datadesc}
1450     \begin{datadesc}{yr}
1451     unit of year
1452     \end{datadesc}
1453    
1454     \begin{datadesc}{gram}
1455     unit of gram
1456     \end{datadesc}
1457     \begin{datadesc}{kg}
1458     unit of kilo gram
1459     \end{datadesc}
1460     \begin{datadesc}{lb}
1461 caltinay 3296 unit of pound
1462 gross 2404 \end{datadesc}
1463     \begin{datadesc}{ton}
1464     metric ton
1465     \end{datadesc}
1466    
1467     \begin{datadesc}{A}
1468     unit of Ampere
1469     \end{datadesc}
1470    
1471     \begin{datadesc}{Hz}
1472     unit of Hertz
1473     \end{datadesc}
1474    
1475     \begin{datadesc}{N}
1476     unit of Newton
1477     \end{datadesc}
1478     \begin{datadesc}{Pa}
1479 caltinay 3296 unit of Pascal
1480 gross 2404 \end{datadesc}
1481     \begin{datadesc}{atm}
1482 caltinay 3296 unit of atmosphere
1483 gross 2404 \end{datadesc}
1484     \begin{datadesc}{J}
1485 caltinay 3296 unit of Joule
1486 gross 2404 \end{datadesc}
1487    
1488     \begin{datadesc}{W}
1489 caltinay 3296 unit of Watt
1490 gross 2404 \end{datadesc}
1491    
1492     \begin{datadesc}{C}
1493 caltinay 3296 unit of Coulomb
1494 gross 2404 \end{datadesc}
1495     \begin{datadesc}{V}
1496 caltinay 3296 unit of Volt
1497 gross 2404 \end{datadesc}
1498     \begin{datadesc}{F}
1499 caltinay 3296 unit of Farad
1500 gross 2404 \end{datadesc}
1501    
1502     \begin{datadesc}{Ohm}
1503     unit of Ohm
1504     \end{datadesc}
1505     \begin{datadesc}{K}
1506 caltinay 3296 unit of Kelvin
1507 gross 2404 \end{datadesc}
1508     \begin{datadesc}{Celsius}
1509     unit of Celsius
1510     \end{datadesc}
1511    
1512     \begin{datadesc}{Fahrenheit}
1513 caltinay 3296 unit of Fahrenheit
1514 gross 2404 \end{datadesc}
1515    
1516     Moreover unit prefixes are supported:
1517    
1518     \begin{datadesc}{Yotta}
1519     prefix yotta = $10^{24}$.
1520 caltinay 3296
1521 gross 2404 \end{datadesc}
1522    
1523     \begin{datadesc}{Zetta}
1524     prefix zetta= $10^{21}$.
1525     \end{datadesc}
1526    
1527     \begin{datadesc}{Exa}
1528     prefix exa= $10^{18}$.
1529     \end{datadesc}
1530    
1531     \begin{datadesc}{Peta}
1532     prefix peta= $10^{15}$.
1533     \end{datadesc}
1534    
1535     \begin{datadesc}{Tera}
1536     prefix tera= $10^{12}$.
1537     \end{datadesc}
1538    
1539     \begin{datadesc}{Giga}
1540     prefix giga= $10^9$.
1541     \end{datadesc}
1542    
1543     \begin{datadesc}{Mega}
1544     prefix mega= $10^6$.
1545     \end{datadesc}
1546    
1547     \begin{datadesc}{Kilo}
1548     prefix kilo= $10^3$.
1549     \end{datadesc}
1550    
1551     \begin{datadesc}{Hecto}
1552     prefix hecto= $10^2$.
1553     \end{datadesc}
1554    
1555     \begin{datadesc}{Deca}
1556     prefix deca= $10^1$.
1557     \end{datadesc}
1558    
1559     \begin{datadesc}{Deci}
1560     prefix deci= $10^{-1}$.
1561     \end{datadesc}
1562    
1563     \begin{datadesc}{Centi}
1564 caltinay 3296 prefix centi= $10^{-2}$.
1565 gross 2404 \end{datadesc}
1566    
1567     \begin{datadesc}{Milli}
1568     prefix milli= $10^{-3}$.
1569     \end{datadesc}
1570    
1571     \begin{datadesc}{Micro}
1572     prefix micro= $10^{-6}$.
1573     \end{datadesc}
1574    
1575     \begin{datadesc}{Nano}
1576     prefix nano= $10^{-9}$.
1577     \end{datadesc}
1578    
1579     \begin{datadesc}{Pico}
1580     prefix pico= $10^{-12}$.
1581     \end{datadesc}
1582    
1583     \begin{datadesc}{Femto}
1584     prefix femto= $10^{-15}$.
1585     \end{datadesc}
1586    
1587     \begin{datadesc}{Atto}
1588     prefix atto= $10^{-18}$.
1589     \end{datadesc}
1590    
1591     \begin{datadesc}{Zepto}
1592     prefix zepto= $10^{-21}$.
1593     \end{datadesc}
1594    
1595     \begin{datadesc}{Yocto}
1596     prefix yocto= $10^{-24}$.
1597     \end{datadesc}
1598    
1599    
1600 gross 2318 \section{Utilities}
1601 gross 2420
1602 caltinay 3296 The \class{FileWriter} provides a mechanism to write data to a file.
1603     In essence, this class wraps the standard \class{file} class to write data
1604     that are global in MPI to a file. In fact, data are written on the processor
1605     with \MPI rank 0 only. It is recommended to use \class{FileWriter}
1606     rather than \class{open} in order to write code that is running
1607 gross 2420 with and without \MPI. It is save to use \class{open} under MPI to read data which are global under \MPI.
1608    
1609     \begin{classdesc}{FileWriter}{fn\optional{,append=\False, \optional{createLocalFiles=\False}})}
1610     Opens a file of name \var{fn} for writing. If \var{append} is set to \True
1611     written data are append at the end of the file.
1612     If running under \MPI only the first processor with rank==0
1613 caltinay 3296 will open the file and write to it.
1614 gross 2420 If \var{createLocalFiles} is set each individual processor will create a file
1615     where for any processor with rank>0 the file name is extended by its rank. This option is normally used for debug purposes only.
1616     \end{classdesc}
1617    
1618     The following methods are available:
1619     \begin{methoddesc}[FileWriter]{close}{}
1620     closes the file.
1621     \end{methoddesc}
1622     \begin{methoddesc}[FileWriter]{flush}{}
1623     flushes the internal buffer to disk.
1624     \end{methoddesc}
1625     \begin{methoddesc}[FileWriter]{write}{txt}
1626     Write string \var{txt} to file.
1627     Note that newline is not added.
1628     \end{methoddesc}
1629     \begin{methoddesc}[FileWriter]{writelines}{txts}
1630     Write the list \var{txts} of strings to the file..
1631 caltinay 3296 Note that newlines are not added.
1632 gross 2420 This method is equivalent to call write() for each string.
1633     \end{methoddesc}
1634     \begin{memberdesc}[FileWriter]{closed}
1635     \True if file is closed.
1636     \end{memberdesc}
1637     \begin{memberdesc}[FileWriter]{mode}
1638 caltinay 3296 access mode.
1639 gross 2420 \end{memberdesc}
1640     \begin{memberdesc}[FileWriter]{name}
1641     file name.
1642     \end{memberdesc}
1643     \begin{memberdesc}[FileWriter]{newlines}
1644     line separator
1645     \end{memberdesc}
1646    
1647    
1648 gross 2318 \begin{funcdesc}{setEscriptParamInt}{name,value}
1649 jfenwick 2335 assigns the integer value \var{value} to the parameter \var{name}.
1650 caltinay 3296 If \var{name}="TOO_MANY_LINES" conversion of any \Data object to a string switches to a
1651 gross 2318 condensed format if more than \var{value} lines would be created.
1652     \end{funcdesc}
1653    
1654     \begin{funcdesc}{getEscriptParamInt}{name}
1655 caltinay 3296 returns the current value of integer parameter \var{name}.
1656 gross 2318 \end{funcdesc}
1657    
1658     \begin{funcdesc}{listEscriptParams}{a}
1659     returns a list of valid parameters and their description.
1660     \end{funcdesc}
1661    
1662     \begin{funcdesc}{getMPISizeWorld}{}
1663     returns the number of \MPI processors in use in the \env{MPI_COMM_WORLD} processor group.
1664 gross 2420 If \MPI is not used 1 is returned.
1665 gross 2318 \end{funcdesc}
1666     \begin{funcdesc}{getMPIRankWorld}{}
1667     returns the rank of the process within the \env{MPI_COMM_WORLD} processor group.
1668 gross 2420 If \MPI is not used 0 is returned.
1669 gross 2318 \end{funcdesc}
1670     \begin{funcdesc}{MPIBarrierWorld}{}
1671     performs a barrier synchronization across all processors within \env{MPI_COMM_WORLD}
1672     processor group.
1673     \end{funcdesc}
1674     \begin{funcdesc}{getMPIWorldMax}{a}
1675 caltinay 3296 returns the maximum value of the integer \var{a} across all
1676 gross 2318 processors within \env{MPI_COMM_WORLD}.
1677     \end{funcdesc}
1678 gross 2420

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26