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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/esys2/escript/src/Data/DataTagged.cpp revision 119 by jgs, Tue Apr 12 04:45:05 2005 UTC trunk/escript/src/DataTagged.cpp revision 1811 by ksteube, Thu Sep 25 23:11:13 2008 UTC
# Line 1  Line 1 
 // $Id$  
 /*  
  ******************************************************************************  
  *                                                                            *  
  *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *  
  *                                                                            *  
  * This software is the property of ACcESS. No part of this code              *  
  * may be copied in any form or by any means without the expressed written    *  
  * consent of ACcESS.  Copying, use or modification of this software          *  
  * by any unauthorised person is illegal unless that person has a software    *  
  * license agreement with ACcESS.                                             *  
  *                                                                            *  
  ******************************************************************************  
 */  
   
 #include "escript/Data/DataTagged.h"  
 #include "escript/Data/DataConstant.h"  
 #include "escript/Data/DataExpanded.h"  
 #include "escript/Data/DataException.h"  
1    
2  #include <sstream>  /*******************************************************
3    *
4    * Copyright (c) 2003-2008 by University of Queensland
5    * Earth Systems Science Computational Center (ESSCC)
6    * http://www.uq.edu.au/esscc
7    *
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    #include "DataTagged.h"
16    #include "esysUtils/esys_malloc.h"
17    
18    #include "DataConstant.h"
19    #include "DataException.h"
20    #ifdef USE_NETCDF
21    #include <netcdfcpp.h>
22    #endif
23    #include "DataMaths.h"
24    
25  using namespace std;  using namespace std;
26    
27  namespace escript {  namespace escript {
28    
29  DataTagged::DataTagged():  DataTagged::DataTagged()
30    DataAbstract(FunctionSpace())    : DataAbstract(FunctionSpace(),DataTypes::scalarShape)
31  {  {
32    //    // default constructor
33    
34    // create a scalar default value    // create a scalar default value
35    m_data.push_back(0.0);    m_data.resize(1,0.,1);
36    DataArrayView temp(m_data,DataArrayView::ShapeType());  /*  DataArrayView temp(m_data,DataTypes::ShapeType());
37    setPointDataView(temp);    setPointDataView(temp);*/
38  }  }
39    
40    // DataTagged::DataTagged(const TagListType& tagKeys,
41    //             const ValueListType& values,
42    //             const DataArrayView& defaultValue,
43    //             const FunctionSpace& what)
44    //   : DataAbstract(what)
45    // {
46    //   // constructor
47    //
48    //   // initialise the array of data values
49    //   // the default value is always the first item in the values list
50    //   int len = defaultValue.noValues();
51    //   m_data.resize(len,0.,len);
52    //   for (int i=0; i<defaultValue.noValues(); i++) {
53    //     m_data[i]=defaultValue.getData(i);
54    //   }
55    //
56    //   // create the data view
57    //   DataArrayView temp(m_data,defaultValue.getShape());
58    //   setPointDataView(temp);
59    //
60    //   // add remaining tags and values
61    //   addTaggedValues(tagKeys,values);
62    // }
63    
64  DataTagged::DataTagged(const TagListType& tagKeys,  DataTagged::DataTagged(const FunctionSpace& what,
65                 const ValueListType& values,                         const DataTypes::ShapeType &shape,
66                 const DataArrayView& defaultValue,                         const int tags[],
67                 const FunctionSpace& what)                         const ValueType& data)
68    : DataAbstract(what)    : DataAbstract(what,shape)
69  {  {
70    //    // alternative constructor
71    // Initialise the array of data values    // not unit_tested tested yet
72    // The default value is always the first item in the values list    // It is not explicitly unit tested yet, but it is called from DataFactory
73    m_data.insert(m_data.end(), &defaultValue.getData(0), &defaultValue.getData(defaultValue.noValues()) );  
74    // create the data view    if (!what.canTag())
75    DataArrayView temp(m_data,defaultValue.getShape());    {
76    setPointDataView(temp);      throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
77    // add remaining tags and values    }
78    addTaggedValues(tagKeys,values);    // copy the data
79      m_data=data;
80    
81      // create the view of the data
82    //   DataArrayView tempView(m_data,shape);
83    //   setPointDataView(tempView);
84    
85      // we can't rely on the tag array to give us the number of tags so
86      // use the data we have been passed
87      int valsize=DataTypes::noValues(shape);
88      int ntags=data.size()/valsize;
89    
90      // create the tag lookup map
91      // we assume that the first value and first tag are the default value so we skip
92      for (int i=1;i<ntags;++i)
93      {
94        m_offsetLookup.insert(DataMapType::value_type(tags[i],i*valsize));
95      }
96  }  }
97    
98  DataTagged::DataTagged(const FunctionSpace& what,  DataTagged::DataTagged(const FunctionSpace& what,
99                         const DataArrayView::ShapeType &shape,                         const DataTypes::ShapeType &shape,
100                         const int tags[],                         const TagListType& tags,
101                         const DataArrayView::ValueType &data)                         const ValueType& data)
102    : DataAbstract(what)    : DataAbstract(what,shape)
103  {  {
104    //    // alternative constructor
105    // copy the data in the correct format  
106      if (!what.canTag())
107      {
108        throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
109      }
110    
111      // copy the data
112    m_data=data;    m_data=data;
113    //  
114    // create the view of the data    // create the view of the data
115    DataArrayView tempView(m_data,shape);  //   DataArrayView tempView(m_data,shape);
116    setPointDataView(tempView);  //   setPointDataView(tempView);
117    //  
118    // create the tag lookup map    // create the tag lookup map
119    for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {  
120      m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));  //   for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
121    //     m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
122    //   }
123    
124      // The above code looks like it will create a map the wrong way around
125    
126      int valsize=DataTypes::noValues(shape);
127      int npoints=(data.size()/valsize)-1;
128      int ntags=tags.size();
129      if (ntags>npoints)
130      {     // This throw is not unit tested yet
131        throw DataException("Programming error - Too many tags for the supplied values.");
132      }
133    
134      // create the tag lookup map
135      // we assume that the first value is the default value so we skip it (hence the i+1 below)
136      for (int i=0;i<ntags;++i)
137      {
138        m_offsetLookup.insert(DataMapType::value_type(tags[i],(i+1)*valsize));
139    }    }
140  }  }
141    
142    
143  DataTagged::DataTagged(const DataTagged& other)  DataTagged::DataTagged(const DataTagged& other)
144    : DataAbstract(other.getFunctionSpace()),    : DataAbstract(other.getFunctionSpace(),other.getShape()),
145    m_data(other.m_data),    m_data(other.m_data),
146    m_offsetLookup(other.m_offsetLookup)    m_offsetLookup(other.m_offsetLookup)
147  {  {
148      // copy constructor
149    
150    // create the data view    // create the data view
151    DataArrayView temp(m_data,other.getPointDataView().getShape());  //   DataArrayView temp(m_data,other.getPointDataView().getShape());
152    setPointDataView(temp);  //   setPointDataView(temp);
153  }  }
154    
155  DataTagged::DataTagged(const DataConstant& other)  DataTagged::DataTagged(const DataConstant& other)
156    : DataAbstract(other.getFunctionSpace())    : DataAbstract(other.getFunctionSpace(),other.getShape())
157  {  {
158    //    // copy constructor
159    // Fill the default value with the constant value item from other  
160    const DataArrayView& value=other.getPointDataView();    if (!other.getFunctionSpace().canTag())
161    m_data.insert(m_data.end(), &value.getData(0), &value.getData(value.noValues()) );    {
162    // create the data view      throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
163    DataArrayView temp(m_data,value.getShape());    }
164    setPointDataView(temp);  
165      // fill the default value with the constant value item from "other"
166    //   const DataArrayView& value=other.getPointDataView();
167      int len = other.getNoValues();
168      m_data.resize(len,0.,len);
169      for (int i=0; i<len; i++) {
170        m_data[i]=other.getVector()[i];
171      }
172    
173    //   // create the data view
174    //   DataArrayView temp(m_data,value.getShape());
175    //   setPointDataView(temp);
176    }
177    
178    
179    // Create a new object by copying tags
180    DataTagged::DataTagged(const FunctionSpace& what,
181                 const DataTypes::ShapeType& shape,
182             const DataTypes::ValueType& defaultvalue,
183                 const DataTagged* tagsource)
184     : DataAbstract(what,shape)
185    {
186    // This constructor has not been unit tested yet
187    
188      if (defaultvalue.size()!=DataTypes::noValues(shape)) {
189        throw DataException("Programming error - defaultvalue does not match supplied shape.");
190      }
191    
192    
193      if (!what.canTag())
194      {
195        throw DataException("Programming error - DataTag created with a non-taggable FunctionSpace.");
196      }
197    
198      if (tagsource!=0)
199      {
200        int numtags=tagsource->getTagLookup().size();
201        //  m_offsetLookup.reserve(tagsource.getTagLookup().size());
202        m_data.resize(defaultvalue.size(),0.);  // since this is tagged data, we should have blocksize=1
203    
204           DataTagged::DataMapType::const_iterator i;
205           for (i=tagsource->getTagLookup().begin();i!=tagsource->getTagLookup().end();i++) {
206          addTag(i->first);
207           }
208      }
209      else
210      {
211        m_data.resize(defaultvalue.size());
212      }
213    
214    
215    
216      // need to set the default value ....
217      for (int i=0; i<defaultvalue.size(); i++) {
218         m_data[i]=defaultvalue[i];
219      }
220    }
221    
222    DataAbstract*
223    DataTagged::deepCopy()
224    {
225      return new DataTagged(*this);
226    }
227    
228    DataAbstract*
229    DataTagged::getSlice(const DataTypes::RegionType& region) const
230    {
231      return new DataTagged(*this, region);
232  }  }
233    
234  DataTagged::DataTagged(const DataTagged& other,  DataTagged::DataTagged(const DataTagged& other,
235                 const DataArrayView::RegionType& region)                 const DataTypes::RegionType& region)
236    : DataAbstract(other.getFunctionSpace())    : DataAbstract(other.getFunctionSpace(),DataTypes::getResultSliceShape(region))
237  {  {
238    //    // slice constructor
239    
240    // get the shape of the slice to copy from other    // get the shape of the slice to copy from other
241    DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));    DataTypes::ShapeType regionShape(DataTypes::getResultSliceShape(region));
242    DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);    DataTypes::RegionLoopRangeType regionLoopRange=DataTypes::getSliceRegionLoopRange(region);
243    // allocate enough space for all values  
244    m_data.resize(DataArrayView::noValues(shape)*(other.m_offsetLookup.size()+1));    // allocate enough space in this for all values
245      // (need to add one to allow for the default value)
246      int len = DataTypes::noValues(regionShape)*(other.m_offsetLookup.size()+1);
247      m_data.resize(len,0.0,len);
248    
249    // create the data view    // create the data view
250    DataArrayView temp(m_data,shape);  //   DataArrayView temp(m_data,regionShape);
251    setPointDataView(temp);  //   setPointDataView(temp);
252    // copy the default value  
253    getDefaultValue().copySlice(other.getDefaultValue(),region_loop_range);    // copy the default value from other to this
254    //  //   getDefaultValue().copySlice(other.getDefaultValue(), regionLoopRange);
255    // Loop through the tag values copying these    const DataTypes::ShapeType& otherShape=other.getShape();
256      const DataTypes::ValueType& otherData=other.getVector();
257      DataTypes::copySlice(getVector(),getShape(),getDefaultOffset(),otherData,otherShape,other.getDefaultOffset(), regionLoopRange);
258    
259      // loop through the tag values copying these
260    DataMapType::const_iterator pos;    DataMapType::const_iterator pos;
261    DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();    DataTypes::ValueType::size_type tagOffset=getNoValues();
262    for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();++pos){    for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
263      getPointDataView().copySlice(tagOffset,other.getPointDataView(), pos->second,region_loop_range);  //     getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,regionLoopRange);
264        DataTypes::copySlice(m_data,getShape(),tagOffset,otherData, otherShape, pos->second, regionLoopRange);
265      m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));      m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
266      tagOffset+=getPointDataView().noValues();      tagOffset+=getNoValues();
267    }    }
268  }  }
269    
270  void  void
271  DataTagged::reshapeDataPoint(const DataArrayView::ShapeType& shape)  DataTagged::setSlice(const DataAbstract* other,
272                         const DataTypes::RegionType& region)
273  {  {
274    //  
275    // can only reshape a rank zero data point    // other must be another DataTagged object
276    if (getPointDataView().getRank()!=0) {    // Data:setSlice implementation should ensure this
277      stringstream temp;    const DataTagged* otherTemp=dynamic_cast<const DataTagged*>(other);
278      temp << "Error - Can only reshape Data with data points of rank 0. "    if (otherTemp==0) {
279       << "This Data has data points with rank: "      throw DataException("Programming error - casting to DataTagged.");
280       << getPointDataView().getRank();    }
281      throw DataException(temp.str());  
282      // determine shape of the specified region
283      DataTypes::ShapeType regionShape(DataTypes::getResultSliceShape(region));
284    
285      // modify region specification as needed to match rank of this object
286      DataTypes::RegionLoopRangeType regionLoopRange=DataTypes::getSliceRegionLoopRange(region);
287    
288      // ensure rank/shape of this object is compatible with specified region
289      if (getRank()!=region.size()) {
290        throw DataException("Error - Invalid slice region.");
291      }
292      if (otherTemp->getRank()>0 && !DataTypes::checkShape(other->getShape(),regionShape)) {
293        throw DataException (DataTypes::createShapeErrorMessage(
294                             "Error - Couldn't copy slice due to shape mismatch.",regionShape,other->getShape()));
295      }
296    
297      const DataTypes::ValueType& otherData=otherTemp->getVector();
298      const DataTypes::ShapeType& otherShape=otherTemp->getShape();
299      // copy slice from other default value to this default value
300    //   getDefaultValue().copySliceFrom(otherTemp->getDefaultValue(), regionLoopRange);
301      DataTypes::copySliceFrom(m_data,getShape(),getDefaultOffset(),otherData,otherShape,otherTemp->getDefaultOffset(),regionLoopRange);
302    
303      // loop through tag values in other, adding any which aren't in this, using default value
304      DataMapType::const_iterator pos;
305      for (pos=otherTemp->m_offsetLookup.begin();pos!=otherTemp->m_offsetLookup.end();pos++) {
306        if (!isCurrentTag(pos->first)) {
307          addTag(pos->first);
308        }
309      }
310    
311      // loop through the tag values copying slices from other to this
312      for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
313    //     getDataPointByTag(pos->first).copySliceFrom(otherTemp->getDataPointByTag(pos->first), regionLoopRange);
314        DataTypes::copySliceFrom(m_data,getShape(),getOffsetForTag(pos->first),otherData, otherShape, otherTemp->getOffsetForTag(pos->first), regionLoopRange);
315    
316    }    }
   //  
   // allocate enough space for all values  
   DataArrayView::ValueType newData(DataArrayView::noValues(shape)*(m_offsetLookup.size()+1));  
   DataArrayView newView(newData,shape);  
   newView.copy(0,getDefaultValue()());  
   //  
   // Loop through the tag values  
   DataMapType::iterator pos;  
   DataArrayView::ValueType::size_type tagOffset=DataArrayView::noValues(shape);  
   for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();++pos){  
     newView.copy(tagOffset,m_data[pos->second]);  
     pos->second=tagOffset;  
     tagOffset+=DataArrayView::noValues(shape);  
   }  
   m_data=newData;  
   DataArrayView temp(m_data,shape);  
   setPointDataView(temp);  
 }  
