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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

Properties

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

  ViewVC Help
Powered by ViewVC 1.1.26