/[escript]/trunk/escript/src/DataAbstract.h
ViewVC logotype

Annotation of /trunk/escript/src/DataAbstract.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 921 - (hide annotations)
Fri Jan 5 00:54:37 2007 UTC (12 years, 9 months ago) by gross
File MIME type: text/plain
File size: 12397 byte(s)
I have done some clarification on functions that allow to access individual data point values in a Data object. 
The term "data point number" is always local on a MPI process and referes to the value (data_point_in_sample, sample)
as a single identifyer (data_point_in_sample + sample * number_data_points_per_sample). a "global data point number"
referes to a tuple of a processour id and local data point number.

The function convertToNumArrayFromSampleNo has been removed now and convertToNumArrayFromDPNo renamed to getValueOfDataPoint.
There are two new functions:

   getNumberOfDataPoints
   setValueOfDataPoint

This allows you to do things like:

  in=Data(..)
  out=Data(..)
   for i in xrange(in.getNumberOfDataPoints())
       in_loc=in.getValueOfDataPoint(i)
       out_loc=< some operations on in_loc>
       out.setValueOfDataPoint(i,out_loc)


Also mindp  is renamed to  minGlobalDataPoint and there is a new function getValueOfGlobalDataPoint. While in MPI the functions getNumberOfDataPoints and getValueOfDataPoint are working locally on each process (so the code above is executed in parallel).
the latter allows getting a single value across all processors. 


