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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 922 - (hide annotations)
Fri Jan 5 04:23:05 2007 UTC (12 years, 10 months ago) by gross
File MIME type: text/plain
File size: 12892 byte(s)
setValueOfDataPoint accepts double value as argument now
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 922 Copy a double value to the data point dataPointNo of sample sampleNo in this object.
326    
327     Description:
328     Copy a double value 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 double value);
337    
338     /**
339     \brief
340 gross 921 Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.
341    
342     Description:
343     Copy the numarray object to the data point dataPointNo of sample sampleNo in this object.
344    
345     \param sampleNo Input - sample number
346     \param dataPointNo Input - data point of the sample
347     \param value Input - new values for the data point
348     */
349     ESCRIPT_DLL_API
350     virtual void
351     copyToDataPoint(const int sampleNo, const int dataPointNo, const boost::python::numeric::array& value);
352    
353    
354     /**
355     \brief
356 jgs 149 Return the tag number associated with the given data-point number.
357 jgs 126
358 jgs 149 If the object cannot be referenced by tag numbers, an exception
359     will be thrown.
360     */
361 woo409 757 ESCRIPT_DLL_API
362 jgs 149 virtual
363     int
364     getTagNumber(int dpno);
365    
366 gross 576 /**
367     \brief
368 ksteube 775 Computes a symmetric matrix (A + AT) / 2
369    
370     \param ev - Output - a symmetric matrix
371    
372     */
373 gross 800 ESCRIPT_DLL_API
374 ksteube 775 virtual void
375     symmetric(DataAbstract* ev);
376    
377     /**
378     \brief
379     Computes a nonsymmetric matrix (A - AT) / 2
380    
381     \param ev - Output - a nonsymmetric matrix
382    
383     */
384 gross 800 ESCRIPT_DLL_API
385 ksteube 775 virtual void
386     nonsymmetric(DataAbstract* ev);
387    
388     /**
389     \brief
390     Computes the trace of a matrix
391    
392     \param ev - Output - the trace of a matrix
393    
394     */
395 gross 800 ESCRIPT_DLL_API
396 ksteube 775 virtual void
397 gross 800 trace(DataAbstract* ev, int axis_offset);
398 ksteube 775
399     /**
400     \brief
401     Transpose each data point of this Data object around the given axis.
402    
403     \param ev - Output - the transpose of a matrix
404    
405     */
406 gross 800 ESCRIPT_DLL_API
407 ksteube 775 virtual void
408     transpose(DataAbstract* ev, int axis_offset);
409    
410     /**
411     \brief
412 gross 804 swaps components axis0 and axis1
413 gross 800
414     \param ev - Output - swapped components
415    
416     */
417     ESCRIPT_DLL_API
418     virtual void
419 gross 804 swapaxes(DataAbstract* ev, int axis0, int axis1);
420 gross 800 /**
421     \brief
422 gross 576 solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
423    
424     \param ev - Output - eigenvalues in increasing order at each data point
425    
426     */
427 woo409 757 ESCRIPT_DLL_API
428 gross 576 virtual void
429     eigenvalues(DataAbstract* ev);
430    
431     /**
432     \brief
433     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
434    
435     \param ev - Output - eigenvalues in increasing order at each data point
436     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
437     and the first nonzero component is positive.
438     \param tol - Input - eigenvalue with relative distance tol are treated as equal.
439    
440     */
441    
442 woo409 757 ESCRIPT_DLL_API
443 gross 576 virtual void
444     eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
445    
446 jgs 82 protected:
447    
448     /**
449     \brief
450 jgs 117 Set the pointDataView DataArrayView associated with this object.
451    
452 jgs 121 \param input - Input - The point data view. DataAbstract takes ownership
453 jgs 82 of the DataArrayView provided. It will delete it when it is destructed.
454     */
455 woo409 757 ESCRIPT_DLL_API
456 jgs 82 void
457     setPointDataView(const DataArrayView& input);
458    
459 woo409 757 ESCRIPT_DLL_API
460 jgs 119 void
461     resetPointDataView();
462    
463 jgs 82 private:
464    
465 jgs 117 //
466     // The number of samples in this Data object.
467     // This is derived directly from the FunctionSpace.
468 jgs 82 int m_noSamples;
469    
470     //
471 jgs 117 // The number of data points per sample in this Data object.
472     // This is derived directly from the FunctionSpace.
473     int m_noDataPointsPerSample;
474    
475     //
476     // The DataArrayView of the data array associated with this object.
477     // The data array is defined only in child classes of this class, it
478     // is not defined in this abstract parent class.
479 jgs 82 boost::scoped_ptr<DataArrayView> m_pointDataView;
480    
481     //
482 jgs 117 // A FunctionSpace which provides a description of the data associated
483     // with this Data object.
484 jgs 82 FunctionSpace m_functionSpace;
485    
486     };
487    
488     inline
489     bool
490 jgs 106 DataAbstract::validSamplePointNo(int samplePointNo) const
491 jgs 82 {
492     return ((0 <= samplePointNo) && (samplePointNo < m_noDataPointsPerSample));
493     }
494    
495     inline
496     bool
497     DataAbstract::validSampleNo(int sampleNo) const
498     {
499     return ((0 <= sampleNo) && (sampleNo < m_noSamples));
500     }
501    
502     inline
503     DataAbstract::ValueType::value_type*
504     DataAbstract::getSampleData(ValueType::size_type sampleNo)
505     {
506     return &(m_pointDataView->getData(getPointOffset(sampleNo,0)));
507     }
508    
509     inline
510     int
511     DataAbstract::getNumDPPSample() const
512     {
513     return m_noDataPointsPerSample;
514     }
515    
516     inline
517     int
518     DataAbstract::getNumSamples() const
519     {
520     return m_noSamples;
521     }
522    
523     inline
524 jgs 106 const
525     FunctionSpace&
526 jgs 82 DataAbstract::getFunctionSpace() const
527     {
528     return m_functionSpace;
529     }
530    
531     inline
532 jgs 106 const
533     DataArrayView&
534 jgs 82 DataAbstract::getPointDataView() const
535     {
536     return *(m_pointDataView.get());
537     }
538    
539     inline
540     DataArrayView&
541     DataAbstract::getPointDataView()
542     {
543     return *(m_pointDataView.get());
544     }
545     } // end of namespace
546 jgs 117
547 jgs 82 #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26