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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 950 - (hide annotations)
Tue Feb 6 07:01:11 2007 UTC (12 years, 8 months ago) by gross
File MIME type: text/plain
File size: 14483 byte(s)
escript data objects can now be saved to netCDF files, see http://www.unidata.ucar.edu/software/netcdf/.
Currently only constant data are implemented with expanded and tagged data to follow.
There are two new functions to dump a data object

   s=Data(...)
   s.dump(<filename>)

and to recover it

   s=load(<filename>, domain)

Notice that the function space of s is recovered but domain is still need. 

dump and load will replace archive and extract.

The installation needs now the netCDF installed. 


1 jgs 82 // $Id$
2 jgs 121
3     /*
4 elspeth 615 ************************************************************
5     * Copyright 2006 by ACcESS MNRF *
6     * *
7     * http://www.access.edu.au *
8     * 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     * *
12     ************************************************************
13 jgs 82 */
14 jgs 121
15 jgs 82 #if !defined escript_DataTagged_20040615_H
16     #define escript_DataTagged_20040615_H
17 woo409 757 #include "system_dep.h"
18 jgs 82
19 jgs 474 #include "DataAbstract.h"
20     #include "DataArrayView.h"
21 jgs 82
22     #include <vector>
23     #include <map>
24    
25     namespace escript {
26    
27     class DataConstant;
28    
29     /**
30     \brief
31 jgs 496 Simulates a full dataset accessible via sampleNo and dataPointNo.
32 jgs 82
33     Description:
34 jgs 496 Each data-point has an associated tag number, and a given tag can represent a
35     range of dataPointNo and sampleNo. Each tag indexes only a single data-point.
36 jgs 82 Thus only a single data-point needs to be stored for a range of sampleNo and
37     dataPointNo values.
38     */
39    
40     class DataTagged : public DataAbstract {
41    
42     public:
43    
44 jgs 119 //
45 jgs 496 // Types for the lists of tags and values.
46 jgs 121 typedef std::vector<int> TagListType;
47 jgs 82 typedef std::vector<DataArrayView> ValueListType;
48 jgs 121 typedef DataArrayView::ValueType ValueType;
49 jgs 82
50     //
51 jgs 496 // Map from a tag to an offset into the data array.
52 jgs 82 typedef std::map<int, int> DataMapType;
53    
54     /**
55     \brief
56     Default constructor for DataTagged.
57    
58     Description:
59     Default constructor for DataTagged. Creates a DataTagged object for which
60 jgs 509 the default data-point is a scalar data-point with value 0.0, and no other
61     tag values are stored.
62 jgs 507 T
63 jgs 82 */
64 woo409 757 ESCRIPT_DLL_API
65 jgs 82 DataTagged();
66    
67     /**
68     \brief
69     Constructor for DataTagged.
70    
71     Description:
72     Constructor for DataTagged.
73 jgs 509 \param tagKeys - Input - A vector of integer tags.
74 jgs 82 \param values - Input - A vector of DataArrayViews. If this is empty
75 jgs 509 all tag values will be assigned a scalar data-point of value
76     0. If it contains one value all tag values will be assigned
77     this value. Otherwise consecutive tags will be assigned
78     consecutive values. If there is a mismatch between the
79     number of keys and the number of values an exception
80 jgs 496 will be generated.
81 jgs 82 \param defaultValue - Input - Value returned if a requested tag doesn't exist.
82     \param what - Input - A description of what this data represents.
83 jgs 507 T
84 jgs 82 */
85 woo409 757 ESCRIPT_DLL_API
86 jgs 82 DataTagged(const TagListType& tagKeys,
87     const ValueListType& values,
88     const DataArrayView& defaultValue,
89     const FunctionSpace& what);
90    
91     /**
92     \brief
93 jgs 496 Alternative Constructor for DataTagged.
94 jgs 119
95     Description:
96 jgs 496 Alternative Constructor for DataTagged.
97 jgs 119 \param what - Input - A description of what this data object represents.
98 jgs 496 \param shape - Input - The shape of each data-point.
99     \param tags - Input - An array of tags, one for each sample number.
100     \param data - The data values for each tag.
101 jgs 535 NB: no unit testing yet
102 jgs 119 */
103 woo409 757 ESCRIPT_DLL_API
104 jgs 119 DataTagged(const FunctionSpace& what,
105     const DataArrayView::ShapeType &shape,
106     const int tags[],
107 jgs 500 const ValueType& data);
108 jgs 119
109     /**
110     \brief
111 woo409 757 Alternative Constructor for DataTagged.
112    
113     Description:
114     Alternative Constructor for DataTagged.
115     \param what - Input - A description of what this data object represents.
116     \param shape - Input - The shape of each data-point.
117     \param tags - Input - An vector of tags, one for each sample number.
118     \param data - The data values for each tag.
119     NB: no unit testing yet
120     */
121     ESCRIPT_DLL_API
122     DataTagged(const FunctionSpace& what,
123     const DataArrayView::ShapeType &shape,
124     const TagListType& tags,
125     const ValueType& data);
126    
127     /**
128     \brief
129 jgs 496 Copy Constructor for DataTagged.
130 jgs 82 Performs a deep copy from the given DataTagged object.
131 jgs 507 T
132 jgs 82 */
133 woo409 757 ESCRIPT_DLL_API
134 jgs 82 DataTagged(const DataTagged& other);
135    
136     /**
137     \brief
138 jgs 496 Copy Constructor for DataTagged.
139 jgs 509 Construct a DataTagged object from a DataConstant object.
140     The default value will be the value of the DataConstant object.
141 jgs 507 T
142 jgs 82 */
143 woo409 757 ESCRIPT_DLL_API
144 jgs 82 DataTagged(const DataConstant& other);
145    
146     /**
147     \brief
148     getSampleDataByTag
149    
150     Description:
151 jgs 496 Return the data-point for the given tag. All of the data for the
152     sample will be visible via the returned pointer.
153    
154     ** This provides an interface into the data suitable for legacy C code.
155 jgs 507 ** NB: need to do array bounds checking when accessing returned value!
156     T
157 jgs 82 */
158 woo409 757 ESCRIPT_DLL_API
159 jgs 82 virtual
160     double*
161     getSampleDataByTag(int tag);
162    
163     /**
164     \brief
165     Write the data as a string.
166     Writes out each tag, including the default, and the data-point which is
167     associated with each tag.
168 jgs 507 T
169 jgs 82 */
170 woo409 757 ESCRIPT_DLL_API
171 jgs 82 virtual
172     std::string
173     toString() const;
174 gross 950 /**
175     \brief
176     dumps the object into a netCDF file
177     */
178     ESCRIPT_DLL_API
179     virtual
180     void
181     dump(const std::string fileName) const;
182 jgs 82
183     /**
184     \brief
185 jgs 496 Return the tag number associated with the given data-point number
186     according to the associated function space.
187 jgs 507 T
188 jgs 149 */
189 woo409 757 ESCRIPT_DLL_API
190 jgs 149 virtual
191     int
192     getTagNumber(int dpno);
193    
194     /**
195     \brief
196 jgs 82 getPointOffset
197    
198     Description:
199 jgs 496 Return the offset to the given data-point value in the underlying
200     data vector.
201 jgs 82
202     \param sampleNo - Input - sample number.
203     \param dataPointNo - Input - data-point number.
204 jgs 507 T
205     */
206 woo409 757 ESCRIPT_DLL_API
207 jgs 82 virtual
208 jgs 121 ValueType::size_type
209 jgs 82 getPointOffset(int sampleNo,
210     int dataPointNo) const;
211    
212     /**
213     \brief
214     addTaggedValues
215    
216     Description:
217 jgs 509 Add the given tags and values to this DataTagged object.
218 jgs 507 \param tagKeys - Input - A vector of integer tags.
219 jgs 82 \param values - Input - A vector of DataArrayViews. If this is empty
220 jgs 509 all tag values will be assigned a scalar data-point of value
221     0. If it contains one value all tag values will be assigned
222     this value. Otherwise consecutive tags will be assigned
223     consecutive values. If there is a mismatch between the
224     number of keys and the number of values an exception
225     will be generated.
226 jgs 507 T
227 jgs 82 */
228 woo409 757 ESCRIPT_DLL_API
229 jgs 82 void
230     addTaggedValues(const TagListType& tagKeys,
231     const ValueListType& values);
232    
233     /**
234     \brief
235     addTaggedValue
236    
237     Description:
238 jgs 121 Add a single tag and value to this DataTagged object. If this tag already has
239     a value associated with it, setTaggedValue will be used to update this value.
240 jgs 509 \param tagKey - Input - Integer tag.
241 jgs 121 \param value - Input - Single DataArrayView value to be assigned to the tag.
242 jgs 507 T
243 jgs 82 */
244 woo409 757 ESCRIPT_DLL_API
245 jgs 82 void
246     addTaggedValue(int tagKey,
247     const DataArrayView& value);
248    
249     /**
250     \brief
251     setTaggedValues
252    
253     Description:
254 jgs 509 Set the given tags to the given values in this DataTagged object.
255     \param tagKeys - Input - A vector of integer tag.
256 jgs 82 \param values - Input - A vector of DataArrayViews. If this is empty
257 jgs 509 all tag values will be assigned a scalar data-point of value
258     0. If it contains one value all tag values will be assigned
259     this value. Otherwise consecutive tags will be assigned
260     consecutive values. If there is a mismatch between the
261     number of keys and the number of values an exception
262     will be generated.
263 jgs 507 T
264 jgs 82 */
265 woo409 757 ESCRIPT_DLL_API
266 jgs 82 void
267     setTaggedValues(const TagListType& tagKeys,
268     const ValueListType& values);
269    
270     /**
271     \brief
272     setTaggedValue
273    
274     Description:
275 jgs 509 Assign the given value to the given tag.
276     \param tagKey - Input - Integer tag.
277 jgs 82 \param value - Input - Single DataArrayView value to be assigned to the tag.
278 jgs 507 T
279 jgs 82 */
280 woo409 757 ESCRIPT_DLL_API
281 jgs 82 virtual
282     void
283     setTaggedValue(int tagKey,
284     const DataArrayView& value);
285    
286     /**
287     \brief
288     getDataPointByTag
289    
290     Description:
291 jgs 509 Return data-point associated with the given tag as a DataArrayView.
292 jgs 82 \param tag - Input - Integer key.
293 jgs 507 T
294 jgs 82 */
295 woo409 757 ESCRIPT_DLL_API
296 jgs 82 DataArrayView
297     getDataPointByTag(int tag) const;
298    
299     /**
300     \brief
301     getDataPoint
302    
303     Description:
304 jgs 509 Return the data-point specified by the given sample and data-point
305     numbers as a DataArrayView.
306 jgs 82 \param sampleNo - Input.
307     \param dataPointNo - Input.
308 jgs 507 T
309 jgs 82 */
310 woo409 757 ESCRIPT_DLL_API
311 jgs 82 virtual
312     DataArrayView
313     getDataPoint(int sampleNo,
314     int dataPointNo);
315    
316     /**
317     \brief
318     getTagLookup
319    
320     Description:
321     Return a reference to the tag offset lookup table.
322 jgs 507 T
323 jgs 82 */
324 woo409 757 ESCRIPT_DLL_API
325 jgs 82 const DataMapType&
326     getTagLookup() const;
327    
328     /**
329     \brief
330     isCurrentTag
331    
332     Description:
333 jgs 496 Return true if the given tag exists within the DataTagged tag map.
334    
335 jgs 509 *** NB: The DataTagged tag map does not necessarily coincide with the tag
336 jgs 496 keys in the associated function space.
337 jgs 507 T
338     */
339 woo409 757 ESCRIPT_DLL_API
340 jgs 82 bool
341     isCurrentTag(int tag) const;
342    
343     /**
344     \brief
345     getDefaultValue
346    
347     Description:
348     Return the default value. This value is associated with any tag which
349 jgs 496 is not explicitly recorded in this DataTagged object's tag map.
350 jgs 507 T
351 jgs 82 */
352 woo409 757 ESCRIPT_DLL_API
353 jgs 82 DataArrayView&
354     getDefaultValue();
355    
356 woo409 757 ESCRIPT_DLL_API
357 jgs 82 const DataArrayView&
358     getDefaultValue() const;
359    
360     /**
361     \brief
362     getLength
363    
364     Description:
365 jgs 509 Return the total number of doubles stored for this DataTagged object.
366 jgs 507 T
367 jgs 82 */
368 woo409 757 ESCRIPT_DLL_API
369 jgs 82 virtual
370     ValueType::size_type
371     getLength() const;
372    
373     /**
374     \brief
375     getSlice
376    
377     Description:
378 jgs 513 Factory method that returns a newly created DataTagged object generated
379     by taking the specified slice from this DataTagged object.
380     The caller is reponsible for managing the returned object.
381 jgs 535 T
382 jgs 82 */
383 woo409 757 ESCRIPT_DLL_API
384 jgs 82 virtual
385     DataAbstract*
386     getSlice(const DataArrayView::RegionType& region) const;
387    
388     /**
389     \brief
390 jgs 513 Slice Constructor for DataTagged.
391 jgs 82
392     Description:
393 jgs 513 Creates a DataTagged object which is the specified slice
394 jgs 519 from the given DataTagged object.
395     \param other - Input - DataTagged object to slice from.
396     \param region - Input - Region to slice.
397 jgs 535 T
398 jgs 82 */
399 woo409 757 ESCRIPT_DLL_API
400 jgs 513 DataTagged(const DataTagged& other,
401     const DataArrayView::RegionType& region);
402    
403     /**
404     \brief
405     setSlice
406    
407     Description:
408 jgs 519 Copy the given Data object into the specified region in this object.
409 jgs 513 \param other - Input - Data object to copy from.
410 jgs 519 \param region - Input - Region to copy into (NB: must have same shape as other!).
411 jgs 535 T
412 jgs 513 */
413 woo409 757 ESCRIPT_DLL_API
414 jgs 82 virtual
415     void
416 jgs 513 setSlice(const DataAbstract* other,
417 jgs 82 const DataArrayView::RegionType& region);
418    
419     /**
420     \brief
421 jgs 509 Archive the underlying data values to the file referenced
422     by ofstream. A count of the number of values expected to be written
423     is provided as a cross-check.
424 jgs 123
425 jgs 509 The return value indicates success (0) or otherwise (1).
426 jgs 123 */
427 woo409 757 ESCRIPT_DLL_API
428 jgs 123 int
429     archiveData(std::ofstream& archiveFile,
430     const DataArrayView::ValueType::size_type noValues) const;
431    
432     /**
433 jgs 509 \brief
434     Extract the number of values specified by noValues from the file
435     referenced by ifstream to the underlying data structure.
436 jgs 123
437 jgs 509 The return value indicates success (0) or otherwise (1).
438 jgs 123 */
439 woo409 757 ESCRIPT_DLL_API
440 jgs 123 int
441     extractData(std::ifstream& archiveFile,
442     const DataArrayView::ValueType::size_type noValues);
443    
444 gross 580 /**
445     \brief
446 ksteube 775 Computes a symmetric matrix (A + AT) / 2
447    
448     \param ev - Output - symmetric matrix
449    
450     */
451 gross 800 ESCRIPT_DLL_API
452 ksteube 775 virtual void
453     symmetric(DataAbstract* ev);
454    
455     /**
456     \brief
457     Computes a nonsymmetric matrix (A - AT) / 2
458    
459     \param ev - Output - nonsymmetric matrix
460    
461     */
462 gross 800 ESCRIPT_DLL_API
463 ksteube 775 virtual void
464     nonsymmetric(DataAbstract* ev);
465    
466     /**
467     \brief
468     Computes the trace of a matrix
469    
470     \param ev - Output - the trace of a matrix
471    
472     */
473 gross 800 ESCRIPT_DLL_API
474 ksteube 775 virtual void
475 gross 800 trace(DataAbstract* ev, int axis_offset);
476 ksteube 775
477     /**
478     \brief
479 gross 804 swaps components axis0 and axis1
480 gross 800
481     \param ev - Output - swapped components
482    
483     */
484     ESCRIPT_DLL_API
485     virtual void
486 gross 804 swapaxes(DataAbstract* ev, int axis0, int axis1);
487 gross 800
488     /**
489     \brief
490 ksteube 775 Transpose each data point of this Data object around the given axis.
491    
492     \param ev - Output - the transpose of a matrix
493    
494     */
495 gross 800 ESCRIPT_DLL_API
496 ksteube 775 virtual void
497     transpose(DataAbstract* ev, int axis_offset);
498    
499     /**
500     \brief
501 gross 580 solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
502    
503     \param ev - Output - eigenvalues in increasing order at each data point
504    
505     */
506 woo409 757 ESCRIPT_DLL_API
507 gross 580 virtual void
508     eigenvalues(DataAbstract* ev);
509    
510     /**
511     \brief
512     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
513    
514     \param ev - Output - eigenvalues in increasing order at each data point
515     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
516     and the first nonzero component is positive.
517     \param tol - Input - eigenvalue with relative distance tol are treated as equal.
518    
519     */
520    
521 woo409 757 ESCRIPT_DLL_API
522 gross 580 virtual void
523     eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
524    
525    
526 jgs 82 protected:
527    
528     private:
529    
530     //
531     // The offset lookup table
532     DataMapType m_offsetLookup;
533    
534     //
535 jgs 496 // the offset to the default value
536 jgs 119 static const int m_defaultValueOffset = 0;
537    
538     //
539 jgs 82 // The actual data
540 jgs 121 ValueType m_data;
541 jgs 82
542     };
543    
544     inline
545     bool
546     DataTagged::isCurrentTag(int tag) const
547     {
548     DataMapType::const_iterator pos(m_offsetLookup.find(tag));
549     return (pos!=m_offsetLookup.end());
550     }
551    
552     inline
553     DataArrayView&
554     DataTagged::getDefaultValue()
555     {
556     // The default value is always the first value.
557     return getPointDataView();
558     }
559    
560     inline
561     const DataArrayView&
562     DataTagged::getDefaultValue() const
563     {
564     // The default value is always the first value.
565     return getPointDataView();
566     }
567    
568 jgs 496 inline
569     const DataTagged::DataMapType&
570     DataTagged::getTagLookup() const
571     {
572     return m_offsetLookup;
573     }
574    
575     inline
576     DataArrayView::ValueType::size_type
577     DataTagged::getLength() const
578     {
579     return m_data.size();
580     }
581    
582 jgs 82 } // end of namespace
583    
584     #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26