317    
 DataAbstract*  
 DataTagged::getSlice(const DataArrayView::RegionType& region) const  
 {  
   return new DataTagged(*this,region);  
318  }  }
319    
320  void  int
321  DataTagged::setSlice(const DataAbstract* value,  DataTagged::getTagNumber(int dpno)
                      const DataArrayView::RegionType& region)  
322  {  {
   const DataTagged* tempDataTag=dynamic_cast<const DataTagged*>(value);  
   if (tempDataTag==0) {  
     throw DataException("Programming error - casting to DataTagged.");  
   }  
   //  
   DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));  
   DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);  
323    //    //
324    if (getPointDataView().getRank()!=region.size()) {    // Get the number of samples and data-points per sample
325      throw DataException("Error - Invalid slice region.");    int numSamples = getNumSamples();
326      int numDataPointsPerSample = getNumDPPSample();
327      int numDataPoints = numSamples * numDataPointsPerSample;
328    
329      if (numDataPointsPerSample==0) {
330        throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
331    }    }
332    if (tempDataTag->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {  
333      throw DataException (value->getPointDataView().createShapeErrorMessage(    if (dpno<0 || dpno>numDataPoints-1) {
334                  "Error - Couldn't copy slice due to shape mismatch.",shape));      throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
335    }    }
336    
337    //    //
338    getDefaultValue().copySliceFrom(tempDataTag->getDefaultValue(),region_loop_range);    // Determine the sample number which corresponds to this data-point number
339      int sampleNo = dpno / numDataPointsPerSample;
340    
341    //    //
342    // Loop through the tag values    // Determine the tag number which corresponds to this sample number
343    DataMapType::const_iterator pos;    int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);
344    for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();++pos){  
345      getDataPointByTag(pos->first).copySliceFrom(tempDataTag->getDataPointByTag(pos->first),region_loop_range);    //
346    }    // return the tag number
347      return(tagNo);
348  }  }
349    
350    // void
351    // DataTagged::setTaggedValues(const TagListType& tagKeys,
352    //                             const ValueListType& values)
353    // {
354    //   addTaggedValues(tagKeys,values);
355    // }
356    
357  void  void
358  DataTagged::setTaggedValue(int tagKey,  DataTagged::setTaggedValue(int tagKey,
359                             const DataArrayView& value)                 const DataTypes::ShapeType& pointshape,
360  {                             const ValueType& value,
361                   int dataOffset)
362    {
363      if (!DataTypes::checkShape(getShape(), pointshape)) {
364          throw DataException(DataTypes::createShapeErrorMessage(
365                              "Error - Cannot setTaggedValue due to shape mismatch.", pointshape,getShape()));
366      }
367    DataMapType::iterator pos(m_offsetLookup.find(tagKey));    DataMapType::iterator pos(m_offsetLookup.find(tagKey));
368    if (pos==m_offsetLookup.end()) {    if (pos==m_offsetLookup.end()) {
369      //      // tag couldn't be found so use addTaggedValue
370      // tag couldn't be found so add as a new tag      addTaggedValue(tagKey,pointshape, value, dataOffset);
     addTaggedValue(tagKey,value);  
371    } else {    } else {
372      if (!getPointDataView().checkShape(value.getShape())) {      // copy the values into the data array at the offset determined by m_offsetLookup
373        throw DataException(getPointDataView().createShapeErrorMessage(      int offset=pos->second;
374           "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));      for (int i=0; i<getNoValues(); i++) {
375          m_data[offset+i]=value[i+dataOffset];
376      }      }
     //  
     // copy the values into tagged data storage  
     copy(&value.getData(0), &value.getData(getPointDataView().noValues()), &m_data[pos->second]);  
377    }    }
378  }  }
379    
380    
381    /*
382  void  void
383  DataTagged::setTaggedValues(const TagListType& tagKeys,  DataTagged::setTaggedValue(int tagKey,
384                              const ValueListType& values)                             const DataArrayView& value)
385  {  {
386    for (int i=0;i<tagKeys.size();++i) {    if (!getPointDataView().checkShape(value.getShape())) {
387      setTaggedValue(tagKeys[i],values[i]);        throw DataException(DataTypes::createShapeErrorMessage(
388                              "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape(),getShape()));
389    }    }
390  }    DataMapType::iterator pos(m_offsetLookup.find(tagKey));
391      if (pos==m_offsetLookup.end()) {
392        // tag couldn't be found so use addTaggedValue
393        addTaggedValue(tagKey,value);
394      } else {
395        // copy the values into the data array at the offset determined by m_offsetLookup
396        int offset=pos->second;
397        for (int i=0; i<getPointDataView().noValues(); i++) {
398          m_data[offset+i]=value.getData(i);
399        }
400      }
401    }*/
402    
403    // void
404    // DataTagged::addTaggedValues(const TagListType& tagKeys,
405    //                             const ValueListType& values)
406    // {
407    //   if (values.size()==0) {
408    //     // copy the current default value for each of the tags
409    //     TagListType::const_iterator iT;
410    //     for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
411    //       // the point data view for DataTagged points at the default value
412    //       addTaggedValue(*iT,getPointDataView());
413    //     }
414    //   } else if (values.size()==1 && tagKeys.size()>1) {
415    //     // assume the one given value will be used for all tag values
416    //     TagListType::const_iterator iT;
417    //     for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
418    //       addTaggedValue(*iT,values[0]);
419    //     }
420    //   } else {
421    //     if (tagKeys.size()!=values.size()) {
422    //       stringstream temp;
423    //       temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
424    //     << " doesn't match number of values: " << values.size();
425    //       throw DataException(temp.str());
426    //     } else {
427    //       unsigned int i;
428    //       for (i=0;i<tagKeys.size();i++) {
429    //         addTaggedValue(tagKeys[i],values[i]);
430    //       }
431    //     }
432    //   }
433    // }
434    
435    
436  void  void
437  DataTagged::addTaggedValue(int tagKey,  DataTagged::addTaggedValues(const TagListType& tagKeys,
438                             const DataArrayView& value)                              const ValueBatchType& values,
439                                const ShapeType& vShape)
440  {  {
441    if (!getPointDataView().checkShape(value.getShape())) {    DataTypes::ValueType t(values.size(),0);
442      throw DataException(getPointDataView().createShapeErrorMessage(    for (int i=0;i<values.size();++i)
443           "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));    {
444        t[i]=values[i];
445    }    }
446    //    addTaggedValues(tagKeys,t,vShape);
   // save the key and the location of its data  
   m_offsetLookup.insert( DataMapType::value_type(tagKey,m_data.size()) );  
   //  
   // insert the data given in value at the end of m_data  
   m_data.insert( m_data.end(), &(value.getData(0)), &(value.getData(value.noValues())) );  
447  }  }
448    
449    
450    // Note: The check to see if vShape==our shape is done in the addTaggedValue method
451  void  void
452  DataTagged::addTaggedValues(const TagListType& tagKeys,  DataTagged::addTaggedValues(const TagListType& tagKeys,
453                              const ValueListType& values)                              const ValueType& values,
454                                const ShapeType& vShape)
455  {  {
456      int n=getNoValues();
457      int numVals=values.size()/n;
458    if (values.size()==0) {    if (values.size()==0) {
459      //      // copy the current default value for each of the tags
     // Copy the default value for each of the tags  
460      TagListType::const_iterator iT;      TagListType::const_iterator iT;
461      for (iT=tagKeys.begin();iT!=tagKeys.end();++iT) {      for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
       //  
462        // the point data view for DataTagged points at the default value        // the point data view for DataTagged points at the default value
463        addTaggedValue(*iT,getPointDataView());        addTag(*iT);
464      }      }
465    } else if (values.size()==1 && tagKeys.size()>1) {    } else if (numVals==1 && tagKeys.size()>1) {
466      //      // assume the one given value will be used for all tag values
     // assume the one value will be used for all tag values  
     // Copy the input data  
467      TagListType::const_iterator iT;      TagListType::const_iterator iT;
468      for (iT=tagKeys.begin();iT!=tagKeys.end();++iT) {      for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
469        addTaggedValue(*iT,values[0]);        addTaggedValue(*iT, vShape, values,0);
470      }      }
471    } else {    } else {
472      if (tagKeys.size()!=values.size()) {      if (tagKeys.size()!=numVals) {
473        stringstream temp;        stringstream temp;
474        temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()        temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
475         << " doesn't match the number of values: " << values.size();         << " doesn't match number of values: " << values.size();
476        throw DataException(temp.str());        throw DataException(temp.str());
477      } else {      } else {
478        for (int i=0;i<tagKeys.size();++i) {        unsigned int i;
479          addTaggedValue(tagKeys[i],values[i]);        int offset=0;
480          for (i=0;i<tagKeys.size();i++ ,offset+=n) {
481            addTaggedValue(tagKeys[i],vShape,values,offset);
482        }        }
483      }      }
484    }    }
485  }  }
486    
487    
488    
489    
490    void
491    DataTagged::addTaggedValue(int tagKey,
492                   const DataTypes::ShapeType& pointshape,
493                               const ValueType& value,
494                   int dataOffset)
495    {
496      if (!DataTypes::checkShape(getShape(), pointshape)) {
497        throw DataException(DataTypes::createShapeErrorMessage(
498                            "Error - Cannot addTaggedValue due to shape mismatch.", pointshape,getShape()));
499      }
500      DataMapType::iterator pos(m_offsetLookup.find(tagKey));
501      if (pos!=m_offsetLookup.end()) {
502        // tag already exists so use setTaggedValue
503        setTaggedValue(tagKey,pointshape, value, dataOffset);
504      } else {
505        // save the key and the location of its data in the lookup tab
506        m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
507        // add the data given in "value" at the end of m_data
508        // need to make a temp copy of m_data, resize m_data, then copy
509        // all the old values plus the value to be added back into m_data
510        ValueType m_data_temp(m_data);
511        int oldSize=m_data.size();
512        int newSize=m_data.size()+getNoValues();
513        m_data.resize(newSize,0.,newSize);
514        for (int i=0;i<oldSize;i++) {
515          m_data[i]=m_data_temp[i];
516        }
517        for (int i=0;i<getNoValues();i++) {
518          m_data[oldSize+i]=value[i+dataOffset];
519        }
520      }
521    }
522    
523    
524    
525    
526    // void
527    // DataTagged::addTaggedValue(int tagKey,
528    //                            const DataArrayView& value)
529    // {
530    //   if (!getPointDataView().checkShape(value.getShape())) {
531    //     throw DataException(DataTypes::createShapeErrorMessage(
532    //                         "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape(),getShape()));
533    //   }
534    //   DataMapType::iterator pos(m_offsetLookup.find(tagKey));
535    //   if (pos!=m_offsetLookup.end()) {
536    //     // tag already exists so use setTaggedValue
537    //     setTaggedValue(tagKey,value);
538    //   } else {
539    //     // save the key and the location of its data in the lookup tab
540    //     m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
541    //     // add the data given in "value" at the end of m_data
542    //     // need to make a temp copy of m_data, resize m_data, then copy
543    //     // all the old values plus the value to be added back into m_data
544    //     ValueType m_data_temp(m_data);
545    //     int oldSize=m_data.size();
546    //     int newSize=m_data.size()+value.noValues();
547    //     m_data.resize(newSize,0.,newSize);
548    //     for (int i=0;i<oldSize;i++) {
549    //       m_data[i]=m_data_temp[i];
550    //     }
551    //     for (int i=0;i<value.noValues();i++) {
552    //       m_data[oldSize+i]=value.getData(i);
553    //     }
554    //   }
555    // }
556    
557    
558    void
559    DataTagged::addTag(int tagKey)
560    {
561      DataMapType::iterator pos(m_offsetLookup.find(tagKey));
562      if (pos!=m_offsetLookup.end()) {
563        // tag already exists so use setTaggedValue
564    //    setTaggedValue(tagKey,value);
565      } else {
566        // save the key and the location of its data in the lookup tab
567        m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
568        // add the data given in "value" at the end of m_data
569        // need to make a temp copy of m_data, resize m_data, then copy
570        // all the old values plus the value to be added back into m_data
571        ValueType m_data_temp(m_data);
572        int oldSize=m_data.size();
573        int newSize=m_data.size()+getNoValues();
574        m_data.resize(newSize,0.,newSize);
575        for (int i=0;i<oldSize;i++) {
576          m_data[i]=m_data_temp[i];
577        }
578        for (int i=0;i<getNoValues();i++) {
579          m_data[oldSize+i]=m_data[m_defaultValueOffset+i];
580        }
581      }
582    }
583    
584    
585  double*  double*
586  DataTagged::getSampleDataByTag(int tag)  DataTagged::getSampleDataByTag(int tag)
587  {  {
588    DataMapType::iterator pos(m_offsetLookup.find(tag));    DataMapType::iterator pos(m_offsetLookup.find(tag));
589    if (pos==m_offsetLookup.end()) {    if (pos==m_offsetLookup.end()) {
     //  
590      // tag couldn't be found so return the default value      // tag couldn't be found so return the default value
591      return &(m_data[0]);      return &(m_data[0]);
592    } else {    } else {
     //  
593      // return the data-point corresponding to the given tag      // return the data-point corresponding to the given tag
594      return &(m_data[pos->second]);      return &(m_data[pos->second]);
595    }    }
# Line 283  DataTagged::getSampleDataByTag(int tag) Line 598  DataTagged::getSampleDataByTag(int tag)
598  string  string
599  DataTagged::toString() const  DataTagged::toString() const
600  {  {
601      using namespace escript::DataTypes;
602      string empty="";
603    stringstream temp;    stringstream temp;
604    DataMapType::const_iterator i;    DataMapType::const_iterator i;
605    temp << "Tag(Default)" << endl;    temp << "Tag(Default)" << endl;
606    temp << getDefaultValue().toString() << endl;    temp << pointToString(m_data,getShape(),getDefaultOffset(),empty) << endl;
   //  
607    // create a temporary view as the offset will be changed    // create a temporary view as the offset will be changed
608    DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());  //   DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
609    for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {    for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
610      temp << "Tag(" << i->first << ")" << endl;      temp << "Tag(" << i->first << ")" << endl;
611      tempView.setOffset(i->second);      temp << pointToString(m_data,getShape(),i->second,empty) << endl;
612      temp << tempView.toString() << endl;  //     tempView.setOffset(i->second);
613    //     temp << tempView.toString() << endl;
614    }    }
615    return temp.str();    return temp.str();
616  }  }
617    
618  DataArrayView  DataTypes::ValueType::size_type
619  DataTagged::getDataPointByTag(int tag) const  DataTagged::getPointOffset(int sampleNo,
620                               int dataPointNo) const
621    {
622      int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
623      DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
624      DataTypes::ValueType::size_type offset=m_defaultValueOffset;
625      if (pos!=m_offsetLookup.end()) {
626        offset=pos->second;
627      }
628      return offset;
629    }
630    
631    // DataArrayView
632    // DataTagged::getDataPointByTag(int tag) const
633    // {
634    //   DataMapType::const_iterator pos(m_offsetLookup.find(tag));
635    //   DataTypes::ValueType::size_type offset=m_defaultValueOffset;
636    //   if (pos!=m_offsetLookup.end()) {
637    //     offset=pos->second;
638    //   }
639    //   DataArrayView temp(getPointDataView());
640    //   temp.setOffset(offset);
641    //   return temp;
642    // }
643    //
644    
645    
646    DataTypes::ValueType::size_type
647    DataTagged::getOffsetForTag(int tag) const
648    {
649      DataMapType::const_iterator pos(m_offsetLookup.find(tag));
650      DataTypes::ValueType::size_type offset=m_defaultValueOffset;
651      if (pos!=m_offsetLookup.end()) {
652        offset=pos->second;
653      }
654      return offset;
655    }
656    
657    DataTypes::ValueType::const_reference
658    DataTagged::getDataByTag(int tag, DataTypes::ValueType::size_type i) const
659  {  {
660    DataMapType::const_iterator pos(m_offsetLookup.find(tag));    DataMapType::const_iterator pos(m_offsetLookup.find(tag));
661    DataArrayView::ValueType::size_type offset=m_defaultValueOffset;    DataTypes::ValueType::size_type offset=m_defaultValueOffset;
662    if (pos!=m_offsetLookup.end()) {    if (pos!=m_offsetLookup.end()) {
663      offset=pos->second;      offset=pos->second;
664    }    }
665    DataArrayView temp(getPointDataView());    return m_data[offset+i];
666    /*  DataArrayView temp(getPointDataView());
667    temp.setOffset(offset);    temp.setOffset(offset);
668    return temp;    return temp.getData()[offset+i];*/
669  }  }
670    
671  DataArrayView::ValueType::size_type  
672  DataTagged::getPointOffset(int sampleNo,  DataTypes::ValueType::reference
673                             int dataPointNo) const  DataTagged::getDataByTag(int tag, DataTypes::ValueType::size_type i)
674  {  {
675    int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);    DataMapType::const_iterator pos(m_offsetLookup.find(tag));
676    DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));    DataTypes::ValueType::size_type offset=m_defaultValueOffset;
   DataArrayView::ValueType::size_type offset=m_defaultValueOffset;  
