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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 480 - (show annotations)
Wed Feb 1 05:15:12 2006 UTC (13 years, 8 months ago) by jgs
File size: 13096 byte(s)
rationalise #includes and forward declarations

1 // $Id$
2
3 /*
4 ******************************************************************************
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
17 #include "DataTagged.h"
18 #include "DataConstant.h"
19 #include "DataException.h"
20
21 using namespace std;
22
23 namespace escript {
24
25 DataTagged::DataTagged()
26 : DataAbstract(FunctionSpace())
27 {
28 // create a scalar default value
29 m_data.resize(1,0.,1);
30 DataArrayView temp(m_data,DataArrayView::ShapeType());
31 setPointDataView(temp);
32 }
33
34 DataTagged::DataTagged(const TagListType& tagKeys,
35 const ValueListType& values,
36 const DataArrayView& defaultValue,
37 const FunctionSpace& what)
38 : DataAbstract(what)
39 {
40 // initialise the array of data values
41 // the default value is always the first item in the values list
42 int len = defaultValue.noValues();
43 m_data.resize(len,0.,len);
44 for (int i=0; i<defaultValue.noValues(); i++) {
45 m_data[i]=defaultValue.getData(i);
46 }
47
48 // create the data view
49 DataArrayView temp(m_data,defaultValue.getShape());
50 setPointDataView(temp);
51
52 // add remaining tags and values
53 addTaggedValues(tagKeys,values);
54 }
55
56 DataTagged::DataTagged(const FunctionSpace& what,
57 const DataArrayView::ShapeType &shape,
58 const int tags[],
59 const ValueType &data)
60 : DataAbstract(what)
61 {
62 // copy the data
63 m_data=data;
64
65 // create the view of the data
66 DataArrayView tempView(m_data,shape);
67 setPointDataView(tempView);
68
69 // create the tag lookup map
70 for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
71 m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
72 }
73 }
74
75 DataTagged::DataTagged(const DataTagged& other)
76 : DataAbstract(other.getFunctionSpace()),
77 m_data(other.m_data),
78 m_offsetLookup(other.m_offsetLookup)
79 {
80 // create the data view
81 DataArrayView temp(m_data,other.getPointDataView().getShape());
82 setPointDataView(temp);
83 }
84
85 DataTagged::DataTagged(const DataConstant& other)
86 : DataAbstract(other.getFunctionSpace())
87 {
88 // fill the default value with the constant value item from "other"
89 const DataArrayView& value=other.getPointDataView();
90 int len = value.noValues();
91 m_data.resize(len,0.,len);
92 for (int i=0; i<value.noValues(); i++) {
93 m_data[i]=value.getData(i);
94 }
95
96 // create the data view
97 DataArrayView temp(m_data,value.getShape());
98 setPointDataView(temp);
99 }
100
101 DataTagged::DataTagged(const DataTagged& other,
102 const DataArrayView::RegionType& region)
103 : DataAbstract(other.getFunctionSpace())
104 {
105 // get the shape of the slice to copy from other
106 DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
107 DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
108
109 // allocate enough space for all values
110 int len = DataArrayView::noValues(shape)*(other.m_offsetLookup.size()+1);
111 m_data.resize(len,0.,len);
112
113 // create the data view
114 DataArrayView temp(m_data,shape);
115 setPointDataView(temp);
116
117 // copy the default value
118 getDefaultValue().copySlice(other.getDefaultValue(),region_loop_range);
119
120 // loop through the tag values copying these
121 DataMapType::const_iterator pos;
122 DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();
123 for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
124 getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,region_loop_range);
125 m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
126 tagOffset+=getPointDataView().noValues();
127 }
128 }
129
130 void
131 DataTagged::reshapeDataPoint(const DataArrayView::ShapeType& shape)
132 {
133 // can only reshape a rank zero data point
134 if (getPointDataView().getRank()!=0) {
135 stringstream temp;
136 temp << "Error - Can only reshape Data with data points of rank 0. "
137 << "This Data has data points with rank: "
138 << getPointDataView().getRank();
139 throw DataException(temp.str());
140 }
141
142 // allocate enough space for all values
143 DataArrayView::ValueType newData(DataArrayView::noValues(shape)*(m_offsetLookup.size()+1));
144 DataArrayView newView(newData,shape);
145 newView.copy(0,getDefaultValue()());
146
147 // loop through the tag values
148 DataMapType::iterator pos;
149 DataArrayView::ValueType::size_type tagOffset=DataArrayView::noValues(shape);
150 for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++){
151 newView.copy(tagOffset,m_data[pos->second]);
152 pos->second=tagOffset;
153 tagOffset+=DataArrayView::noValues(shape);
154 }
155 m_data=newData;
156 DataArrayView temp(m_data,shape);
157 setPointDataView(temp);
158 }
159
160 DataAbstract*
161 DataTagged::getSlice(const DataArrayView::RegionType& region) const
162 {
163 return new DataTagged(*this,region);
164 }
165
166 void
167 DataTagged::setSlice(const DataAbstract* value,
168 const DataArrayView::RegionType& region)
169 {
170 const DataTagged* tempDataTag=dynamic_cast<const DataTagged*>(value);
171 if (tempDataTag==0) {
172 throw DataException("Programming error - casting to DataTagged.");
173 }
174
175 DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
176 DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
177 if (getPointDataView().getRank()!=region.size()) {
178 throw DataException("Error - Invalid slice region.");
179 }
180 if (tempDataTag->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
181 throw DataException (value->getPointDataView().createShapeErrorMessage(
182 "Error - Couldn't copy slice due to shape mismatch.",shape));
183 }
184
185 getDefaultValue().copySliceFrom(tempDataTag->getDefaultValue(),region_loop_range);
186
187 // loop through the tag values
188 DataMapType::const_iterator pos;
189 for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
190 getDataPointByTag(pos->first).copySliceFrom(tempDataTag->getDataPointByTag(pos->first),region_loop_range);
191 }
192 }
193
194 int
195 DataTagged::getTagNumber(int dpno)
196 {
197 //
198 // Get the number of samples and data-points per sample
199 int numSamples = getNumSamples();
200 int numDataPointsPerSample = getNumDPPSample();
201 int numDataPoints = numSamples * numDataPointsPerSample;
202
203 if (numDataPointsPerSample==0) {
204 throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
205 }
206
207 if (dpno<0 || dpno>numDataPoints) {
208 throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
209 }
210
211 //
212 // Determine the sample number which corresponds to this data-point number
213 int sampleNo = dpno / numDataPointsPerSample;
214
215 //
216 // Determine the tag number which corresponds to this sample number
217 int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);
218
219 //
220 // return the tag number
221 return(tagNo);
222 }
223
224 void
225 DataTagged::setTaggedValue(int tagKey,
226 const DataArrayView& value)
227 {
228 if (!getPointDataView().checkShape(value.getShape())) {
229 throw DataException(getPointDataView().createShapeErrorMessage(
230 "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));
231 }
232 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
233 if (pos==m_offsetLookup.end()) {
234 // tag couldn't be found so use addTaggedValue
235 addTaggedValue(tagKey,value);
236 } else {
237 // copy the values into the data array at the offset determined by m_offsetLookup
238 int offset=pos->second;
239 for (int i=0; i<getPointDataView().noValues(); i++) {
240 m_data[offset+i]=value.getData(i);
241 }
242 }
243 }
244
245 void
246 DataTagged::addTaggedValue(int tagKey,
247 const DataArrayView& value)
248 {
249 if (!getPointDataView().checkShape(value.getShape())) {
250 throw DataException(getPointDataView().createShapeErrorMessage(
251 "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));
252 }
253 DataMapType::iterator pos(m_offsetLookup.find(tagKey));
254 if (pos!=m_offsetLookup.end()) {
255 // tag already exists so use setTaggedValue
256 setTaggedValue(tagKey,value);
257 } else {
258 // save the key and the location of its data in the lookup tab
259 m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
260 // add the data given in "value" at the end of m_data
261 // need to make a temp copy of m_data, resize m_data, then copy
262 // all the old values plus the value to be added back into m_data
263 ValueType m_data_temp(m_data);
264 int oldSize=m_data.size();
265 int newSize=m_data.size()+value.noValues();
266 m_data.resize(newSize,0.,newSize);
267 for (int i=0;i<oldSize;i++) {
268 m_data[i]=m_data_temp[i];
269 }
270 for (int i=0;i<value.noValues();i++) {
271 m_data[oldSize+i]=value.getData(i);
272 }
273 }
274 }
275
276 void
277 DataTagged::setTaggedValues(const TagListType& tagKeys,
278 const ValueListType& values)
279 {
280 addTaggedValues(tagKeys,values);
281 }
282
283 void
284 DataTagged::addTaggedValues(const TagListType& tagKeys,
285 const ValueListType& values)
286 {
287 if (values.size()==0) {
288 // copy the default value for each of the tags
289 TagListType::const_iterator iT;
290 for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
291 // the point data view for DataTagged points at the default value
292 addTaggedValue(*iT,getPointDataView());
293 }
294 } else if (values.size()==1 && tagKeys.size()>1) {
295 // assume the one value will be used for all tag values
296 TagListType::const_iterator iT;
297 for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
298 addTaggedValue(*iT,values[0]);
299 }
300 } else {
301 if (tagKeys.size()!=values.size()) {
302 stringstream temp;
303 temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
304 << " doesn't match the number of values: " << values.size();
305 throw DataException(temp.str());
306 } else {
307 for (int i=0;i<tagKeys.size();i++) {
308 addTaggedValue(tagKeys[i],values[i]);
309 }
310 }
311 }
312 }
313
314 double*
315 DataTagged::getSampleDataByTag(int tag)
316 {
317 DataMapType::iterator pos(m_offsetLookup.find(tag));
318 if (pos==m_offsetLookup.end()) {
319 // tag couldn't be found so return the default value
320 return &(m_data[0]);
321 } else {
322 // return the data-point corresponding to the given tag
323 return &(m_data[pos->second]);
324 }
325 }
326
327 string
328 DataTagged::toString() const
329 {
330 stringstream temp;
331 DataMapType::const_iterator i;
332 temp << "Tag(Default)" << endl;
333 temp << getDefaultValue().toString() << endl;
334 // create a temporary view as the offset will be changed
335 DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
336 for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
337 temp << "Tag(" << i->first << ")" << endl;
338 tempView.setOffset(i->second);
339 temp << tempView.toString() << endl;
340 }
341 return temp.str();
342 }
343
344 DataArrayView
345 DataTagged::getDataPointByTag(int tag) const
346 {
347 DataMapType::const_iterator pos(m_offsetLookup.find(tag));
348 DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
349 if (pos!=m_offsetLookup.end()) {
350 offset=pos->second;
351 }
352 DataArrayView temp(getPointDataView());
353 temp.setOffset(offset);
354 return temp;
355 }
356
357 DataArrayView::ValueType::size_type
358 DataTagged::getPointOffset(int sampleNo,
359 int dataPointNo) const
360 {
361 int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
362 DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
363 DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
364 if (pos!=m_offsetLookup.end()) {
365 offset=pos->second;
366 }
367 return offset;
368 }
369
370 DataArrayView
371 DataTagged::getDataPoint(int sampleNo,
372 int dataPointNo)
373 {
374 EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
375 int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
376 return getDataPointByTag(tagKey);
377 }
378
379 const DataTagged::DataMapType&
380 DataTagged::getTagLookup() const
381 {
382 return m_offsetLookup;
383 }
384
385 DataArrayView::ValueType::size_type
386 DataTagged::getLength() const
387 {
388 return m_data.size();
389 }
390
391 int
392 DataTagged::archiveData(ofstream& archiveFile,
393 const DataArrayView::ValueType::size_type noValues) const
394 {
395 return(m_data.archiveData(archiveFile, noValues));
396 }
397
398 int
399 DataTagged::extractData(ifstream& archiveFile,
400 const DataArrayView::ValueType::size_type noValues)
401 {
402 return(m_data.extractData(archiveFile, noValues));
403 }
404
405 } // end of namespace

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26