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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 82 - (hide annotations)
Tue Oct 26 06:53:54 2004 UTC (14 years, 6 months ago) by jgs
Original Path: trunk/esys2/doc/user/escript.tex
File MIME type: application/x-tex
File size: 22311 byte(s)
Initial revision

1 jgs 82 % $Id$
2    
3     \chapter{The module \escript}
4    
5     \declaremodule{extension}{escript} \modulesynopsis{Handling data on
6     data points like \class{Nodes}, \class{Elements}}
7    
8     The class \Data of the module \escript allows handling
9     data which are hold on data points \index{data points}. Examples for
10     data points are nodes or the quadrature points in elements of a finite
11     element mesh. Another examples a particles or the connection between
12     particles in the case of discrete element methods. Handlers to data
13     points are issued by the structure which contains the data points,
14     e.g. a \finley mesh.
15    
16     The simplest form of data attached to a data point is a single scalar
17     $a$ value which for instance represent the temperature or pressure at
18     this particular data point. Another example is a velocity field. in
19     this case each data point holds a vector $a(0),a(1),a(2)$ representing
20     the velocity at the particular data point. For the case that the
21     values are representing a stress tensor the value is a matrix of the
22     form
23     $a(0,0),a(0,1),a(0,2),a(1,0),a(1,1),a(1,2),a(2,0),a(2,1),a(2,2)$. In
24     general, values hald by data points can have up to four indices. The
25     number of indices is called rank \index{rank}. The tuple of length
26     rank which defines the upper-bound for each index component is called
27     the shape. A stress has rank 2 and the shape is (3,3). For a vector we
28     have rank 1 and shape (3,). A scalar can have rank 0 or rank 1 with
29     shape (1,).
30    
31     In general, the data are stored for each data point. This status of
32     the data is called expanded \index{expanded}. But in some cases, all
33     data points hold the same value. In this case only a single value is
34     stored, which is refered by each data point if needed. This saves
35     memory as well as compute time. In some cases, it is very usefull to
36     have slightly more general way which allows to define piecewise
37     constant data. For this, each data point has to wear a tag which is an
38     integer \index{tag}. The tag is used to distingish between various
39     types of data points. Typical example of the usage of tags is to
40     assign different material parameters to various subdomains. Then one
41     assigns the same tag to all elements in a finite element mesh which
42     lay in the same subdomain. Later each tag can be assigns individual
43     material parameters.
44    
45     The following table shows unitary operations that can be applied to an
46     \Data object \var{arg}:
47     \begin{tableii}{l|l}{textrm}{expression}{Description}
48     \lineii{+\var{arg}} {just \var{arg} \index{+}}
49     \lineii{-\var{arg}} {swapping the sign\index{-}}
50     \lineii{\function{abs}(\var{arg})} {absolute value}
51     \lineii{\function{sin}(\var{arg})} {sine function}
52     \lineii{\function{cos}(\var{arg})} {cosine function}
53     \lineii{\function{exp}(\var{arg})} {exponential function}
54     \lineii{\function{sqrt}(\var{arg})} {square root}
55     \end{tableii}
56     An unitary operation returns a \Data objects of the same shape
57     and defined on the data points like \var{arg}.
58    
59     The following table shows binary operations that can be applied to
60     \Data objects:
61     \begin{tableii}{l|l}{textrm}{expression}{Description}
62     \lineii{\var{arg1}+\var{arg2}} {adds \var{arg1} and \var{arg2} \index{+}}
63     \lineii{\var{arg1}*\var{arg2}} {multiplies \var{arg1} and \var{arg2} \index{*}}
64     \lineii{\var{arg1}-\var{arg2}} {difference \var{arg2} from\var{arg2} \index{-}}
65     \lineii{\var{arg1}/\var{arg2}} {ratio \var{arg1} by \var{arg2} \index{/}}
66     \lineii{\var{arg1}**\var{arg2}} {raises \var{arg1} to the power of \var{arg2} \index{**}}
67     \end{tableii}
68     At least on of the arguments \var{arg1} or \var{arg2} must be a
69     \Data object. One of the arguments may be an object that can be
70     converted into a \Data object. If \var{arg1} or \var{arg2} are
71     defined on different data points it is tried to interpolate \var{arg1}
72     onto the data points of \var{arg2} or to interpolate \var{arg2} onto
73     the data points of \var{arg1}. Boths arguments must have the same
74     shape or one of the arguments my be of rank 0 or shape (1,). In the
75     latter case it is assumed that the particular argument is of the same
76     shape like the other argument but constant over all components.
77    
78     The returned \Data object has the same shape and is defined on
79     the data points like \var{arg1} or \var{arg2}.
80    
81     The following table shows the update operations that can be applied to
82     \Data objects:
83     \begin{tableii}{l|l}{textrm}{expression}{Description}
84     \lineii{\var{arg1}+=\var{arg2}} {adds \var{arg1} to \var{arg2} \index{+}}
85     \lineii{\var{arg1}*=\var{arg2}} {multiplies \var{arg1} with \var{arg2} \index{*}}
86     \lineii{\var{arg1}-=\var{arg2}} {subtracts \var{arg2} from\var{arg2} \index{-}}
87     \lineii{\var{arg1}/=\var{arg2}} {divides \var{arg1} by \var{arg2} \index{/}}
88     \end{tableii}
89     \var{arg1} must be a \Data object. \var{arg1} must be a
90     \Data object or an object that can be converted into a
91     \Data object. \var{arg1} must have the same shape like
92     \var{arg1} or has rank 0 or shape (1,). In the latter case it is
93     assumed that the values of \var{arg1} are constant for all
94     components. \var{arg2} must be defined on the same data points like
95     \var{arg1} or it must be possible to interpolate \var{arg2} onto the
96     data points where \var{arg1} is hold.
97    
98    
99     %TODO:
100     Slicing \index{slicing}.
101    
102     \begin{classdesc}{Data}{}
103     A class that holds values assigned to data points.
104     \end{classdesc}
105    
106     \begin{classdesc}{Scalar}{value=None,where=None,expand=None}
107     A class that holds a single value per data point.
108     \end{classdesc}
109    
110     \begin{classdesc}{Vector}{value=None,dim=None,where=None,expand=None}
111     A class that holds a vector per data point.
112     \end{classdesc}
113    
114     \begin{classdesc}{Tensor}{value=None,dim=None,where=None,expand=None}
115     A class that holds a tensor order 2 (matrix) per data point.
116     \end{classdesc}
117    
118     \begin{classdesc}{Tensor3}{value=None,dim=None,where=None,expand=None}
119     A class that holds a tensor order 3 per data point.
120     \end{classdesc}
121    
122     \begin{classdesc}{Tensor4}{value=None,dim=None,where=None,expand=None}
123     A class that holds a tensor order 4 per data point.
124     \end{classdesc}
125    
126     \begin{funcdesc}{abs}{arg}
127     returns the absulute value of \Data \var{arg}. The returned
128     \Data object has the same rank, shape and is defined on the
129     same \class{_Atom} like \var{arg}. An entries in the returned object
130     is the absolute value of the corresponding entry in \var{arg}.
131     \index{absolute value}
132     \end{funcdesc}
133    
134     \begin{funcdesc}{L2}{arg}
135     returns the $L^2$-norm of the \Data \var{arg} by using method
136     \method{arg.L2()}. \index{$L^2$-norm}
137     \end{funcdesc}
138    
139     \begin{funcdesc}{grad}{arg}
140     returns the gradient of the interpolation function of \Data
141     \var{arg} by using \method{arg.grad}. \index{gradient}
142     \end{funcdesc}
143    
144     \begin{funcdesc}{integrate}{arg}
145     returns the integral of the interpolation function of \Data
146     \var{arg} by using \method{arg.integrate}. \index{integral}
147     \end{funcdesc}
148    
149     \begin{funcdesc}{interpolate}{arg,where}
150     interpolates the \Data \var{arg} onto \class{_Atom} where by
151     using \method{arg.interpolate}. \index{interpolation}
152     \end{funcdesc}
153    
154     \begin{funcdesc}{transpose}{arg}
155     returns the transpose of \var{arg} where \var{arg} has to be
156     \Data or \class{numarray.array}. If \var{arg} is of
157     \Data the method \method{arg.transpose} is used otherwise
158     \function{numarray.transpose} is called. \index{transpose}
159     \end{funcdesc}
160    
161     \begin{funcdesc}{trace}{arg}
162     returns the trace of \var{arg} where \var{arg} has to be \Data
163     or \class{numarray.array} of rank 2. If \var{arg} is of \Data
164     the method \method{arg.trace} is used otherwise
165     \function{numarray.trace} is called. \index{trace}
166     \end{funcdesc}
167    
168     \begin{funcdesc}{exp}{arg}
169     applies the exponential function to \var{arg} where \var{arg} has to
170     be \Data or \class{numarray.array}. If \var{arg} is of
171     \Data the method \method{arg.exp} is used otherwise
172     \function{numarray.exp} is called. \index{exponential function}
173     \end{funcdesc}
174    
175     \begin{funcdesc}{sqrt}{arg}
176     applies the square root function to \var{arg} where \var{arg} has to
177     be \Data or \class{numarray.array}. If \var{arg} is of
178     \Data the method \method{arg.sqrt} is used otherwise
179     \function{numarray.sqrt} is called. \index{square root}
180     \end{funcdesc}
181    
182     \begin{funcdesc}{sin}{arg}
183     applies the sine function to \var{arg} where \var{arg} has to be
184     \Data or \class{numarray.array}. If \var{arg} is of
185     \Data the method \method{arg.sin} is used otherwise
186     \function{numarray.sin} is called. \index{sine function}
187     \end{funcdesc}
188    
189     \begin{funcdesc}{cos}{arg}
190     applies the cosine function to \var{arg} where \var{arg} has to be
191     \Data or \class{numarray.array}. If \var{arg} is of
192     \Data the method \method{arg.cos} is used otherwise
193     \function{numarray.cos} is called. \index{cosine function}
194     \end{funcdesc}
195    
196     \begin{funcdesc}{maxval}{arg}
197     returns for each data point the maximum value over all components of
198     \Data \var{arg} by using \method{arg.maxval}. \index{maximum
199     value}
200     \end{funcdesc}
201    
202     \begin{funcdesc}{minval}{arg}
203     returns for each data point the minimum value over all components of
204     \Data \var{arg} by using \method{arg.minval}. \index{minimum
205     value}
206     \end{funcdesc}
207    
208     \begin{funcdesc}{inf}{arg}
209     returns the minimum value (infimum) over all components and all data
210     points of \Data \var{arg} by using \method{arg.inf}.
211     \index{infimum}
212     \end{funcdesc}
213    
214     \begin{funcdesc}{sup}{arg}
215     returns the maximum value (supremum) over all components and all data
216     points of \Data \var{arg} by using \method{arg.sup}.
217     \index{supremum}
218     \end{funcdesc}
219    
220     \begin{funcdesc}{Lsup}{arg}
221     returns the maximum absulute value ($L^{sup}$-norm) over all
222     components and all data points of \Data \var{arg} by using
223     \method{arg.sup}. The returned value equals
224     \function{sup}(\function(arg)). \index{$L^{sup}$-norm}
225     \end{funcdesc}
226    
227     \begin{funcdesc}{matmult}{arg1,arg2}
228     returns for each data point the matrix-matrix product of \var{arg1}
229     and \var{arg2} \index{matrix-matrix product}. At least of the
230     arguments \var{arg1} and \var{arg2} has to be a \Data
231     object. If the other argument is not a \Data object it must be
232     convertable into a \Data object. The returned \Data
233     object has rank \var{arg1.getRank()}+\var{arg2.getRank()}-2 and shape
234     (\var{arg1.getShape()}[r-1],\var{arg2.getShape()}[1:]), where
235     \var{r}=\var{arg1.getRank()}. The last dimension of \var{arg1} and the
236     first dimension of \var{arg2} have to match,
237     i.e. \var{arg1.getShape()[r-1]}=\var{arg2.getShape()[0]}
238    
239     For the case that \var{arg1} and \var{arg2} are both of rank $2$ the
240     result \var{res} is calculated as
241     \begin{equation}
242     res(i,j;s)=
243     arg1(i,0;s) \cdot arg2(0,j;s)+
244     \ldots
245     arg1(i,n-1;s) \cdot arg2(n-1,j;s)
246     \end{equation}
247     for all $0\le i <$ \var{arg1.getShape()[0]}, $0\le j <$
248     \var{arg2.getShape()[1]} and all data points $s$, where
249     $n$=\var{arg2.getShape()[0]},
250    
251     If the arguments are not defined on the same data points, \var{arg1}
252     is tried to be interpolated on the data points of \var{arg2} or
253     \var{arg2} is tried to be interpolated on the data points of
254     \var{arg1}. What ever case works defines the data points of the
255     result.
256     \end{funcdesc}
257    
258     %==================================================================
259     \section{\Data class}
260     \begin{classdesc}{Data}{value=None,shape=None,where=None,expand=None}
261     \end{classdesc}
262    
263     \begin{methoddesc}[Data]{getAtoms}{}
264     returns a handel to the data points on which the object is definded
265     \index{data points}. The returned object is of \class{_Atoms}.
266     \end{methoddesc}
267    
268     \begin{methoddesc}[Data]{getShape}{}
269     returns the shape of the data on each data point as a \class{tuple} of
270     integers. \index{shape}
271     \end{methoddesc}
272    
273     \begin{methoddesc}[Data]{getRank}{}
274     returns the rank of the data on each data point. \index{rank}
275     \end{methoddesc}
276    
277     \begin{methoddesc}[Data]{hasShape}{shape}
278     is true if the object has the shape \var{shape}.
279     \end{methoddesc}
280    
281     \begin{methoddesc}[Data]{expand}{}
282     returns an expanded version of the object if the object is not
283     expanded. Otherwise it returns itself. \index{expanded}
284     \end{methoddesc}
285    
286     \begin{methoddesc}[Data]{makeExpanded}{}
287     turns the object into an expanded \Data
288     object. \index{expanded}
289     \end{methoddesc}
290    
291     \begin{methoddesc}[Data]{isExpanded}{}
292     is true if the object is expanded. \index{expanded}
293     \end{methoddesc}
294    
295     \begin{methoddesc}[Data]{isTagged}{}
296     is true if the object is defined using tags. \index{tagged}
297     \end{methoddesc}
298    
299     \begin{methoddesc}[Data]{asArray}{}
300     returns the object as a \class{numarray.array} array. The array is one
301     rank higher than the rank of the object. The extra dimension is the
302     number of data points.
303     % TODO: be more accurate on the shape
304     \end{methoddesc}
305    
306     \begin{methoddesc}[Data]{addTaggedValue}{tag,value=0}
307     assigns the \var{value} to all data points which have the tag
308     \var{tag} which has to be an integer or a list of
309     integers. \var{value} must be an object of class
310     \class{numarray.array} or must be convertable into a
311     \class{numarray.array} object. \var{value} (or the cooresponding
312     \class{numarray.array} object) must be of rank $0$ or must have the
313     same rank like the object. \index{tagged}
314    
315     If a value has allready be defined for tag \var{tag} within the object
316     it is overwritten by the new \var{value}. If the object is expanded,
317     the value assigned to data points with tag \var{tag} is replaced by
318     \var{value}.
319     \end{methoddesc}
320    
321     \begin{methoddesc}[Data]{getTaggedValue}{tag}
322     returns the value assigned to \var{tag}. An exception is raised if the
323     object is not defined by tagged data, e.g. if the object is
324     expanded.\index{tagged}
325     \end{methoddesc}
326    
327     \begin{methoddesc}[Data]{L2}{}
328     returns the $L^2$-norm of the object. This is square root of sum of
329     the squares of all values over all components and all data points.
330     \index{$L^2$-norm}
331     \end{methoddesc}
332    
333     \begin{methoddesc}[Data]{grad}{}
334     returns the gradient of the interpolation function. The returned
335     \Data object is of rank r+1 where r is the rank of the object.
336     Typically the object of to be defined on nodes and the returned
337     gradient is defined on the quadrature points of elements.
338     \index{gradient}
339     \end{methoddesc}
340    
341     \begin{methoddesc}[Data]{integrate}{}
342     returns the integral of the interpolation function. The method returns
343     a \class{numarray.array} object of the same shape like the object. A
344     component of the returned object is the integral of the corresponding
345     component of the object. \index{integral}
346     \end{methoddesc}
347    
348     \begin{methoddesc}[Data]{interpolate}{where}
349     interpolates onto the data points of the \class{_Atom}
350     \var{where}. The returned \Data object is of the same shape
351     like the object and is defined on the data points \var{where}.
352     \index{interpolation}
353     \end{methoddesc}
354    
355     \begin{methoddesc}[Data]{transpose}{}
356     returns the transpose of the object. The return value is an object has
357     the same shape and is defined on the same data points like the object.
358     For each data point the value is set to transposed of the
359     corresponding value of the object by reversing the index of the data.
360    
361     For the case that object \var{self} is of rank 3 the result \var{res} is
362     \begin{equation}
363     res(i,j,k;s)=self(k,j,i;s)
364     \end{equation}
365     for all
366     $0\le i <$ \var{self.getShape()[2]},
367     $0\le j <$ \var{self.getShape()[1]},
368     $0\le k <$ \var{self.getShape()[0]}
369     and all data points $s$.
370     \index{transpose}
371     \end{methoddesc}
372    
373     \begin{methoddesc}[Data]{trace}{}
374     returns the trace of the object of rank 2. The return value is an
375     object has rank 0 or shape (1,) and is defined on the same data points
376     like the object. For each data point the value is set to sum of the
377     main diagonal entries.
378    
379     For the case that object \var{self} is of rank 2 the result \var{res}
380     is
381     \begin{equation}
382     res(0;s)=
383     self(0,0;s)+
384     self(1,1;s)+
385     \ldots +
386     self(n,n;s)
387     \end{equation}
388     for all data points $s$ where
389     $n=min($\var{self.getShape()[0]},\var{self.getShape()[1]}$)$.
390     \index{trace}
391     \end{methoddesc}
392    
393     \begin{methoddesc}[Data]{exp}{}
394     applies the exponential function to the values of the object. The
395     return value is an object has the same shape and is defined on the
396     same data points like the object. For each data point and all
397     components the value is calculated by applying the exponention
398     function to the corresponding value of the object. \index{exponential
399     function}
400     \end{methoddesc}
401    
402     \begin{methoddesc}[Data]{sqrt}{}
403     applies the square root function to the values of the object. The
404     return value is an object has the same shape and is defined on the
405     same data points like the object. For each data point and all
406     components the value is calculated by applying the square root
407     function to the corresponding value of the object. An exception is
408     raised if the value is negative. \index{square root}
409     \end{methoddesc}
410    
411     \begin{methoddesc}[Data]{sin}{}
412     applies the sine function to the values of the object. The return
413     value is an object has the same shape and is defined on the same data
414     points like the object. For each data point and all components the
415     value is calculated by applying the sine function to the
416     corresponding value of the object. \index{sine function}
417     \end{methoddesc}
418    
419     \begin{methoddesc}[Data]{cos}{}
420     applies the cosine function to the values of the object. The return
421     value is an object has the same shape and is defined on the same data
422     points like the object. For each data point and all components the
423     value is calculated by applying the cosine function to the
424     corresponding value of the object. \index{cosine function}
425     \end{methoddesc}
426    
427     \begin{methoddesc}[Data]{maxval}{}
428     returns for each data point the maximum value over all components. The
429     return value is an object of rank 0 or shape (1,) and is defined on
430     the same data points like the object. \index{maximum value}
431     \end{methoddesc}
432    
433     \begin{methoddesc}[Data]{minval}{}
434     returns for each data point the minimum value over all components. The
435     return value is an object of rank 0 or shape (1,) and is defined on
436     the same data points like the object. \index{minimum value}
437     \end{methoddesc}
438    
439     \begin{methoddesc}[Data]{inf}{}
440     returns the minimum value (infimum) of the object. The minimum is
441     taken over all components and all data points. \index{infimum}
442     \end{methoddesc}
443    
444     \begin{methoddesc}[Data]{sup}{}
445     returns the maximum value (supremum) of the object. The maximum is
446     taken over all components and all data points. \index{supremum}
447     \end{methoddesc}
448    
449     \begin{methoddesc}[Data]{Lsup}{}
450     returns the $L^{sup}$-norm of the object. This is maximum value of the
451     absolut values of the object over all data points and all components.
452     \index{$L^{sup}$-norm}
453     \end{methoddesc}
454    
455     \begin{methoddesc}[Data]{wherePositive}{}
456     returns \Data object which has the same shape and is defined on
457     the same data points like the object. The returned values are $1$
458     where the object is positive and $0$ elsewhere.
459     \end{methoddesc}
460    
461     \begin{methoddesc}[Data]{whereNonnegative}{}
462     returns \Data object which has the same shape and is defined on
463     the same data points like the object. The returned values are $1$
464     where the object is non-negative and $0$ elsewhere.
465     \end{methoddesc}
466    
467     \begin{methoddesc}[Data]{whereNegative}{}
468     returns \Data object which has the same shape and is defined on
469     the same data points like the object. The returned values are $1$
470     where the object is negative and $0$ elsewhere.
471     \end{methoddesc}
472    
473     \begin{methoddesc}[Data]{whereZero}{tolerance=Constants.EPSILON}
474     returns \Data object which has the same shape and is defined on
475     the same data points like the object. The returned values are $1$
476     where the object is nearly zero, i.e. where the absolute value is less
477     than \var{tolerance}, and $0$ elsewhere.
478     \end{methoddesc}
479    
480     \begin{methoddesc}[Data]{whereNonzero}{tolerance=Constants.EPSILON}
481     returns \Data object which has the same shape and is defined on
482     the same data points like the object. The returned values are $1$
483     where the object is nearly non-zero, i.e. where the absolute value is
484     greater or equal than \var{tolerance}, and $0$ elsewhere.
485     \end{methoddesc}
486    
487     \begin{methoddesc}[Data]{saveDX}{fileName}
488     saves the object to an openDX format file of name \var{fileName}, see
489     \ulink{www.opendx.org}{\url{www.opendx.org}}. \index{openDX}
490     \end{methoddesc}
491    
492     \begin{methoddesc}[Data]{saveMM}{fileName}
493     saves the object to a matrix market format file of name
494     \var{fileName}, see
495     \ulink{maths.nist.gov/MatrixMarket}{\url{http://maths.nist.gov/MatrixMarket}}.
496     \index{Matrix Market}
497     \end{methoddesc}
498    
499     %=====================================================
500     \section{Subclasses of \var{class}}
501     \begin{classdesc}{Scalar}{value=None,where=None,expand=None}
502     \Data object with a single value (scalar) per data
503     point. \var{value} must be a float number. If \var{expand} is true,
504     the \var{value} is copied to each data point.
505     \end{classdesc}
506    
507     \begin{classdesc}{Vector}{value=None,dim=None,where=None,expand=None}
508     \Data object with a vector of length \var{dim} value (scalar)
509     per data point. If \var{dim} is not present or equals \var{None},
510     \var{dim} is assumed to be the spatial dimension of the data points
511     defined by \var{where}. \var{value} may be a float number or a
512     \class{numarray.array} object with shape (\var{dim},). If
513     \var{expand} is true, the \var{value} is copied to each data point.
514     \end{classdesc}
515    
516     \begin{classdesc}{Tensor}{value=None,dim=None,where=None,expand=None}
517     \Data object with a \var{dim} $\times$ \var{dim} - tensor of
518     order 2 per data point. If \var{dim} is not present or equals
519     \var{None}, \var{dim} is assumed to be the spatial dimension of the
520     data points defined by \var{where}. \var{value} may be a float number
521     or a \class{numarray.array} object with shape (\var{dim},\var{dim}).
522     If \var{expand} is true, the \var{value} is copied to each data point.
523     \end{classdesc}
524    
525     \begin{classdesc}{Tensor3}{value=None,dim=None,where=None,expand=None}
526     \Data object with a \var{dim} $\times$ \var{dim} $\times$
527     \var{dim} - tensor of order 3 per data point. If \var{dim} is not
528     present or equals \var{None}, \var{dim} is assumed to be the spatial
529     dimension of the data points defined by \var{where}. \var{value} may
530     be a float number or a \class{numarray.array} object with shape
531     (\var{dim},\var{dim},var{dim}). If \var{expand} is true, the
532     \var{value} is copied to each data point.
533     \end{classdesc}
534    
535     \begin{classdesc}{Tensor4}{value=None,dim=None,where=None,expand=None}
536     \Data object with a \var{dim} $\times$ \var{dim} $\times$
537     \var{dim} $\times$ \var{dim} - tensor of order 4 per data point. If
538     \var{dim} is not present or equals \var{None}, \var{dim} is assumed to
539     be the spatial dimension of the data points defined by
540     \var{where}. \var{value} may be a float number or a
541     \class{numarray.array} object with shape
542     (\var{dim},\var{dim},var{dim},var{dim}). If \var{expand} is true, the
543     \var{value} is copied to each data point.
544     \end{classdesc}

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26