677    if (pos!=m_offsetLookup.end()) {    if (pos!=m_offsetLookup.end()) {
678      offset=pos->second;      offset=pos->second;
679    }    }
680    return offset;    return m_data[offset+i];
681    /*  DataArrayView temp(getPointDataView());
682      temp.setOffset(offset);
683      return temp.getData()[offset+i];*/
684    }
685    
686    
687    
688    
689    
690    
691    // DataArrayView
692    // DataTagged::getDataPoint(int sampleNo,
693    //                          int dataPointNo)
694    // {
695    //   EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
696    //   int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
697    //   return getDataPointByTag(tagKey);
698    // }
699    
700    
701    void
702    DataTagged::symmetric(DataAbstract* ev)
703    {
704      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
705      if (temp_ev==0) {
706        throw DataException("Error - DataTagged::symmetric casting to DataTagged failed (probably a programming error).");
707      }
708      const DataTagged::DataMapType& thisLookup=getTagLookup();
709      DataTagged::DataMapType::const_iterator i;
710      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
711      ValueType& evVec=temp_ev->getVector();
712      const ShapeType& evShape=temp_ev->getShape();
713      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
714          temp_ev->addTag(i->first);
715          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
716    //       DataArrayView thisView=getDataPointByTag(i->first);
717    //       DataArrayView evView=temp_ev->getDataPointByTag(i->first);
718          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
719    
720    //       DataArrayView::symmetric(thisView,0,evView,0);
721          DataMaths::symmetric(m_data,getShape(),offset,evVec, evShape, evoffset);
722      }
723    //   symmetric(m_data,getShape(),getDefaultOffset(),
724      DataMaths::symmetric(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset());
725  }  }
726    
727  DataArrayView  
728  DataTagged::getDataPoint(int sampleNo,  void
729                           int dataPointNo)  DataTagged::nonsymmetric(DataAbstract* ev)
730  {  {
731    EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);    DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
732    int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);    if (temp_ev==0) {
733    return getDataPointByTag(tagKey);      throw DataException("Error - DataTagged::nonsymmetric casting to DataTagged failed (probably a programming error).");
734      }
735      const DataTagged::DataMapType& thisLookup=getTagLookup();
736      DataTagged::DataMapType::const_iterator i;
737      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
738      ValueType& evVec=temp_ev->getVector();
739      const ShapeType& evShape=temp_ev->getShape();
740      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
741          temp_ev->addTag(i->first);
742    /*      DataArrayView thisView=getDataPointByTag(i->first);
743          DataArrayView evView=temp_ev->getDataPointByTag(i->first);*/
744          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
745          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
746          DataMaths::nonsymmetric(m_data,getShape(),offset,evVec, evShape, evoffset);
747      }
748      DataMaths::nonsymmetric(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset());
749    }
750    
751    
752    void
753    DataTagged::trace(DataAbstract* ev, int axis_offset)
754    {
755      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
756      if (temp_ev==0) {
757        throw DataException("Error - DataTagged::trace casting to DataTagged failed (probably a programming error).");
758      }
759      const DataTagged::DataMapType& thisLookup=getTagLookup();
760      DataTagged::DataMapType::const_iterator i;
761      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
762      ValueType& evVec=temp_ev->getVector();
763      const ShapeType& evShape=temp_ev->getShape();
764      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
765          temp_ev->addTag(i->first);
766    //       DataArrayView thisView=getDataPointByTag(i->first);
767    //       DataArrayView evView=temp_ev->getDataPointByTag(i->first);
768          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
769          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
770          DataMaths::trace(m_data,getShape(),offset,evVec, evShape, evoffset, axis_offset);
771      }
772      DataMaths::trace(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset(),axis_offset);
773    }
774    
775    void
776    DataTagged::transpose(DataAbstract* ev, int axis_offset)
777    {
778      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
779      if (temp_ev==0) {
780        throw DataException("Error - DataTagged::transpose casting to DataTagged failed (probably a programming error).");
781      }
782      const DataTagged::DataMapType& thisLookup=getTagLookup();
783      DataTagged::DataMapType::const_iterator i;
784      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
785      ValueType& evVec=temp_ev->getVector();
786      const ShapeType& evShape=temp_ev->getShape();
787      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
788          temp_ev->addTag(i->first);
789    //       DataArrayView thisView=getDataPointByTag(i->first);
790    //       DataArrayView evView=temp_ev->getDataPointByTag(i->first);
791          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
792          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
793          DataMaths::transpose(m_data,getShape(),offset,evVec, evShape, evoffset, axis_offset);
794      }
795      DataMaths::transpose(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset(),axis_offset);
796    }
797    
798    void
799    DataTagged::swapaxes(DataAbstract* ev, int axis0, int axis1)
800    {
801      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
802      if (temp_ev==0) {
803        throw DataException("Error - DataTagged::swapaxes casting to DataTagged failed (probably a programming error).");
804      }
805      const DataTagged::DataMapType& thisLookup=getTagLookup();
806      DataTagged::DataMapType::const_iterator i;
807      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
808      ValueType& evVec=temp_ev->getVector();
809      const ShapeType& evShape=temp_ev->getShape();
810      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
811          temp_ev->addTag(i->first);
812    /*      DataArrayView thisView=getDataPointByTag(i->first);
813          DataArrayView evView=temp_ev->getDataPointByTag(i->first);*/
814          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
815          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
816          DataMaths::swapaxes(m_data,getShape(),offset,evVec, evShape, evoffset,axis0,axis1);
817      }
818      DataMaths::swapaxes(m_data,getShape(),getDefaultOffset(),evVec,evShape,temp_ev->getDefaultOffset(),axis0,axis1);
819  }  }
820    
821  const DataTagged::DataMapType&  void
822  DataTagged::getTagLookup() const  DataTagged::eigenvalues(DataAbstract* ev)
823    {
824      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
825      if (temp_ev==0) {
826        throw DataException("Error - DataTagged::eigenvalues casting to DataTagged failed (propably a programming error).");
827      }
828      const DataTagged::DataMapType& thisLookup=getTagLookup();
829      DataTagged::DataMapType::const_iterator i;
830      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
831      ValueType& evVec=temp_ev->getVector();
832      const ShapeType& evShape=temp_ev->getShape();
833      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
834          temp_ev->addTag(i->first);
835    //       DataArrayView thisView=getDataPointByTag(i->first);
836    //       DataArrayView evView=temp_ev->getDataPointByTag(i->first);
837          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
838          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
839          DataMaths::eigenvalues(m_data,getShape(),offset,evVec, evShape, evoffset);
840      }
841      DataMaths::eigenvalues(m_data,getShape(),getDefaultOffset(),evVec, evShape, temp_ev->getDefaultOffset());
842    }
843    void
844    DataTagged::eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol)
845    {
846      DataTagged* temp_ev=dynamic_cast<DataTagged*>(ev);
847      if (temp_ev==0) {
848        throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
849      }
850      DataTagged* temp_V=dynamic_cast<DataTagged*>(V);
851      if (temp_V==0) {
852        throw DataException("Error - DataTagged::eigenvalues_and_eigenvectors casting to DataTagged failed (propably a programming error).");
853      }
854      const DataTagged::DataMapType& thisLookup=getTagLookup();
855      DataTagged::DataMapType::const_iterator i;
856      DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
857      ValueType& evVec=temp_ev->getVector();
858      const ShapeType& evShape=temp_ev->getShape();
859      ValueType& VVec=temp_V->getVector();
860      const ShapeType& VShape=temp_V->getShape();
861      for (i=thisLookup.begin();i!=thisLookupEnd;i++) {
862          temp_ev->addTag(i->first);
863          temp_V->addTag(i->first);
864    /*      DataArrayView thisView=getDataPointByTag(i->first);
865          DataArrayView evView=temp_ev->getDataPointByTag(i->first);
866          DataArrayView VView=temp_V->getDataPointByTag(i->first);*/
867          DataTypes::ValueType::size_type offset=getOffsetForTag(i->first);
868          DataTypes::ValueType::size_type evoffset=temp_ev->getOffsetForTag(i->first);
869          DataTypes::ValueType::size_type Voffset=temp_V->getOffsetForTag(i->first);
870    /*      DataArrayView::eigenvalues_and_eigenvectors(thisView,0,evView,0,VView,0,tol);*/
871          DataMaths::eigenvalues_and_eigenvectors(m_data,getShape(),offset,evVec, evShape, evoffset,VVec,VShape,Voffset,tol);
872    
873      }
874      DataMaths::eigenvalues_and_eigenvectors(m_data,getShape(),getDefaultOffset(),evVec, evShape,
875                          temp_ev->getDefaultOffset(),VVec,VShape,
876                          temp_V->getDefaultOffset(), tol);
877    
878    
879    }
880    
881    void
882    DataTagged::setToZero(){
883        DataTypes::ValueType::size_type n=m_data.size();
884        for (int i=0; i<n ;++i) m_data[i]=0.;
885    }
886    
887    void
888    DataTagged::dump(const std::string fileName) const
889    {
890       #ifdef PASO_MPI
891       throw DataException("Error - DataTagged:: dump is not implemented for MPI yet.");
892       #endif
893       #ifdef USE_NETCDF
894       const int ldims=DataTypes::maxRank+1;
895       const NcDim* ncdims[ldims];
896       NcVar *var, *tags_var;
897       int rank = getRank();
898       int type=  getFunctionSpace().getTypeCode();
899       int ndims =0;
900       long dims[ldims];
901       const double* d_ptr=&(m_data[0]);
902       DataTypes::ShapeType shape = getShape();
903    
904       // netCDF error handler
905       NcError err(NcError::verbose_nonfatal);
906       // Create the file.
907       NcFile dataFile(fileName.c_str(), NcFile::Replace);
908       // check if writing was successful
909       if (!dataFile.is_valid())
910            throw DataException("Error - DataTagged:: opening of netCDF file for output failed.");
911       if (!dataFile.add_att("type_id",1) )
912            throw DataException("Error - DataTagged:: appending data type to netCDF file failed.");
913       if (!dataFile.add_att("rank",rank) )
914            throw DataException("Error - DataTagged:: appending rank attribute to netCDF file failed.");
915       if (!dataFile.add_att("function_space_type",type))
916            throw DataException("Error - DataTagged:: appending function space attribute to netCDF file failed.");
917       ndims=rank+1;
918       if ( rank >0 ) {
919           dims[0]=shape[0];
920           if (! (ncdims[0] = dataFile.add_dim("d0",shape[0])) )
921                throw DataException("Error - DataTagged:: appending ncdimension 0 to netCDF file failed.");
922       }
923       if ( rank >1 ) {
924           dims[1]=shape[1];
925           if (! (ncdims[1] = dataFile.add_dim("d1",shape[1])) )
926                throw DataException("Error - DataTagged:: appending ncdimension 1 to netCDF file failed.");
927       }
928       if ( rank >2 ) {
929           dims[2]=shape[2];
930           if (! (ncdims[2] = dataFile.add_dim("d2", shape[2])) )
931                throw DataException("Error - DataTagged:: appending ncdimension 2 to netCDF file failed.");
932       }
933       if ( rank >3 ) {
934           dims[3]=shape[3];
935           if (! (ncdims[3] = dataFile.add_dim("d3", shape[3])) )
936                throw DataException("Error - DataTagged:: appending ncdimension 3 to netCDF file failed.");
937       }
938       const DataTagged::DataMapType& thisLookup=getTagLookup();
939       DataTagged::DataMapType::const_iterator i;
940       DataTagged::DataMapType::const_iterator thisLookupEnd=thisLookup.end();
941       int ntags=1;
942       for (i=thisLookup.begin();i!=thisLookupEnd;i++) ntags++;
943       int* tags =(int*) esysUtils::malloc(ntags*sizeof(int));
944       int c=1;
945       tags[0]=-1;
946       for (i=thisLookup.begin();i!=thisLookupEnd;i++) tags[c++]=i->first;
947       dims[rank]=ntags;
948       if (! (ncdims[rank] = dataFile.add_dim("num_tags", dims[rank])) )
949       {
950           esysUtils::free(tags);
951               throw DataException("Error - DataTagged:: appending num_tags to netCDF file failed.");
952       }
953       if (! ( tags_var = dataFile.add_var("tags", ncInt, ncdims[rank])) )
954       {
955        esysUtils::free(tags);
956            throw DataException("Error - DataTagged:: appending tags to netCDF file failed.");
957       }
958       if (! (tags_var->put(tags,dims[rank])) )
959       {
960        esysUtils::free(tags);
961            throw DataException("Error - DataTagged:: copy tags to netCDF buffer failed.");
962       }
963       if (! ( var = dataFile.add_var("data", ncDouble, ndims, ncdims)) )
964       {
965        esysUtils::free(tags);
966            throw DataException("Error - DataTagged:: appending variable to netCDF file failed.");
967       }
968       if (! (var->put(d_ptr,dims)) )
969       {
970        esysUtils::free(tags);
971            throw DataException("Error - DataTagged:: copy data to netCDF buffer failed.");
972       }
973       #else
974       throw DataException("Error - DataTagged:: dump is not configured with netCDF. Please contact your installation manager.");
975       #endif
976    }
977    
978    DataTypes::ValueType&
979    DataTagged::getVector()
980  {  {
981    return m_offsetLookup;      return m_data;
982  }  }
983    
984  DataArrayView::ValueType::size_type  const DataTypes::ValueType&
985  DataTagged::getLength() const  DataTagged::getVector() const
986  {  {
987    return m_data.size();      return m_data;
988  }  }
989    
990  }  // end of namespace  }  // end of namespace

Legend:
Removed from v.119  
changed lines
  Added in v.1811

  ViewVC Help
Powered by ViewVC 1.1.26