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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 950 - (show annotations)
Tue Feb 6 07:01:11 2007 UTC (12 years, 6 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 // $Id$
2
3 /*
4 ************************************************************
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 */
14
15 #if !defined escript_DataTagged_20040615_H
16 #define escript_DataTagged_20040615_H
17 #include "system_dep.h"
18
19 #include "DataAbstract.h"
20 #include "DataArrayView.h"
21
22 #include <vector>
23 #include <map>
24
25 namespace escript {
26
27 class DataConstant;
28
29 /**
30 \brief
31 Simulates a full dataset accessible via sampleNo and dataPointNo.
32
33 Description:
34 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 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 //
45 // Types for the lists of tags and values.
46 typedef std::vector<int> TagListType;
47 typedef std::vector<DataArrayView> ValueListType;
48 typedef DataArrayView::ValueType ValueType;
49
50 //
51 // Map from a tag to an offset into the data array.
52 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 the default data-point is a scalar data-point with value 0.0, and no other
61 tag values are stored.
62 T
63 */
64 ESCRIPT_DLL_API
65 DataTagged();
66
67 /**
68 \brief
69 Constructor for DataTagged.
70
71 Description:
72 Constructor for DataTagged.
73 \param tagKeys - Input - A vector of integer tags.
74 \param values - Input - A vector of DataArrayViews. If this is empty
75 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 will be generated.
81 \param defaultValue - Input - Value returned if a requested tag doesn't exist.
82 \param what - Input - A description of what this data represents.
83 T
84 */
85 ESCRIPT_DLL_API
86 DataTagged(const TagListType& tagKeys,
87 const ValueListType& values,
88 const DataArrayView& defaultValue,
89 const FunctionSpace& what);
90
91 /**
92 \brief
93 Alternative Constructor for DataTagged.
94
95 Description:
96 Alternative Constructor for DataTagged.
97 \param what - Input - A description of what this data object represents.
98 \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 NB: no unit testing yet
102 */
103 ESCRIPT_DLL_API
104 DataTagged(const FunctionSpace& what,
105 const DataArrayView::ShapeType &shape,
106 const int tags[],
107 const ValueType& data);
108
109 /**
110 \brief
111 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 Copy Constructor for DataTagged.
130 Performs a deep copy from the given DataTagged object.
131 T
132 */
133 ESCRIPT_DLL_API
134 DataTagged(const DataTagged& other);
135
136 /**
137 \brief
138 Copy Constructor for DataTagged.
139 Construct a DataTagged object from a DataConstant object.
140 The default value will be the value of the DataConstant object.
141 T
142 */
143 ESCRIPT_DLL_API
144 DataTagged(const DataConstant& other);
145
146 /**
147 \brief
148 getSampleDataByTag
149
150 Description:
151 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 ** NB: need to do array bounds checking when accessing returned value!
156 T
157 */
158 ESCRIPT_DLL_API
159 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 T
169 */
170 ESCRIPT_DLL_API
171 virtual
172 std::string
173 toString() const;
174 /**
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
183 /**
184 \brief
185 Return the tag number associated with the given data-point number
186 according to the associated function space.
187 T
188 */
189 ESCRIPT_DLL_API
190 virtual
191 int
192 getTagNumber(int dpno);
193
194 /**
195 \brief
196 getPointOffset
197
198 Description:
199 Return the offset to the given data-point value in the underlying
200 data vector.
201
202 \param sampleNo - Input - sample number.
203 \param dataPointNo - Input - data-point number.
204 T
205 */
206 ESCRIPT_DLL_API
207 virtual
208 ValueType::size_type
209 getPointOffset(int sampleNo,
210 int dataPointNo) const;
211
212 /**
213 \brief
214 addTaggedValues
215
216 Description:
217 Add the given tags and values to this DataTagged object.
218 \param tagKeys - Input - A vector of integer tags.
219 \param values - Input - A vector of DataArrayViews. If this is empty
220 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 T
227 */
228 ESCRIPT_DLL_API
229 void
230 addTaggedValues(const TagListType& tagKeys,
231 const ValueListType& values);
232
233 /**
234 \brief
235 addTaggedValue
236
237 Description:
238 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 \param tagKey - Input - Integer tag.
241 \param value - Input - Single DataArrayView value to be assigned to the tag.
242 T
243 */
244 ESCRIPT_DLL_API
245 void
246 addTaggedValue(int tagKey,
247 const DataArrayView& value);
248
249 /**
250 \brief
251 setTaggedValues
252
253 Description:
254 Set the given tags to the given values in this DataTagged object.
255 \param tagKeys - Input - A vector of integer tag.
256 \param values - Input - A vector of DataArrayViews. If this is empty
257 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 T
264 */
265 ESCRIPT_DLL_API
266 void
267 setTaggedValues(const TagListType& tagKeys,
268 const ValueListType& values);
269
270 /**
271 \brief
272 setTaggedValue
273
274 Description:
275 Assign the given value to the given tag.
276 \param tagKey - Input - Integer tag.
277 \param value - Input - Single DataArrayView value to be assigned to the tag.
278 T
279 */
280 ESCRIPT_DLL_API
281 virtual
282 void
283 setTaggedValue(int tagKey,
284 const DataArrayView& value);
285
286 /**
287 \brief
288 getDataPointByTag
289
290 Description:
291 Return data-point associated with the given tag as a DataArrayView.
292 \param tag - Input - Integer key.
293 T
294 */
295 ESCRIPT_DLL_API
296 DataArrayView
297 getDataPointByTag(int tag) const;
298
299 /**
300 \brief
301 getDataPoint
302
303 Description:
304 Return the data-point specified by the given sample and data-point
305 numbers as a DataArrayView.
306 \param sampleNo - Input.
307 \param dataPointNo - Input.
308 T
309 */
310 ESCRIPT_DLL_API
311 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 T
323 */
324 ESCRIPT_DLL_API
325 const DataMapType&
326 getTagLookup() const;
327
328 /**
329 \brief
330 isCurrentTag
331
332 Description:
333 Return true if the given tag exists within the DataTagged tag map.
334
335 *** NB: The DataTagged tag map does not necessarily coincide with the tag
336 keys in the associated function space.
337 T
338 */
339 ESCRIPT_DLL_API
340 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 is not explicitly recorded in this DataTagged object's tag map.
350 T
351 */
352 ESCRIPT_DLL_API
353 DataArrayView&
354 getDefaultValue();
355
356 ESCRIPT_DLL_API
357 const DataArrayView&
358 getDefaultValue() const;
359
360 /**
361 \brief
362 getLength
363
364 Description:
365 Return the total number of doubles stored for this DataTagged object.
366 T
367 */
368 ESCRIPT_DLL_API
369 virtual
370 ValueType::size_type
371 getLength() const;
372
373 /**
374 \brief
375 getSlice
376
377 Description:
378 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 T
382 */
383 ESCRIPT_DLL_API
384 virtual
385 DataAbstract*
386 getSlice(const DataArrayView::RegionType& region) const;
387
388 /**
389 \brief
390 Slice Constructor for DataTagged.
391
392 Description:
393 Creates a DataTagged object which is the specified slice
394 from the given DataTagged object.
395 \param other - Input - DataTagged object to slice from.
396 \param region - Input - Region to slice.
397 T
398 */
399 ESCRIPT_DLL_API
400 DataTagged(const DataTagged& other,
401 const DataArrayView::RegionType& region);
402
403 /**
404 \brief
405 setSlice
406
407 Description:
408 Copy the given Data object into the specified region in this object.
409 \param other - Input - Data object to copy from.
410 \param region - Input - Region to copy into (NB: must have same shape as other!).
411 T
412 */
413 ESCRIPT_DLL_API
414 virtual
415 void
416 setSlice(const DataAbstract* other,
417 const DataArrayView::RegionType& region);
418
419 /**
420 \brief
421 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
425 The return value indicates success (0) or otherwise (1).
426 */
427 ESCRIPT_DLL_API
428 int
429 archiveData(std::ofstream& archiveFile,
430 const DataArrayView::ValueType::size_type noValues) const;
431
432 /**
433 \brief
434 Extract the number of values specified by noValues from the file
435 referenced by ifstream to the underlying data structure.
436
437 The return value indicates success (0) or otherwise (1).
438 */
439 ESCRIPT_DLL_API
440 int
441 extractData(std::ifstream& archiveFile,
442 const DataArrayView::ValueType::size_type noValues);
443
444 /**
445 \brief
446 Computes a symmetric matrix (A + AT) / 2
447
448 \param ev - Output - symmetric matrix
449
450 */
451 ESCRIPT_DLL_API
452 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 ESCRIPT_DLL_API
463 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 ESCRIPT_DLL_API
474 virtual void
475 trace(DataAbstract* ev, int axis_offset);
476
477 /**
478 \brief
479 swaps components axis0 and axis1
480
481 \param ev - Output - swapped components
482
483 */
484 ESCRIPT_DLL_API
485 virtual void
486 swapaxes(DataAbstract* ev, int axis0, int axis1);
487
488 /**
489 \brief
490 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 ESCRIPT_DLL_API
496 virtual void
497 transpose(DataAbstract* ev, int axis_offset);
498
499 /**
500 \brief
501 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 ESCRIPT_DLL_API
507 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 ESCRIPT_DLL_API
522 virtual void
523 eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
524
525
526 protected:
527
528 private:
529
530 //
531 // The offset lookup table
532 DataMapType m_offsetLookup;
533
534 //
535 // the offset to the default value
536 static const int m_defaultValueOffset = 0;
537
538 //
539 // The actual data
540 ValueType m_data;
541
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 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 } // 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