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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 500 - (hide annotations)
Tue Feb 7 05:19:07 2006 UTC (14 years ago) by jgs
File MIME type: text/plain
File size: 11875 byte(s)
fix a reference indicator

1 jgs 82 // $Id$
2 jgs 121
3     /*
4 jgs 82 ******************************************************************************
5     * *
6     * COPYRIGHT ACcESS 2004 - All Rights Reserved *
7     * *
8     * This software is the property of ACcESS. No part of this code *
9     * may be copied in any form or by any means without the expressed written *
10     * consent of ACcESS. Copying, use or modification of this software *
11     * by any unauthorised person is illegal unless that person has a software *
12     * license agreement with ACcESS. *
13     * *
14     ******************************************************************************
15     */
16 jgs 121
17 jgs 82 #if !defined escript_DataTagged_20040615_H
18     #define escript_DataTagged_20040615_H
19    
20 jgs 474 #include "DataAbstract.h"
21     #include "DataArrayView.h"
22 jgs 82
23     #include <vector>
24     #include <map>
25    
26     namespace escript {
27    
28     class DataConstant;
29    
30     /**
31     \brief
32 jgs 496 Simulates a full dataset accessible via sampleNo and dataPointNo.
33 jgs 82
34     Description:
35 jgs 496 Each data-point has an associated tag number, and a given tag can represent a
36     range of dataPointNo and sampleNo. Each tag indexes only a single data-point.
37 jgs 82 Thus only a single data-point needs to be stored for a range of sampleNo and
38     dataPointNo values.
39     */
40    
41     class DataTagged : public DataAbstract {
42    
43     public:
44    
45 jgs 119 //
46 jgs 496 // Types for the lists of tags and values.
47 jgs 121 typedef std::vector<int> TagListType;
48 jgs 82 typedef std::vector<DataArrayView> ValueListType;
49 jgs 121 typedef DataArrayView::ValueType ValueType;
50 jgs 82
51     //
52 jgs 496 // Map from a tag to an offset into the data array.
53 jgs 82 typedef std::map<int, int> DataMapType;
54    
55     /**
56     \brief
57     Default constructor for DataTagged.
58    
59     Description:
60     Default constructor for DataTagged. Creates a DataTagged object for which
61 jgs 496 the only data-point is a scalar data-point with value 0.0. All tags
62     will map to this single data-point.
63 jgs 500 T
64 jgs 82 */
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 keys.
74     \param values - Input - A vector of DataArrayViews. If this is empty
75 jgs 496 all tag values will be assigned a value of zero. If
76     it contains one value all tag values will be assigned the
77     same value. Otherwise if there is a mismatch between
78     the number of keys and the number of values an exception
79     will be generated.
80 jgs 82 \param defaultValue - Input - Value returned if a requested tag doesn't exist.
81     \param what - Input - A description of what this data represents.
82 jgs 500 T
83 jgs 82 */
84     DataTagged(const TagListType& tagKeys,
85     const ValueListType& values,
86     const DataArrayView& defaultValue,
87     const FunctionSpace& what);
88    
89     /**
90     \brief
91 jgs 496 Alternative Constructor for DataTagged.
92 jgs 119
93     Description:
94 jgs 496 Alternative Constructor for DataTagged.
95 jgs 119 \param what - Input - A description of what this data object represents.
96 jgs 496 \param shape - Input - The shape of each data-point.
97     \param tags - Input - An array of tags, one for each sample number.
98     \param data - The data values for each tag.
99 jgs 119 */
100     DataTagged(const FunctionSpace& what,
101     const DataArrayView::ShapeType &shape,
102     const int tags[],
103 jgs 500 const ValueType& data);
104 jgs 119
105     /**
106     \brief
107 jgs 496 Slice Constructor for DataTagged.
108 jgs 82
109     Description:
110 jgs 496 Slice Constructor for DataTagged.
111 jgs 82 Copies a slice from another DataTagged object.
112     \param other - Input - DataTagged object to copy from.
113 jgs 496 \param region - Input - Region to copy.
114 jgs 82 */
115     DataTagged(const DataTagged& other,
116     const DataArrayView::RegionType& region);
117    
118     /**
119     \brief
120 jgs 496 Copy Constructor for DataTagged.
121 jgs 82 Performs a deep copy from the given DataTagged object.
122     */
123     DataTagged(const DataTagged& other);
124    
125     /**
126     \brief
127 jgs 496 Copy Constructor for DataTagged.
128 jgs 82 Construct a tagged data from a DataConstant object.
129 jgs 496 The default value will be that held by the DataConstant object.
130 jgs 82 */
131     DataTagged(const DataConstant& other);
132    
133     /**
134     \brief
135     getSampleDataByTag
136    
137     Description:
138 jgs 496 Return the data-point for the given tag. All of the data for the
139     sample will be visible via the returned pointer.
140    
141     ** This provides an interface into the data suitable for legacy C code.
142 jgs 82 */
143     virtual
144     double*
145     getSampleDataByTag(int tag);
146    
147     /**
148     \brief
149     Write the data as a string.
150     Writes out each tag, including the default, and the data-point which is
151     associated with each tag.
152 jgs 500 T
153 jgs 82 */
154     virtual
155     std::string
156     toString() const;
157    
158     /**
159     \brief
160 jgs 496 Return the tag number associated with the given data-point number
161     according to the associated function space.
162 jgs 500 T
163 jgs 149 */
164     virtual
165     int
166     getTagNumber(int dpno);
167    
168     /**
169     \brief
170 jgs 82 getPointOffset
171    
172     Description:
173 jgs 496 Return the offset to the given data-point value in the underlying
174     data vector.
175 jgs 82
176     \param sampleNo - Input - sample number.
177     \param dataPointNo - Input - data-point number.
178 jgs 500 T
179 jgs 82 */
180     virtual
181 jgs 121 ValueType::size_type
182 jgs 82 getPointOffset(int sampleNo,
183     int dataPointNo) const;
184    
185     /**
186     \brief
187     addTaggedValues
188    
189     Description:
190 jgs 121 Add the given tags and values to this DataTagged object, by repeatedly
191     using addTaggedValue for each given tag/value pair.
192 jgs 82 \param tagKeys - Input - A vector of integer keys.
193     \param values - Input - A vector of DataArrayViews. If this is empty
194 jgs 121 then all given tags will be assigned a value of zero. If
195     it contains one value all tags will be assigned the same value.
196     Otherwise if there is a mismatch between the number of tags and
197     the number of values an exception will be generated.
198 jgs 82 */
199     void
200     addTaggedValues(const TagListType& tagKeys,
201     const ValueListType& values);
202    
203     /**
204     \brief
205     addTaggedValue
206    
207     Description:
208 jgs 121 Add a single tag and value to this DataTagged object. If this tag already has
209     a value associated with it, setTaggedValue will be used to update this value.
210 jgs 82 \param tagKey - Input - Integer key.
211 jgs 121 \param value - Input - Single DataArrayView value to be assigned to the tag.
212 jgs 82 */
213     void
214     addTaggedValue(int tagKey,
215     const DataArrayView& value);
216    
217     /**
218     \brief
219     setTaggedValues
220    
221     Description:
222 jgs 121 Set the given tags to the given values in this DataTagged object, by repeatedly
223     using setTaggedValue for each given tag/value pair.
224 jgs 82 \param tagKeys - Input - A vector of integer keys.
225     \param values - Input - A vector of DataArrayViews. If this is empty
226     then all given tags will be assigned a value of zero. If
227     it contains one value all tag values will be assigned the same value.
228     Otherwise if there is a mismatch between the number of keys and
229     the number of values an exception will be generated.
230     */
231     void
232     setTaggedValues(const TagListType& tagKeys,
233     const ValueListType& values);
234    
235     /**
236     \brief
237     setTaggedValue
238    
239     Description:
240 jgs 121 Assign the given value to the given tag. If this tag does not already have a value
241     associated with it, addTaggedValue will be used to add this tag/value pair.
242 jgs 82 \param tagKey - Input - Integer key.
243     \param value - Input - Single DataArrayView value to be assigned to the tag.
244     */
245     virtual
246     void
247     setTaggedValue(int tagKey,
248     const DataArrayView& value);
249    
250     /**
251     \brief
252     getDataPointByTag
253    
254     Description:
255     Return a view into the data-point associated with the given tag.
256     \param tag - Input - Integer key.
257 jgs 500 T
258 jgs 82 */
259     DataArrayView
260     getDataPointByTag(int tag) const;
261    
262     /**
263     \brief
264     getDataPoint
265    
266     Description:
267     Return a view into the data-point specified by the given sample
268     and data-point numbers.
269     \param sampleNo - Input.
270     \param dataPointNo - Input.
271 jgs 500 T
272 jgs 82 */
273     virtual
274     DataArrayView
275     getDataPoint(int sampleNo,
276     int dataPointNo);
277    
278     /**
279     \brief
280     getTagLookup
281    
282     Description:
283     Return a reference to the tag offset lookup table.
284 jgs 500 T
285 jgs 82 */
286     const DataMapType&
287     getTagLookup() const;
288    
289     /**
290     \brief
291     isCurrentTag
292    
293     Description:
294 jgs 496 Return true if the given tag exists within the DataTagged tag map.
295    
296     NOTE: The DataTagged tag map does not necessarily coincide with the tag
297     keys in the associated function space.
298 jgs 500 T
299 jgs 82 */
300     bool
301     isCurrentTag(int tag) const;
302    
303     /**
304     \brief
305     getDefaultValue
306    
307     Description:
308     Return the default value. This value is associated with any tag which
309 jgs 496 is not explicitly recorded in this DataTagged object's tag map.
310 jgs 500 T
311 jgs 82 */
312     DataArrayView&
313     getDefaultValue();
314    
315     const DataArrayView&
316     getDefaultValue() const;
317    
318     /**
319     \brief
320     getLength
321    
322     Description:
323     Return the number of doubles stored for the Data.
324 jgs 500 T
325 jgs 82 */
326     virtual
327     ValueType::size_type
328     getLength() const;
329    
330     /**
331     \brief
332     getSlice
333    
334     Description:
335 jgs 102 Factory method that returns a newly created DataTagged object.
336 jgs 82 The caller is reponsible for managing the object created.
337     */
338     virtual
339     DataAbstract*
340     getSlice(const DataArrayView::RegionType& region) const;
341    
342     /**
343     \brief
344     setSlice
345    
346     Description:
347 jgs 102 Copy the specified region from the given value into this object.
348 jgs 82 \param value - Input - Data to copy from.
349     \param region - Input - Region to copy.
350     */
351     virtual
352     void
353     setSlice(const DataAbstract* value,
354     const DataArrayView::RegionType& region);
355    
356     /**
357     \brief
358     reshapeDataPoint
359    
360     Description:
361     Reshape the data point only if the data-point is currently rank 0.
362     An exception is thrown if the data-point has rank other than 0.
363     The original data point value is used for all values of the new
364     data point.
365     */
366     void
367     reshapeDataPoint(const DataArrayView::ShapeType& shape);
368    
369 jgs 123 /**
370     \brief
371     Archive the underlying data values to the file referenced
372     by ofstream. A count of the number of values expected to be written
373     is provided as a cross-check.
374    
375     The return value indicates success (0) or otherwise (1).
376     */
377     int
378     archiveData(std::ofstream& archiveFile,
379     const DataArrayView::ValueType::size_type noValues) const;
380    
381     /**
382     \brief
383     Extract the number of values specified by noValues from the file
384     referenced by ifstream to the underlying data structure.
385    
386     The return value indicates success (0) or otherwise (1).
387     */
388     int
389     extractData(std::ifstream& archiveFile,
390     const DataArrayView::ValueType::size_type noValues);
391    
392 jgs 82 protected:
393    
394     private:
395    
396     //
397     // The offset lookup table
398     DataMapType m_offsetLookup;
399    
400     //
401 jgs 496 // the offset to the default value
402 jgs 119 static const int m_defaultValueOffset = 0;
403    
404     //
405 jgs 82 // The actual data
406 jgs 121 ValueType m_data;
407 jgs 82
408     };
409    
410     inline
411     bool
412     DataTagged::isCurrentTag(int tag) const
413     {
414     DataMapType::const_iterator pos(m_offsetLookup.find(tag));
415     return (pos!=m_offsetLookup.end());
416     }
417    
418     inline
419     DataArrayView&
420     DataTagged::getDefaultValue()
421     {
422     // The default value is always the first value.
423     return getPointDataView();
424     }
425    
426     inline
427     const DataArrayView&
428     DataTagged::getDefaultValue() const
429     {
430     // The default value is always the first value.
431     return getPointDataView();
432     }
433    
434 jgs 496 inline
435     const DataTagged::DataMapType&
436     DataTagged::getTagLookup() const
437     {
438     return m_offsetLookup;
439     }
440    
441     inline
442     DataArrayView::ValueType::size_type
443     DataTagged::getLength() const
444     {
445     return m_data.size();
446     }
447    
448 jgs 82 } // end of namespace
449    
450     #endif

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26