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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 984 - (hide annotations)
Tue Feb 20 03:33:45 2007 UTC (12 years, 7 months ago) by gross
File MIME type: text/plain
File size: 14770 byte(s)
warning in dump and load at altix fixed.
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 gross 983 \brief
318     getData
319    
320     Description:
321     Return pointer to the data
322     T
323     */
324     ESCRIPT_DLL_API
325     const DataArrayView::ValueType::ElementType*
326 gross 984 getData() const;
327 gross 983
328     /**
329 jgs 82 \brief
330     getTagLookup
331    
332     Description:
333     Return a reference to the tag offset lookup table.
334 jgs 507 T
335 jgs 82 */
336 woo409 757 ESCRIPT_DLL_API
337 jgs 82 const DataMapType&
338     getTagLookup() const;
339    
340     /**
341     \brief
342     isCurrentTag
343    
344     Description:
345 jgs 496 Return true if the given tag exists within the DataTagged tag map.
346    
347 jgs 509 *** NB: The DataTagged tag map does not necessarily coincide with the tag
348 jgs 496 keys in the associated function space.
349 jgs 507 T
350     */
351 woo409 757 ESCRIPT_DLL_API
352 jgs 82 bool
353     isCurrentTag(int tag) const;
354    
355     /**
356     \brief
357     getDefaultValue
358    
359     Description:
360     Return the default value. This value is associated with any tag which
361 jgs 496 is not explicitly recorded in this DataTagged object's tag map.
362 jgs 507 T
363 jgs 82 */
364 woo409 757 ESCRIPT_DLL_API
365 jgs 82 DataArrayView&
366     getDefaultValue();
367    
368 woo409 757 ESCRIPT_DLL_API
369 jgs 82 const DataArrayView&
370     getDefaultValue() const;
371    
372     /**
373     \brief
374     getLength
375    
376     Description:
377 jgs 509 Return the total number of doubles stored for this DataTagged object.
378 jgs 507 T
379 jgs 82 */
380 woo409 757 ESCRIPT_DLL_API
381 jgs 82 virtual
382     ValueType::size_type
383     getLength() const;
384    
385     /**
386     \brief
387     getSlice
388    
389     Description:
390 jgs 513 Factory method that returns a newly created DataTagged object generated
391     by taking the specified slice from this DataTagged object.
392     The caller is reponsible for managing the returned object.
393 jgs 535 T
394 jgs 82 */
395 woo409 757 ESCRIPT_DLL_API
396 jgs 82 virtual
397     DataAbstract*
398     getSlice(const DataArrayView::RegionType& region) const;
399    
400     /**
401     \brief
402 jgs 513 Slice Constructor for DataTagged.
403 jgs 82
404     Description:
405 jgs 513 Creates a DataTagged object which is the specified slice
406 jgs 519 from the given DataTagged object.
407     \param other - Input - DataTagged object to slice from.
408     \param region - Input - Region to slice.
409 jgs 535 T
410 jgs 82 */
411 woo409 757 ESCRIPT_DLL_API
412 jgs 513 DataTagged(const DataTagged& other,
413     const DataArrayView::RegionType& region);
414    
415     /**
416     \brief
417     setSlice
418    
419     Description:
420 jgs 519 Copy the given Data object into the specified region in this object.
421 jgs 513 \param other - Input - Data object to copy from.
422 jgs 519 \param region - Input - Region to copy into (NB: must have same shape as other!).
423 jgs 535 T
424 jgs 513 */
425 woo409 757 ESCRIPT_DLL_API
426 jgs 82 virtual
427     void
428 jgs 513 setSlice(const DataAbstract* other,
429 jgs 82 const DataArrayView::RegionType& region);
430    
431     /**
432     \brief
433 jgs 509 Archive the underlying data values to the file referenced
434     by ofstream. A count of the number of values expected to be written
435     is provided as a cross-check.
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     archiveData(std::ofstream& archiveFile,
442     const DataArrayView::ValueType::size_type noValues) const;
443    
444     /**
445 jgs 509 \brief
446     Extract the number of values specified by noValues from the file
447     referenced by ifstream to the underlying data structure.
448 jgs 123
449 jgs 509 The return value indicates success (0) or otherwise (1).
450 jgs 123 */
451 woo409 757 ESCRIPT_DLL_API
452 jgs 123 int
453     extractData(std::ifstream& archiveFile,
454     const DataArrayView::ValueType::size_type noValues);
455    
456 gross 580 /**
457     \brief
458 ksteube 775 Computes a symmetric matrix (A + AT) / 2
459    
460     \param ev - Output - symmetric matrix
461    
462     */
463 gross 800 ESCRIPT_DLL_API
464 ksteube 775 virtual void
465     symmetric(DataAbstract* ev);
466    
467     /**
468     \brief
469     Computes a nonsymmetric matrix (A - AT) / 2
470    
471     \param ev - Output - nonsymmetric matrix
472    
473     */
474 gross 800 ESCRIPT_DLL_API
475 ksteube 775 virtual void
476     nonsymmetric(DataAbstract* ev);
477    
478     /**
479     \brief
480     Computes the trace of a matrix
481    
482     \param ev - Output - the trace of a matrix
483    
484     */
485 gross 800 ESCRIPT_DLL_API
486 ksteube 775 virtual void
487 gross 800 trace(DataAbstract* ev, int axis_offset);
488 ksteube 775
489     /**
490     \brief
491 gross 804 swaps components axis0 and axis1
492 gross 800
493     \param ev - Output - swapped components
494    
495     */
496     ESCRIPT_DLL_API
497     virtual void
498 gross 804 swapaxes(DataAbstract* ev, int axis0, int axis1);
499 gross 800
500     /**
501     \brief
502 ksteube 775 Transpose each data point of this Data object around the given axis.
503    
504     \param ev - Output - the transpose of a matrix
505    
506     */
507 gross 800 ESCRIPT_DLL_API
508 ksteube 775 virtual void
509     transpose(DataAbstract* ev, int axis_offset);
510    
511     /**
512     \brief
513 gross 580 solves the eigenvalue problem this*V=ev*V for the eigenvalues ev
514    
515     \param ev - Output - eigenvalues in increasing order at each data point
516    
517     */
518 woo409 757 ESCRIPT_DLL_API
519 gross 580 virtual void
520     eigenvalues(DataAbstract* ev);
521    
522     /**
523     \brief
524     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V
525    
526     \param ev - Output - eigenvalues in increasing order at each data point
527     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
528     and the first nonzero component is positive.
529     \param tol - Input - eigenvalue with relative distance tol are treated as equal.
530    
531     */
532    
533 woo409 757 ESCRIPT_DLL_API
534 gross 580 virtual void
535     eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
536    
537    
538 jgs 82 protected:
539    
540     private:
541    
542     //
543     // The offset lookup table
544     DataMapType m_offsetLookup;
545    
546     //
547 jgs 496 // the offset to the default value
548 jgs 119 static const int m_defaultValueOffset = 0;
549    
550     //
551 jgs 82 // The actual data
552 jgs 121 ValueType m_data;
553 jgs 82
554     };
555    
556     inline
557     bool
558     DataTagged::isCurrentTag(int tag) const
559     {
560     DataMapType::const_iterator pos(m_offsetLookup.find(tag));
561     return (pos!=m_offsetLookup.end());
562     }
563    
564     inline
565     DataArrayView&
566     DataTagged::getDefaultValue()
567     {
568     // The default value is always the first value.
569     return getPointDataView();
570     }
571    
572     inline
573     const DataArrayView&
574     DataTagged::getDefaultValue() const
575     {
576     // The default value is always the first value.
577     return getPointDataView();
578     }
579    
580 jgs 496 inline
581 gross 983 const DataArrayView::ValueType::ElementType*
582     DataTagged::getData() const
583     {
584     return &(m_data[0]);
585     }
586    
587     inline
588 jgs 496 const DataTagged::DataMapType&
589     DataTagged::getTagLookup() const
590     {
591     return m_offsetLookup;
592     }
593    
594     inline
595     DataArrayView::ValueType::size_type
596     DataTagged::getLength() const
597     {
598     return m_data.size();
599     }
600    
601 jgs 82 } // end of namespace
602    
603     #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26