1 jgs 82 // $Id$
2     /*
3 elspeth 615 ************************************************************
4     * Copyright 2006 by ACcESS MNRF *
5     * *
6     * http://www.access.edu.au *
7     * Primary Business: Queensland, Australia *
8     * Licensed under the Open Software License version 3.0 *
9     * http://www.opensource.org/licenses/osl-3.0.php *
10     * *
11     ************************************************************
12    
13 jgs 82 */
14 jgs 478
15 jgs 106 #if !defined escript_DataAbstract_20040315_H
16 jgs 82 #define escript_DataAbstract_20040315_H
17 woo409 757 #include "system_dep.h"
18 jgs 82
19 jgs 474 #include "DataArrayView.h"
20     #include "DataArray.h"
21     #include "FunctionSpace.h"
22 jgs 82
23     #include <boost/scoped_ptr.hpp>
24 jgs 478 #include <boost/python/numeric.hpp>
25 jgs 480
26 jgs 82 #include <string>
27 jgs 480 #include <fstream>
28 jgs 82
29     namespace escript {
30    
31     /**
32     \brief
33 jgs 117 DataAbstract provides an abstract interface for the class of containers
34 jgs 82 which hold ESyS data.
35    
36     Description:
37 jgs 117 DataAbstract provides an abstract interface for the class of containers
38 jgs 82 which hold ESyS data. The container may be thought of as a 2 dimensional
39 jgs 117 array of data points where one dimension corresponds to the number of samples
40     and the other to the number of data points per sample as defined by the function
41     space associated with each Data object. The data points themselves are arrays of
42     doubles of rank 0-4.
43 jgs 82 */
44    
45     class DataAbstract {
46    
47     public:
48    
49     typedef DataArrayView::ValueType ValueType;
50     typedef DataArrayView::ShapeType ShapeType;
51    
52     /**
53     \brief
54     Constructor for DataAbstract.
55    
56     Description:
57     Constructor for DataAbstract.
58 jgs 117
59 jgs 82 \param what - Input - A description of what this data represents.
60     */
61 woo409 757 ESCRIPT_DLL_API
62 jgs 82 DataAbstract(const FunctionSpace& what);
63    
64     /**
65     \brief
66     Destructor for DataAbstract.
67     */
68 woo409 757 ESCRIPT_DLL_API
69 jgs 106 virtual
70     ~DataAbstract();
71 jgs 82
72     /**
73     \brief
74     Write the data as a string.
75     */
76 woo409 757 ESCRIPT_DLL_API
77 jgs 82 virtual
78     std::string
79     toString() const = 0;
80    
81     /**
82     \brief
83     Return the number of data points per sample.
84     */
85 woo409 757 ESCRIPT_DLL_API
86 jgs 82 int
87     getNumDPPSample() const;
88    
89     /**
90     \brief
91     Return the number of samples.
92     */
93 woo409 757 ESCRIPT_DLL_API
94 jgs 82 int
95     getNumSamples() const;
96    
97     /**
98     \brief
99     Return the DataArrayView of the point data. This essentially contains
100     the shape information for each data point although it also may be used
101     to manipulate the point data.
102     */
103 woo409 757 ESCRIPT_DLL_API
104 jgs 117 DataArrayView&
105     getPointDataView();
106    
107 woo409 757 ESCRIPT_DLL_API
108 jgs 82 const DataArrayView&
109     getPointDataView() const;
110    
111     /**
112     \brief
113 jgs 117 Return the offset for the given sample. This returns the offset for the given
114     point into the container holding the point data. Only really necessary to
115     avoid creating many DataArrayView objects.
116    
117 jgs 82 \param sampleNo - Input - sample number.
118 jgs 117 \param dataPointNo - Input - data point number.
119 jgs 82 */
120 woo409 757 ESCRIPT_DLL_API
121 jgs 82 virtual
122     ValueType::size_type
123     getPointOffset(int sampleNo,
124     int dataPointNo) const = 0;
125    
126     /**
127     \brief
128 jgs 117 Return the sample data for the given sample number.
129 jgs 82 */
130 woo409 757 ESCRIPT_DLL_API
131 jgs 82 double*
132     getSampleData(ValueType::size_type sampleNo);
133    
134     /**
135     \brief
136 jgs 117 Return the number of doubles stored for this Data object.
137 jgs 82 */
138 woo409 757 ESCRIPT_DLL_API
139 jgs 82 virtual
140     ValueType::size_type
141     getLength() const = 0;
142    
143     /**
144     \brief
145     Return the sample data for the given tag key.
146     NB: If the data isn't tagged an exception will be thrown.
147     */
148 woo409 757 ESCRIPT_DLL_API
149 jgs 82 virtual
150     double*
151     getSampleDataByTag(int tag);
152    
153     /**
154     \brief
155 jgs 110 Assign the given value to the data-points(s) referenced by the given
156     reference number.
157    
158     If this Data object cannot be accessed by reference numbers an
159     exception will be thrown.
160    
161     \param ref - Input - reference number.
162     \param value - Input - value to assign to data-points associated with
163     the given reference number.
164     */
165 woo409 757 ESCRIPT_DLL_API
166 jgs 110 virtual
167     void
168     setRefValue(int ref,
169     const DataArray& value);
170    
171     /**
172     \brief
173     Return the values associated with the data-point(s) referenced by the given
174     reference number.
175    
176     If this Data object cannot be accessed by reference numbers an
177     exception will be thrown.
178    
179     \param ref - Input - reference number.
180     \param value - Output - object to receive data-points associated with
181     the given reference number.
182     */
183 woo409 757 ESCRIPT_DLL_API
184 jgs 110 virtual
185     void
186     getRefValue(int ref,
187     DataArray& value);
188    
189     /**
190     \brief
191 jgs 117 Check this and the given RHS operands are compatible. Throws
192 jgs 82 an exception if they aren't.
193 jgs 117
194 jgs 82 \param right - Input - The right hand side.
195     */
196 woo409 757 ESCRIPT_DLL_API
197 jgs 82 void
198     operandCheck(const DataAbstract& right) const;
199    
200     /**
201     \brief
202     Return true if a valid sample point number.
203     */
204 woo409 757 ESCRIPT_DLL_API
205 jgs 82 bool
206     validSamplePointNo(int samplePointNo) const;
207    
208     /**
209     \brief
210 jgs 117 Return true if a valid sample number.
211 jgs 82 */
212 woo409 757 ESCRIPT_DLL_API
213 jgs 82 bool
214     validSampleNo(int sampleNo) const;
215    
216     /**
217     \brief
218     Return a view into the data for the data point specified.
219     NOTE: Construction of the DataArrayView is a relatively expensive
220     operation.
221 jgs 117
222     \param sampleNo - Input - the sample number.
223     \param dataPointNo - Input - the data point number.
224 jgs 82 */
225 woo409 757 ESCRIPT_DLL_API
226 jgs 82 virtual
227 jgs 106 DataArrayView
228 jgs 117 getDataPoint(int sampleNo,
229 jgs 106 int dataPointNo) = 0;
230 jgs 82
231     /**
232     \brief
233 jgs 117 Return the function space associated with this Data object.
234 jgs 82 */
235 woo409 757 ESCRIPT_DLL_API
236 jgs 117 const
237     FunctionSpace&
238 jgs 82 getFunctionSpace() const;
239    
240     /**
241     \brief
242 jgs 117 Return the given slice from this object.
243    
244     NB: The caller is responsible for managing the object created.
245 jgs 82 */
246 woo409 757 ESCRIPT_DLL_API
247 jgs 82 virtual
248     DataAbstract*
249     getSlice(const DataArrayView::RegionType& region) const = 0;
250    
251     /**
252     \brief
253 jgs 117 Copy the specified region from the given object.
254    
255 jgs 82 \param value - Input - Data to copy from
256     \param region - Input - Region to copy.
257     */
258 woo409 757 ESCRIPT_DLL_API
259 jgs 82 virtual
260     void
261     setSlice(const DataAbstract* value,
262     const DataArrayView::RegionType& region) = 0;
263    
264    
265     /**
266     \brief
267     setTaggedValue
268    
269     Description:
270     Assign the given value to the given tag.
271 jgs 117
272     NB: If the data isn't tagged an exception will be thrown.
273    
274 jgs 82 \param tagKey - Input - Integer key.
275     \param value - Input - Single DataArrayView value to be assigned to the tag.
276     */
277 woo409 757 ESCRIPT_DLL_API
278 jgs 82 virtual
279     void
280     setTaggedValue(int tagKey,
281     const DataArrayView& value);
282    
283 jgs 123 /**
284     \brief
285     Archive the underlying data values to the file referenced
286     by ofstream. A count of the number of values expected to be written
287     is provided as a cross-check.
288    
289     The return value indicates success (0) or otherwise (1).
290     */
291 woo409 757 ESCRIPT_DLL_API
292 jgs 123 virtual
293     int
294     archiveData(std::ofstream& archiveFile,
295     const ValueType::size_type noValues) const;
296    
297     /**
298     \brief
299     Extract the number of values specified by noValues from the file
300     referenced by ifstream to the underlying data structure.
301    
302     The return value indicates success (0) or otherwise (1).
303     */
304 woo409 757 ESCRIPT_DLL_API
305 jgs 123 virtual
306     int
307     extractData(std::ifstream& archiveFile,
308     const ValueType::size_type noValues);
309    
310 jgs 126 /**
311     \brief
312     Copy the numarray object to the data points in this object.
313    
314     Description:
315     Copy the numarray object to the data points in this object.
316    
317     \param value Input - new values for the data points
318     */
319 woo409 757 ESCRIPT_DLL_API
320 jgs 126 virtual void
321     copyAll(const boost::python::numeric::array& value);
322    
323 jgs 149 /**
324     \brief
325 gross 921 Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.
326    
327     Description:
328     Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.
329    
330     \param sampleNo Input - sample number
331     \param dataPointNo Input - data point of the sample
332     \param value Input - new values for the data point
333     */
334     ESCRIPT_DLL_API
335     virtual void
336     copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value);
337    
338    
339     /**
340     \brief
341 jgs 149 Return the tag number associated with the given data-point number.
342 jgs 126
343 jgs 149 If the object cannot be referenced by tag numbers, an exception
344     will be thrown.
345     */
346 woo409 757 ESCRIPT_DLL_API
347 jgs 149 virtual
348     int
349     getTagNumber(int dpno);
350    
351 gross 576 /**
352     \brief
353 ksteube 775 Computes a symmetric matrix (A + AT) / 2
354    
355     \param ev - Output - a symmetric matrix
356    
357     */
358 gross 800 ESCRIPT_DLL_API
359 ksteube 775 virtual void
360     symmetric(DataAbstract* ev);
361    
362     /**
363     \brief
364     Computes a nonsymmetric matrix (A - AT) / 2
365    
366     \param ev - Output - a nonsymmetric matrix
367    
368     */
369 gross 800 ESCRIPT_DLL_API
370 ksteube 775 virtual void
371     nonsymmetric(DataAbstract* ev);
372    
373     /**
374     \brief
375     Computes the trace of a matrix
376    
377     \param ev - Output - the trace of a matrix
378    
379     */
380 gross 800 ESCRIPT_DLL_API
381 ksteube 775 virtual void
382 gross 800 trace(DataAbstract* ev, int axis_offset);
383 ksteube 775
384     /**
385     \brief
386     Transpose each data point of this Data object around the given axis.
387    
388     \param ev - Output - the transpose of a matrix
389    
390     */
391 gross 800 ESCRIPT_DLL_API
392 ksteube 775 virtual void
393     transpose(DataAbstract* ev, int axis_offset);
394    
395     /**
396     \brief
397 gross 804 swaps components axis0 and axis1
398 gross 800
399     \param ev - Output - swapped components
400    
401     */
402     ESCRIPT_DLL_API
403     virtual void
404 gross 804 swapaxes(DataAbstract* ev, int axis0, int axis1);
405 gross 800 /**
406     \brief
407 gross 576 solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
408    
409     \param ev - Output - eigenvalues in increasing order at each data point
410    
411     */
412 woo409 757 ESCRIPT_DLL_API
413 gross 576 virtual void
414     eigenvalues(DataAbstract* ev);
415    
416     /**
417     \brief
418     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
419    
420     \param ev - Output - eigenvalues in increasing order at each data point
421     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
422     and the first nonzero component is positive.
423     \param tol - Input - eigenvalue with relative distance tol are treated as equal.
424    
425     */
426    
427 woo409 757 ESCRIPT_DLL_API
428 gross 576 virtual void
429     eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
430    
431 jgs 82 protected:
432    
433     /**
434     \brief
435 jgs 117 Set the pointDataView DataArrayView associated with this object.
436    
437 jgs 121 \param input - Input - The point data view. DataAbstract takes ownership
438 jgs 82 of the DataArrayView provided. It will delete it when it is destructed.
439     */
440 woo409 757 ESCRIPT_DLL_API
441 jgs 82 void
442     setPointDataView(const DataArrayView& input);
443    
444 woo409 757 ESCRIPT_DLL_API
445 jgs 119 void
446     resetPointDataView();
447    
448 jgs 82 private:
449    
450 jgs 117 //
451     // The number of samples in this Data object.
452     // This is derived directly from the FunctionSpace.
453 jgs 82 int m_noSamples;
454    
455     //
456 jgs 117 // The number of data points per sample in this Data object.
457     // This is derived directly from the FunctionSpace.
458     int m_noDataPointsPerSample;
459    
460     //
461     // The DataArrayView of the data array associated with this object.
462     // The data array is defined only in child classes of this class, it
463     // is not defined in this abstract parent class.
464 jgs 82 boost::scoped_ptr<DataArrayView> m_pointDataView;
465    
466     //
467 jgs 117 // A FunctionSpace which provides a description of the data associated
468     // with this Data object.
469 jgs 82 FunctionSpace m_functionSpace;
470    
471     };
472    
473     inline
474     bool
475 jgs 106 DataAbstract::validSamplePointNo(int samplePointNo) const
476 jgs 82 {
477     return ((0 <= samplePointNo) && (samplePointNo < m_noDataPointsPerSample));
478     }
479    
480     inline
481     bool
482     DataAbstract::validSampleNo(int sampleNo) const
483     {
484     return ((0 <= sampleNo) && (sampleNo < m_noSamples));
485     }
486    
487     inline
488     DataAbstract::ValueType::value_type*
489     DataAbstract::getSampleData(ValueType::size_type sampleNo)
490     {
491     return &(m_pointDataView->getData(getPointOffset(sampleNo,0)));
492     }
493    
494     inline
495     int
496     DataAbstract::getNumDPPSample() const
497     {
498     return m_noDataPointsPerSample;
499     }
500    
501     inline
502     int
503     DataAbstract::getNumSamples() const
504     {
505     return m_noSamples;
506     }
507    
508     inline
509 jgs 106 const
510     FunctionSpace&
511 jgs 82 DataAbstract::getFunctionSpace() const
512     {
513     return m_functionSpace;
514     }
515    
516     inline
517 jgs 106 const
518     DataArrayView&
519 jgs 82 DataAbstract::getPointDataView() const
520     {
521     return *(m_pointDataView.get());
522     }
523    
524     inline
525     DataArrayView&
526     DataAbstract::getPointDataView()
527     {
528     return *(m_pointDataView.get());
529     }
530     } // end of namespace
531 jgs 117
532 jgs 82 #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26