/[escript]/trunk/escript/test/DataTaggedTestCase.cpp
ViewVC logotype

Diff of /trunk/escript/test/DataTaggedTestCase.cpp

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

trunk/escript/test/DataTagged/DataTaggedTestCase.cpp revision 534 by jgs, Fri Feb 17 01:03:53 2006 UTC trunk/escript/test/DataTaggedTestCase.cpp revision 2008 by phornby, Mon Nov 10 08:59:14 2008 UTC
# Line 1  Line 1 
 // $Id$  
 /*  
  *****************************************************************************  
  *                                                                           *  
  *       COPYRIGHT  ACcESS  -  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.                                            *  
  *                                                                           *  
  *****************************************************************************  
 */  
1    
2  #include "EsysException.h"  /*******************************************************
3    *
4  #include "DataTagged.h"  * Copyright (c) 2003-2008 by University of Queensland
5  #include "DataConstant.h"  * 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 "esysUtils/EsysException.h"
16    
17    #include "escript/DataVector.h"
18    #include "escript/DataTagged.h"
19    #include "escript/DataConstant.h"
20    
21  #include "DataTaggedTestCase.h"  #include "DataTaggedTestCase.h"
22    
23  #include "BinaryOp.h"  #include "escript/BinaryOp.h"
24  #include "UnaryOp.h"  #include "escript/UnaryOp.h"
25  #include "FunctionSpaceFactory.h"  #include "escript/FunctionSpaceFactory.h"
26  #include "DataFactory.h"  #include "escript/DataFactory.h"
27    
28    #include "escript/FunctionSpace.h"
29    // #include "finley/CppAdapter/MeshAdapter.h"
30    #include "escript/DataTypes.h"
31    
32  #include <iostream>  #include <iostream>
33  #include <functional>  #include <functional>
34  #include <algorithm>  #include <algorithm>
35    
36    
37    
38  using namespace CppUnitTest;  using namespace CppUnitTest;
39  using namespace escript;  using namespace escript;
40  using namespace esysUtils;  using namespace esysUtils;
41  using namespace std;  using namespace std;
42    using namespace escript::DataTypes;
43    // using finley::MeshAdapter;
44    
45    // namespace {
46    // std::string constr(FunctionSpace& fs)
47    // {
48    //    
49    //    try
50    //    {
51    //  int t[1];
52    //  DataTagged dt(fs,DataTypes::scalarShape,t,DataTypes::ValueType());
53    //  
54    //  return "DataTagged(const FunctionSpace& what, const DataTypes::ShapeType &shape, const int tags[], const ValueType& data) was supposed to throw.";
55    //    } catch (DataException d){}
56    //    try
57    //    {
58    //  DataTagged t(fs,DataTypes::scalarShape,DataTagged::TagListType(),DataTypes::ValueType());
59    //  return "DataTagged(const FunctionSpace& what, const DataTypes::ShapeType &shape, const TagListType& tags, const ValueType& data) was supposed to throw.";
60    //    } catch (DataException d){}
61    //    try
62    //    {
63    //  DataTagged t(fs,DataTypes::scalarShape,DataTypes::ValueType());
64    //  return "  DataTagged(const FunctionSpace& what, const DataTypes::ShapeType& shape, const DataTypes::ValueType& defaultvalue, const DataTagged* tagsource=0) was supposed to throw.";
65    //    } catch (DataException d){}
66    //    try
67    //    {
68    //      DataTypes::ValueType viewData1(1);
69    //      viewData1[0]=0.0;
70    //  DataConstant c(fs,DataTypes::scalarShape, viewData1);
71    //  DataTagged t(c);
72    //  return "DataTagged(const DataConstant& other) was supposed to throw.";
73    //    } catch (DataException d){}
74    //
75    // }
76    //
77    // }
78    
79  void DataTaggedTestCase::setUp() {  void DataTaggedTestCase::setUp() {
80    //    //
81    // This is called before each test is run    // This is called before each test is run
82    
83  }  }
84    
85  void DataTaggedTestCase::tearDown() {  void DataTaggedTestCase::tearDown() {
86    //    //
87    // This is called after each test has been run    // This is called after each test has been run
   
 }  
   
 void DataTaggedTestCase::testReshape() {  
   
   cout << endl;  
   
   {  
   
     cout << "\tTest rank 1 reshape of default DataTagged." << endl;  
   
     DataTagged myData;  
     myData.getPointDataView()()=1.0;  
   
     DataArrayView::ShapeType shape;  
     shape.push_back(2);  
   
     myData.reshapeDataPoint(shape);  
   
     for (int i=0;i<shape[0];i++) {  
       assert(myData.getDefaultValue()(i)==1);  
     }  
   
     //cout << myData.toString() << endl;  
   
     assert(myData.getNumSamples()==1);  
     assert(myData.getNumDPPSample()==1);  
   
     assert(myData.validSamplePointNo(0));  
     assert(myData.validSampleNo(0));  
     assert(!myData.validSamplePointNo(1));  
     assert(!myData.validSampleNo(1));  
   
     // data-point 0 has tag number 1 by default  
     assert(myData.getTagNumber(0)==1);  
   
     assert(!myData.isCurrentTag(1));  
   
     assert(myData.getTagLookup().size()==0);  
   
     assert(myData.getLength()==2);  
   
     assert(myData.getPointOffset(0,0)==0);  
   
     DataArrayView myDataView = myData.getDataPoint(0,0);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==2);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1.0);  
     assert(myDataView(1)==1.0);  
   
     // Test non-existent tag returns the default value.  
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==2);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1.0);  
     assert(myDataView(1)==1.0);  
   
     myDataView = myData.getDefaultValue();  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==2);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1.0);  
     assert(myDataView(1)==1.0);  
   
     // use a non-existent tag so we get a pointer to  
     // the first element of the data array  
     double* sampleData=myData.getSampleDataByTag(9);  
     for (int i=0; i<myData.getLength(); i++) {  
       assert(sampleData[i]==1.0);  
     }  
   
   }  
   
   {  
   
     cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;  
   
     DataTagged::TagListType keys;  
     keys.push_back(1);  
   
     DataTagged::ValueListType values;  
   
     DataArrayView::ShapeType viewShape;  
   
     // default value  
     DataArrayView::ValueType viewData(1);  
     viewData[0]=1.0;  
     DataArrayView myView(viewData,viewShape);  
   
     // value for tag "1"  
     DataArray eOne(myView);  
     eOne.getView()()=2.0;  
     values.push_back(eOne.getView());  
   
     DataTagged myData(keys,values,myView,FunctionSpace());  
   
     DataArrayView::ShapeType shape;  
     shape.push_back(2);  
     shape.push_back(5);  
   
     myData.reshapeDataPoint(shape);  
   
     //cout << myData.toString() << endl;  
88    
89      assert(myData.getNumSamples()==1);  }
     assert(myData.getNumDPPSample()==1);  
   
     assert(myData.validSamplePointNo(0));  
     assert(myData.validSampleNo(0));  
     assert(!myData.validSamplePointNo(1));  
     assert(!myData.validSampleNo(1));  
   
     // data-point 0 has tag number 1 by default  
     assert(myData.getTagNumber(0)==1);  
   
     assert(myData.isCurrentTag(1));  
   
     assert(myData.getTagLookup().size()==1);  
   
     assert(myData.getLength()==20);  
   
     assert(myData.getPointOffset(0,0)==10);  
   
     DataArrayView myDataView = myData.getDataPoint(0,0);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==10);  
     assert(myDataView.getRank()==2);  
     assert(myDataView.noValues()==10);  
     assert(myDataView.getShape().size()==2);  
     for (int j=0;j<shape[1];j++) {  
       for (int i=0;i<shape[0];i++) {  
         assert(myDataView(i,j)==2.0);  
       }  
     }  
   
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==10);  
     assert(myDataView.getRank()==2);  
     assert(myDataView.noValues()==10);  
     assert(myDataView.getShape().size()==2);  
     for (int j=0;j<shape[1];j++) {  
       for (int i=0;i<shape[0];i++) {  
         assert(myDataView(i,j)==2.0);  
       }  
     }  
   
     myDataView = myData.getDefaultValue();  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==2);  
     assert(myDataView.noValues()==10);  
     assert(myDataView.getShape().size()==2);  
     for (int j=0;j<shape[1];j++) {  
       for (int i=0;i<shape[0];i++) {  
         assert(myDataView(i,j)==1.0);  
       }  
     }  
   
     // use a non-existent tag so we get a pointer to  
     // the first element of the data array  
     double* sampleData=myData.getSampleDataByTag(9);  
     for (int i=0; i<myData.getLength(); i++) {  
       if (i<10) {  
         assert(sampleData[i]==1.0);  
       } else {  
         assert(sampleData[i]==2.0);  
       }  
     }  
   
   }  
   
   {  
   
     cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;  
   
     DataTagged::TagListType keys;  
     keys.push_back(1);  
     keys.push_back(2);  
     keys.push_back(3);  
   
     DataTagged::ValueListType values;  
   
     DataArrayView::ShapeType viewShape;  
   
     // default value  
     DataArrayView::ValueType viewData(1);  
     viewData[0]=0.0;  
     DataArrayView myView(viewData,viewShape);  
   
     // value for tag "1"  
     DataArray eOne(myView);  
     eOne.getView()()=1.0;  
     values.push_back(eOne.getView());  
   
     // value for tag "2"  
     DataArray eTwo(myView);  
     eTwo.getView()()=2.0;  
     values.push_back(eTwo.getView());  
   
     // value for tag "3"  
     DataArray eThree(myView);  
     eThree.getView()()=3.0;  
     values.push_back(eThree.getView());  
   
     DataTagged myData(keys,values,myView,FunctionSpace());  
   
     DataArrayView::ShapeType shape;  
     shape.push_back(2);  
     shape.push_back(2);  
     shape.push_back(2);  
   
     myData.reshapeDataPoint(shape);  
   
     //cout << myData.toString() << endl;  
   
     assert(myData.getNumSamples()==1);  
     assert(myData.getNumDPPSample()==1);  
   
     assert(myData.validSamplePointNo(0));  
     assert(myData.validSampleNo(0));  
     assert(!myData.validSamplePointNo(1));  
     assert(!myData.validSampleNo(1));  
   
     // data-point 0 has tag number 1 by default  
     assert(myData.getTagNumber(0)==1);  
   
     assert(myData.isCurrentTag(1));  
     assert(myData.isCurrentTag(2));  
     assert(myData.isCurrentTag(3));  
   
     assert(myData.getTagLookup().size()==3);  
   
     assert(myData.getLength()==32);  
   
     assert(myData.getPointOffset(0,0)==8);  
   
     DataArrayView myDataView = myData.getDataPoint(0,0);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==8);  
     assert(myDataView.getRank()==3);  
     assert(myDataView.noValues()==8);  
     assert(myDataView.getShape().size()==3);  
     for (int k=0;k<shape[2];k++) {  
       for (int j=0;j<shape[1];j++) {  
         for (int i=0;i<shape[0];i++) {  
           assert(myDataView(i,j,k)==1.0);  
         }  
       }  
     }  
90    
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==8);  
     assert(myDataView.getRank()==3);  
     assert(myDataView.noValues()==8);  
     assert(myDataView.getShape().size()==3);  
     for (int k=0;k<shape[2];k++) {  
       for (int j=0;j<shape[1];j++) {  
         for (int i=0;i<shape[0];i++) {  
           assert(myDataView(i,j,k)==1.0);  
         }  
       }  
     }  
91    
92      myDataView = myData.getDataPointByTag(2);  namespace {
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==16);  
     assert(myDataView.getRank()==3);  
     assert(myDataView.noValues()==8);  
     assert(myDataView.getShape().size()==3);  
     for (int k=0;k<shape[2];k++) {  
       for (int j=0;j<shape[1];j++) {  
         for (int i=0;i<shape[0];i++) {  
           assert(myDataView(i,j,k)==2.0);  
         }  
       }  
     }  
93    
94      myDataView = myData.getDataPointByTag(3);  ValueType::reference
95      assert(!myDataView.isEmpty());  getRef(DataTagged& data,int offset, int i, int j, int k)
96      assert(myDataView.getOffset()==24);  {
97      assert(myDataView.getRank()==3);     return data.getVector()[offset+getRelIndex(data.getShape(),i,j,k)];
98      assert(myDataView.noValues()==8);  }
     assert(myDataView.getShape().size()==3);  
     for (int k=0;k<shape[2];k++) {  
       for (int j=0;j<shape[1];j++) {  
         for (int i=0;i<shape[0];i++) {  
           assert(myDataView(i,j,k)==3.0);  
         }  
       }  
     }  
99    
100      myDataView = myData.getDefaultValue();  ValueType::reference
101      assert(!myDataView.isEmpty());  getRef(DataTagged& data,int offset, int i, int j, int k, int l)
102      assert(myDataView.getOffset()==0);  {
103      assert(myDataView.getRank()==3);     return data.getVector()[offset+getRelIndex(data.getShape(),i,j,k,l)];
104      assert(myDataView.noValues()==8);  }
     assert(myDataView.getShape().size()==3);  
     for (int k=0;k<shape[2];k++) {  
       for (int j=0;j<shape[1];j++) {  
         for (int i=0;i<shape[0];i++) {  
           assert(myDataView(i,j,k)==0.0);  
         }  
       }  
     }  
105    
106      // use a non-existent tag so we get a pointer to  ValueType::reference
107      // the first element of the data array  getRef(DataTagged& data,int offset, int i, int j)
108      double* sampleData=myData.getSampleDataByTag(9);  {
109      for (int i=0; i<myData.getLength(); i++) {     return data.getVector()[offset+getRelIndex(data.getShape(),i,j)];
110        if (i<8) {  }
         assert(sampleData[i]==0.0);  
       } else if ((i>=8) && (i<16)) {  
         assert(sampleData[i]==1.0);  
       } else if ((i>=16) && (i<24)) {  
         assert(sampleData[i]==2.0);  
       } else {  
         assert(sampleData[i]==3.0);  
       }  
     }  
111    
112    }  ValueType::const_reference
113    getRef(const DataTagged& data,int offset, int i)
114    {
115       return data.getVector()[offset+getRelIndex(data.getShape(),i)];
116    }
117    
118  }  }
119    
# Line 410  void DataTaggedTestCase::testOperations( Line 150  void DataTaggedTestCase::testOperations(
150    
151      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
152    
153      DataArrayView myDataView = myData.getDataPoint(0,0);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
154      assert(!myDataView.isEmpty());  //     assert(!myDataView.isEmpty());
155      assert(myDataView.getOffset()==0);      assert(myData.getPointOffset(0,0)==0);
156      assert(myDataView.getRank()==0);      assert(myData.getRank()==0);
157      assert(myDataView.noValues()==1);      assert(myData.getNoValues()==1);
158      assert(myDataView.getShape().size()==0);      assert(myData.getShape().size()==0);
159      assert(myDataView()==0.0);      assert(myData.getDataAtOffset(0)==0.0);
160    
161      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
162      myDataView = myData.getDataPointByTag(1);  //     myDataView = myData.getDataPointByTag(1);
163      assert(!myDataView.isEmpty());  //     assert(!myDataView.isEmpty());
164      assert(myDataView.getOffset()==0);      assert(myData.getOffsetForTag(1)==0);
165      assert(myDataView.getRank()==0);      assert(myData.getRank()==0);
166      assert(myDataView.noValues()==1);      assert(myData.getNoValues()==1);
167      assert(myDataView.getShape().size()==0);      assert(myData.getShape().size()==0);
168      assert(myDataView()==0.0);      assert(myData.getDataAtOffset(0)==0.0);
169    
170      myDataView = myData.getDefaultValue();  //     myDataView = myData.getDefaultValue();
171      assert(!myDataView.isEmpty());  //     assert(!myDataView.isEmpty());
172      assert(myDataView.getOffset()==0);      assert(myData.getDefaultOffset()==0);
173      assert(myDataView.getRank()==0);  //     assert(myDataView.getRank()==0);     // there is no point in testing this again
174      assert(myDataView.noValues()==1);  //     assert(myDataView.noValues()==1);    // since we are not building DataArrayViews
175      assert(myDataView.getShape().size()==0);  //     assert(myDataView.getShape().size()==0);
176      assert(myDataView()==0.0);  //     assert(myDataView()==0.0);
177    
178      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
179      // the first element of the data array      // the first element of the data array
# Line 447  void DataTaggedTestCase::testOperations( Line 187  void DataTaggedTestCase::testOperations(
187    {    {
188      cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;      cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
189    
190      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
191      viewShape.push_back(3);      viewShape.push_back(3);
192    
193      DataTagged::TagListType keys;  //     DataTagged::TagListType keys;
194    //
195      DataTagged::ValueListType values;  //     DataTagged::ValueListType values;
196    
197      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
198      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
199        viewData[i]=i;        viewData[i]=i;
200      }      }
     DataArrayView myView(viewData,viewShape);  
201    
202      DataTagged myData(keys,values,myView,FunctionSpace());  //     DataTagged myData(keys,values,myView,FunctionSpace());
203      DataTagged right(keys,values,myView,FunctionSpace());  //     DataTagged right(keys,values,myView,FunctionSpace());
204        DataTagged myData(FunctionSpace(),viewShape,viewData);
205        DataTagged right(FunctionSpace(),viewShape,viewData);
206    
207    
208      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
209    
# Line 486  void DataTaggedTestCase::testOperations( Line 228  void DataTaggedTestCase::testOperations(
228    
229      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
230    
231      DataArrayView myDataView = myData.getDefaultValue();      assert(myData.getRank()==1);
232      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==3);
233      assert(myDataView.getOffset()==0);      assert(myData.getShape().size()==1);
234      assert(myDataView.getRank()==1);  
235      assert(myDataView.noValues()==3);  
236      assert(myDataView.getShape().size()==1);      int offset=myData.getDefaultOffset();
237      assert(myDataView(0)==0);  //     DataArrayView myDataView = myData.getDefaultValue();
238      assert(myDataView(1)==2);      assert(offset==0);
239      assert(myDataView(2)==4);      assert(getRef(myData,offset,0)==0);
240        assert(getRef(myData,offset,1)==2);
241        assert(getRef(myData,offset,2)==4);
242    
243      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
244      // the first element of the data array      // the first element of the data array
# Line 511  void DataTaggedTestCase::testOperations( Line 255  void DataTaggedTestCase::testOperations(
255      DataTagged myData;      DataTagged myData;
256      DataTagged right;      DataTagged right;
257    
258      DataArray vOne(1.0);      DataVector vOneData(1, 1.0 ,1);
259      myData.addTaggedValue(1,vOne.getView());      // create a view with an empty shape, a scalar.
260      right.addTaggedValue(1,vOne.getView());  //     DataArrayView vOneView(vOneData,DataTypes::ShapeType());
261    
262        myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
263        right.addTaggedValue(1,DataTypes::scalarShape,vOneData);
264    
265      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
266    
# Line 536  void DataTaggedTestCase::testOperations( Line 283  void DataTaggedTestCase::testOperations(
283    
284      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
285    
286    
287        assert(myData.getRank()==0);
288        assert(myData.getNoValues()==1);
289        assert(myData.getShape().size()==0);
290    
291    
292    
293      // check result value for tag "1"      // check result value for tag "1"
294      DataArrayView myDataView = myData.getDataPointByTag(1);  //     DataArrayView myDataView = myData.getDataPointByTag(1);
295      assert(!myDataView.isEmpty());      int offset=myData.getOffsetForTag(1);
296      assert(myDataView.getOffset()==1);      assert(offset==1);
297      assert(myDataView.getRank()==0);      assert(myData.getVector()[offset]==2.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==2.0);  
298    
299      // check result for default value      // check result for default value
300      myDataView = myData.getDefaultValue();  //     myDataView = myData.getDefaultValue();
301      assert(!myDataView.isEmpty());      offset=myData.getDefaultOffset();
302      assert(myDataView.getOffset()==0);      assert(offset==0);
303      assert(myDataView.getRank()==0);      assert(myData.getVector()[offset]==0.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
304    
305      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
306      // the first element of the data array      // the first element of the data array
# Line 569  void DataTaggedTestCase::testOperations( Line 317  void DataTaggedTestCase::testOperations(
317      DataTagged myData;      DataTagged myData;
318      DataTagged right;      DataTagged right;
319    
320      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
321      DataArray vTwo(2.0);      // verify that the tag values in each object are being added to the correct
322      myData.addTaggedValue(1,vOne.getView());      // default values - since the tag lists don't match, the default values will
323      right.addTaggedValue(2,vTwo.getView());      // be used for missing tags in each object
324    //     myData.getDefaultValue()()=1.0;
325    //     right.getDefaultValue()()=2.0;
326        myData.getVector()[myData.getDefaultOffset()]=1.0;
327        right.getVector()[right.getDefaultOffset()]=2.0;
328    
329        DataVector vOneData(1, 3.0 ,1);
330        // create a view with an empty shape, a scalar.
331    //     DataArrayView vOneView(vOneData,DataTypes::ShapeType());
332    
333        DataVector vTwoData(1, 4.0 ,1);
334        // create a view with an empty shape, a scalar.
335    //     DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
336    
337        myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
338        right.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
339    
340        //cout << myData.toString() << endl;
341        //cout << right.toString() << endl;
342    
343      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
344    
345        //cout << myData.toString() << endl;
346    
347      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
348      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
349    
# Line 596  void DataTaggedTestCase::testOperations( Line 364  void DataTaggedTestCase::testOperations(
364    
365      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
366    
367        assert(myData.getRank()==0);
368        assert(myData.getNoValues()==1);
369        assert(myData.getShape().size()==0);
370    
371    
372      // check result value for tag "1"      // check result value for tag "1"
373      DataArrayView myDataView = myData.getDataPointByTag(1);  //     DataArrayView myDataView = myData.getDataPointByTag(1);
374      assert(!myDataView.isEmpty());      int offset=myData.getOffsetForTag(1);
375      assert(myDataView.getOffset()==1);      assert(offset==1);
376      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==5.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1.0);  
377    
378      // check result value for tag "2"      // check result value for tag "2"
379      myDataView = myData.getDataPointByTag(2);  //     myDataView = myData.getDataPointByTag(2);
380      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(2);
381      assert(myDataView.getOffset()==2);      assert(offset==2);
382      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==5.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==2.0);  
383    
384      // check result for default value      // check result for default value
385      myDataView = myData.getDefaultValue();  //     myDataView = myData.getDefaultValue();
386      assert(!myDataView.isEmpty());      offset=myData.getDefaultOffset();
387      assert(myDataView.getOffset()==0);      assert(offset==0);
388      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==3.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
389    
390      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
391      // the first element of the data array      // the first element of the data array
392      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
393      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==3);
394        assert(sampleData[i]==i);      assert(sampleData[1]==5);
395      }      assert(sampleData[2]==5);
396    
397    }    }
398    
# Line 638  void DataTaggedTestCase::testOperations( Line 402  void DataTaggedTestCase::testOperations(
402      DataTagged myData;      DataTagged myData;
403      DataTagged right;      DataTagged right;
404    
405      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
406      myData.addTaggedValue(1,vOne.getView());      // verify that the tag values in each object are being added to the correct
407      myData.addTaggedValue(2,vOne.getView());      // default values - since the tag lists don't match, the default values will
408      right.addTaggedValue(2,vOne.getView());      // be used for missing tags in each object
409      right.addTaggedValue(3,vOne.getView());  /*    myData.getDefaultValue()()=2.0;
410        right.getDefaultValue()()=3.0;*/
411        myData.getVector()[myData.getDefaultOffset()]=2.0;
412        right.getVector()[right.getDefaultOffset()]=3.0;
413    
414    
415        DataVector vOneData(1, 1.0 ,1);
416        // create a view with an empty shape, a scalar.
417    //     DataArrayView vOneView(vOneData,DataTypes::ShapeType());
418    
419        myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
420        myData.addTaggedValue(2,DataTypes::scalarShape,vOneData);
421        right.addTaggedValue(2,DataTypes::scalarShape,vOneData);
422        right.addTaggedValue(3,DataTypes::scalarShape,vOneData);
423    
424        //cout << myData.toString() << endl;
425        //cout << right.toString() << endl;
426    
427      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
428    
429        //cout << myData.toString() << endl;
430    
431      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
432      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
433    
# Line 667  void DataTaggedTestCase::testOperations( Line 449  void DataTaggedTestCase::testOperations(
449    
450      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
451    
452        assert(myData.getRank()==0);
453        assert(myData.getNoValues()==1);
454        assert(myData.getShape().size()==0);
455    
456    
457      // check result value for tag "1"      // check result value for tag "1"
458      DataArrayView myDataView = myData.getDataPointByTag(1);  //     DataArrayView myDataView = myData.getDataPointByTag(1);
459      assert(!myDataView.isEmpty());      int offset=myData.getOffsetForTag(1);
460      assert(myDataView.getOffset()==1);      assert(offset==1);
461      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==4.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1.0);  
462    
463      // check result value for tag "2"      // check result value for tag "2"
464      myDataView = myData.getDataPointByTag(2);  //     myDataView = myData.getDataPointByTag(2);
465      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(2);
466      assert(myDataView.getOffset()==2);      assert(offset==2);
467      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==2.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==2.0);  
468    
469      // check result value for tag "3"      // check result value for tag "3"
470      myDataView = myData.getDataPointByTag(3);  //     myDataView = myData.getDataPointByTag(3);
471      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(3);
472      assert(myDataView.getOffset()==3);      assert(offset==3);
473      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==3.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1.0);  
474    
475      // check result for default value      // check result for default value
476      myDataView = myData.getDefaultValue();  //     myDataView = myData.getDefaultValue();
477      assert(!myDataView.isEmpty());      offset=myData.getDefaultOffset();
478      assert(myDataView.getOffset()==0);      assert(offset==0);
479      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==5.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
480    
481      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
482      // the first element of the data array      // the first element of the data array
483      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
484      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==5);
485        if (i<3) {      assert(sampleData[1]==4);
486          assert(sampleData[i]==i);      assert(sampleData[2]==2);
487        } else {      assert(sampleData[3]==3);
         assert(sampleData[i]==i-2);  
       }  
     }  
488    
489    }    }
490    
491    {    {
492      cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
493    
494      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
495      viewShape.push_back(3);      viewShape.push_back(3);
496    
497      DataTagged::TagListType keys;  //     DataTagged::TagListType keys;
498    
499      DataTagged::ValueListType values;  //     DataTagged::ValueListType values;
500    
501      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
502      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
503        viewData[i]=i;        viewData[i]=i;
504      }      }
505      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
506    
507      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
508      DataTagged right(keys,values,myView,FunctionSpace());      DataTagged right(FunctionSpace(),viewShape,viewData);
509    
510      binaryOp(myData,right,multiplies<double>());      binaryOp(myData,right,multiplies<double>());
511    
# Line 758  void DataTaggedTestCase::testOperations( Line 530  void DataTaggedTestCase::testOperations(
530    
531      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
532    
533      DataArrayView myDataView = myData.getDefaultValue();      assert(myData.getRank()==1);
534      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==3);
535      assert(myDataView.getOffset()==0);      assert(myData.getShape().size()==1);
536      assert(myDataView.getRank()==1);  
537      assert(myDataView.noValues()==3);  
538      assert(myDataView.getShape().size()==1);  //     DataArrayView myDataView = myData.getDefaultValue();
539      assert(myDataView(0)==0);      int offset=myData.getDefaultOffset();
540      assert(myDataView(1)==1);      assert(offset==0);
541      assert(myDataView(2)==4);      assert(getRef(myData,offset,0)==0);
542        assert(getRef(myData,offset,1)==1);
543        assert(getRef(myData,offset,2)==4);
544    
545      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
546      // the first element of the data array      // the first element of the data array
# Line 778  void DataTaggedTestCase::testOperations( Line 552  void DataTaggedTestCase::testOperations(
552    }    }
553    
554    {    {
555    
556        cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
557    
558        DataTagged myData;
559    
560        DataVector vOneData(1, 1.0 ,1);
561        // create a view with an empty shape, a scalar.
562    //     DataArrayView vOneView(vOneData,DataTypes::ShapeType());
563    
564        DataVector vTwoData(1, 2.0 ,1);
565        // create a view with an empty shape, a scalar.
566    //     DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
567    
568        myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
569        myData.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
570    
571        DataVector vThreeData(1, 3.0 ,1);
572        // create a view with an empty shape, a scalar.
573    //     DataArrayView vThreeView(vThreeData,DataTypes::ShapeType());
574    
575    //     DataArrayView right=vThreeView;
576    
577        //cout << myData.toString() << endl;
578        //cout << right.toString() << endl;
579    
580        binaryOp(myData,vThreeData, DataTypes::scalarShape,multiplies<double>());
581    
582        //cout << myData.toString() << endl;
583    
584        assert(myData.getNumSamples()==1);
585        assert(myData.getNumDPPSample()==1);
586    
587        assert(myData.validSamplePointNo(0));
588        assert(myData.validSampleNo(0));
589        assert(!myData.validSamplePointNo(1));
590        assert(!myData.validSampleNo(1));
591    
592        // data-point 0 has tag number 1 by default
593        assert(myData.getTagNumber(0)==1);
594    
595        assert(myData.isCurrentTag(1));
596        assert(myData.isCurrentTag(2));
597    
598        assert(myData.getTagLookup().size()==2);
599    
600        assert(myData.getLength()==3);
601    
602        assert(myData.getPointOffset(0,0)==1);
603    
604        assert(myData.getRank()==0);
605        assert(myData.getNoValues()==1);
606        assert(myData.getShape().size()==0);
607    
608        // check result value for tag "1"
609    //     DataArrayView myDataView = myData.getDataPointByTag(1);
610        int offset=myData.getOffsetForTag(1);
611        assert(offset==1);
612        assert(myData.getDataAtOffset(offset)==3.0);
613    
614        // check result value for tag "2"
615    //     myDataView = myData.getDataPointByTag(2);
616        offset=myData.getOffsetForTag(2);
617        assert(offset==2);
618        assert(myData.getDataAtOffset(offset)==6.0);
619    
620        // check result for default value
621    //     myDataView = myData.getDefaultValue();
622        offset=myData.getDefaultOffset();
623        assert(offset==0);
624        assert(myData.getDataAtOffset(offset)==0.0);
625    
626        // use a non-existent tag so we get a pointer to
627        // the first element of the data array
628        double* sampleData=myData.getSampleDataByTag(9);
629        assert(sampleData[0]==0);
630        assert(sampleData[1]==3);
631        assert(sampleData[2]==6);
632    
633      }
634    
635      {
636      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
637    
638      DataTagged myData;      DataTagged myData;
639      DataTagged right;      DataTagged right;
640    
641      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
642      DataArray vTwo(2.0);      // verify that the tag values in each object are being added to the correct
643      myData.addTaggedValue(1,vOne.getView());      // default values - since the tag lists don't match, the default values will
644      myData.addTaggedValue(2,vOne.getView());      // be used for missing tags in each object
645      right.addTaggedValue(2,vTwo.getView());  //     myData.getDefaultValue()()=2.0;
646      right.addTaggedValue(3,vTwo.getView());  //     right.getDefaultValue()()=3.0;
647        myData.getVector()[myData.getDefaultOffset()]=2.0;
648        right.getVector()[right.getDefaultOffset()]=3.0;
649    
650        DataVector vOneData(1, 1.0 ,1);
651        // create a view with an empty shape, a scalar.
652    //     DataArrayView vOneView(vOneData,DataTypes::ShapeType());
653    
654        DataVector vTwoData(1, 2.0 ,1);
655        // create a view with an empty shape, a scalar.
656    //     DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
657    
658        myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
659        myData.addTaggedValue(2,DataTypes::scalarShape,vOneData);
660        right.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
661        right.addTaggedValue(3,DataTypes::scalarShape,vTwoData);
662    
663        //cout << myData.toString() << endl;
664        //cout << right.toString() << endl;
665    
666      binaryOp(myData,right,multiplies<double>());      binaryOp(myData,right,multiplies<double>());
667    
668        //cout << myData.toString() << endl;
669    
670      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
671      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
672    
# Line 813  void DataTaggedTestCase::testOperations( Line 688  void DataTaggedTestCase::testOperations(
688    
689      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
690    
691        assert(myData.getRank()==0);
692        assert(myData.getNoValues()==1);
693        assert(myData.getShape().size()==0);
694    
695    
696      // check result value for tag "1"      // check result value for tag "1"
697      DataArrayView myDataView = myData.getDataPointByTag(1);  //     DataArrayView myDataView = myData.getDataPointByTag(1);
698      assert(!myDataView.isEmpty());      int offset=myData.getOffsetForTag(1);
699      assert(myDataView.getOffset()==1);      assert(offset==1);
700      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==3.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
701    
702      // check result value for tag "2"      // check result value for tag "2"
703      myDataView = myData.getDataPointByTag(2);  //     myDataView = myData.getDataPointByTag(2);
704      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(2);
705      assert(myDataView.getOffset()==2);      assert(offset==2);
706      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==2.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==2.0);  
707    
708      // check result value for tag "3"      // check result value for tag "3"
709      myDataView = myData.getDataPointByTag(3);  //     myDataView = myData.getDataPointByTag(3);
710      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(3);
711      assert(myDataView.getOffset()==3);      assert(offset==3);
712      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==4.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
713    
714      // check result for default value      // check result for default value
715      myDataView = myData.getDefaultValue();  //     myDataView = myData.getDefaultValue();
716      assert(!myDataView.isEmpty());      offset=myData.getDefaultOffset();
717      assert(myDataView.getOffset()==0);      assert(offset==0);
718      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==6.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
719    
720      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
721      // the first element of the data array      // the first element of the data array
722      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
723      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==6);
724        if (i==2) {      assert(sampleData[1]==3);
725          assert(sampleData[i]==2);      assert(sampleData[2]==2);
726        } else {      assert(sampleData[3]==4);
         assert(sampleData[i]==0);  
       }  
     }  
727    
728    }    }
729    
# Line 890  void DataTaggedTestCase::testOperations( Line 755  void DataTaggedTestCase::testOperations(
755    
756      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
757    
758      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
759      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
760      assert(myDataView.getOffset()==0);      assert(myData.getShape().size()==0);
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
761    
     // Test non-existent tag returns the default value.  
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
762    
763      myDataView = myData.getDefaultValue();  //     DataArrayView myDataView = myData.getDataPoint(0,0);
764      assert(!myDataView.isEmpty());      int offset=myData.getPointOffset(0,0);
765      assert(myDataView.getOffset()==0);      assert(offset==0);
766      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==0.0);
767      assert(myDataView.noValues()==1);  
768      assert(myDataView.getShape().size()==0);      // Test non-existent tag returns the default value.
769      assert(myDataView()==0.0);  //     myDataView = myData.getDataPointByTag(1);
770        offset=myData.getOffsetForTag(1);
771        assert(offset==0);
772        assert(myData.getDataAtOffset(offset)==0.0);
773    
774    //     myDataView = myData.getDefaultValue();
775        offset=myData.getDefaultOffset();
776        assert(offset==0);
777        assert(myData.getDataAtOffset(offset)==0.0);
778    
779      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
780      // the first element of the data array      // the first element of the data array
# Line 927  void DataTaggedTestCase::testOperations( Line 788  void DataTaggedTestCase::testOperations(
788    {    {
789      cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;      cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
790    
791      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
792      viewShape.push_back(3);      viewShape.push_back(3);
793    
794      DataTagged::TagListType keys;  //     DataTagged::TagListType keys;
795    
796      DataTagged::ValueListType values;  //     DataTagged::ValueListType values;
797    
798      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
799      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
800        viewData[i]=i;        viewData[i]=i;
801      }      }
802      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
803    
804      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
805    
806      unaryOp(myData,negate<double>());      unaryOp(myData,negate<double>());
807    
# Line 965  void DataTaggedTestCase::testOperations( Line 826  void DataTaggedTestCase::testOperations(
826    
827      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
828    
829      DataArrayView myDataView = myData.getDefaultValue();      assert(myData.getRank()==1);
830      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==3);
831      assert(myDataView.getOffset()==0);      assert(myData.getShape().size()==1);
832      assert(myDataView.getRank()==1);  
833      assert(myDataView.noValues()==3);  
834      assert(myDataView.getShape().size()==1);      int offset=myData.getDefaultOffset();
835      assert(myDataView(0)==0);  //     DataArrayView myDataView = myData.getDefaultValue();
836      assert(myDataView(1)==-1);      assert(offset==0);
837      assert(myDataView(2)==-2);      assert(getRef(myData,offset,0)==0);
838        assert(getRef(myData,offset,1)==-1);
839        assert(getRef(myData,offset,2)==-2);
840    
841      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
842      // the first element of the data array      // the first element of the data array
# Line 985  void DataTaggedTestCase::testOperations( Line 848  void DataTaggedTestCase::testOperations(
848    }    }
849    
850    {    {
851      cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;      cout << "\tTest unnaryOp negate on DataTagged object with two tags." << endl;
852    
853      DataTagged myData;      DataTagged myData;
854    
855      DataArray vOne(1.0);      DataVector vOneData(1, 1.0 ,1);
856      DataArray vTwo(2.0);      // create a view with an empty shape, a scalar.
857      myData.addTaggedValue(1,vOne.getView());  //     DataArrayView vOneView(vOneData,DataTypes::ShapeType());
858      myData.addTaggedValue(2,vTwo.getView());  
859        DataVector vTwoData(1, 2.0 ,1);
860        // create a view with an empty shape, a scalar.
861    //     DataArrayView vTwoView(vTwoData,DataTypes::ShapeType());
862    
863        myData.addTaggedValue(1,DataTypes::scalarShape,vOneData);
864        myData.addTaggedValue(2,DataTypes::scalarShape,vTwoData);
865    
866      unaryOp(myData,negate<double>());      unaryOp(myData,negate<double>());
867    
# Line 1016  void DataTaggedTestCase::testOperations( Line 885  void DataTaggedTestCase::testOperations(
885    
886      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
887    
888        assert(myData.getRank()==0);
889        assert(myData.getNoValues()==1);
890        assert(myData.getShape().size()==0);
891    
892    
893      // check result value for tag "1"      // check result value for tag "1"
894      DataArrayView myDataView = myData.getDataPointByTag(1);  //     DataArrayView myDataView = myData.getDataPointByTag(1);
895      assert(!myDataView.isEmpty());      int offset=myData.getOffsetForTag(1);
896      assert(myDataView.getOffset()==1);      assert(offset==1);
897      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==-1.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==-1.0);  
898    
899      // check result value for tag "2"      // check result value for tag "2"
900      myDataView = myData.getDataPointByTag(2);  //     myDataView = myData.getDataPointByTag(2);
901      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(2);
902      assert(myDataView.getOffset()==2);      assert(offset==2);
903      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==-2.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==-2.0);  
904    
905      // check result for default value      // check result for default value
906      myDataView = myData.getDefaultValue();  //     myDataView = myData.getDefaultValue();
907      assert(!myDataView.isEmpty());      offset=myData.getDefaultOffset();
908      assert(myDataView.getOffset()==0);      assert(offset==0);
909      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==0.0);
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
910    
911      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
912      // the first element of the data array      // the first element of the data array
# Line 1066  void DataTaggedTestCase::testAddTaggedVa Line 931  void DataTaggedTestCase::testAddTaggedVa
931      DataTagged::TagListType keys;      DataTagged::TagListType keys;
932      keys.push_back(1);      keys.push_back(1);
933    
934      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
935    
936      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,DataTypes::scalarShape);
937    
938      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
939    
# Line 1081  void DataTaggedTestCase::testAddTaggedVa Line 946  void DataTaggedTestCase::testAddTaggedVa
946    
947      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
948    
949      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
950      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
951      assert(myDataView.getOffset()==1);      assert(myData.getShape().size()==0);
952      assert(myDataView.getRank()==0);  
953      assert(myDataView.noValues()==1);  
954      assert(myDataView.getShape().size()==0);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
955      assert(myDataView()==0.0);      int offset=myData.getPointOffset(0,0);
956        assert(offset==1);
957      myDataView = myData.getDataPointByTag(1);      assert(myData.getDataAtOffset(offset)==0.0);
958      assert(!myDataView.isEmpty());  
959      assert(myDataView.getOffset()==1);  //     myDataView = myData.getDataPointByTag(1);
960      assert(myDataView.getRank()==0);      offset=myData.getOffsetForTag(1);
961      assert(myDataView.noValues()==1);      assert(offset==1);
962      assert(myDataView.getShape().size()==0);      assert(myData.getDataAtOffset(offset)==0.0);
963      assert(myDataView()==0.0);  
964    //     myDataView = myData.getDefaultValue();
965      myDataView = myData.getDefaultValue();      offset=myData.getDefaultOffset();
966      assert(!myDataView.isEmpty());      assert(offset==0);
967      assert(myDataView.getOffset()==0);      assert(myData.getDataAtOffset(offset)==0.0);
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
968    
969      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
970      // the first element of the data array      // the first element of the data array
# Line 1122  void DataTaggedTestCase::testAddTaggedVa Line 983  void DataTaggedTestCase::testAddTaggedVa
983      DataTagged::TagListType keys;      DataTagged::TagListType keys;
984      keys.push_back(1);      keys.push_back(1);
985    
986      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
987    
988      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
989      DataArrayView::ValueType viewData(1);  /*    DataTypes::ValueType viewData(1);
990      viewData[0]=1.0;      viewData[0]=1.0;*/
991      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
992      values.push_back(myView);      values.push_back(1.0);
993    
994      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
995    
996      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
997    
# Line 1143  void DataTaggedTestCase::testAddTaggedVa Line 1004  void DataTaggedTestCase::testAddTaggedVa
1004    
1005      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
1006    
1007      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
1008      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
1009      assert(myDataView.getOffset()==1);      assert(myData.getShape().size()==0);
1010      assert(myDataView.getRank()==0);  
1011      assert(myDataView.noValues()==1);  
1012      assert(myDataView.getShape().size()==0);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1013      assert(myDataView()==1.0);      int offset=myData.getPointOffset(0,0);
1014        assert(offset==1);
1015      myDataView = myData.getDataPointByTag(1);      assert(myData.getDataAtOffset(offset)==1.0);
1016      assert(!myDataView.isEmpty());  
1017      assert(myDataView.getOffset()==1);  //     myDataView = myData.getDataPointByTag(1);
1018      assert(myDataView.getRank()==0);      offset=myData.getOffsetForTag(1);
1019      assert(myDataView.noValues()==1);      assert(offset==1);
1020      assert(myDataView.getShape().size()==0);      assert(myData.getDataAtOffset(offset)==1.0);
1021      assert(myDataView()==1.0);  
1022    //     myDataView = myData.getDefaultValue();
1023      myDataView = myData.getDefaultValue();      offset=myData.getDefaultOffset();
1024      assert(!myDataView.isEmpty());      assert(offset==0);
1025      assert(myDataView.getOffset()==0);      assert(myData.getDataAtOffset(offset)==0.0);
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
1026    
1027      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1028      // the first element of the data array      // the first element of the data array
# Line 1186  void DataTaggedTestCase::testAddTaggedVa Line 1043  void DataTaggedTestCase::testAddTaggedVa
1043      keys.push_back(2);      keys.push_back(2);
1044      keys.push_back(3);      keys.push_back(3);
1045    
1046      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1047    
1048      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1049      DataArrayView::ValueType viewData(1);  /*    DataTypes::ValueType viewData(1);
1050      viewData[0]=1.0;      viewData[0]=1.0;
1051      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);*/
1052      values.push_back(myView);      values.push_back(1.0);
1053    
1054      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1055    
1056      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
1057      assert(myData.isCurrentTag(2));      assert(myData.isCurrentTag(2));
# Line 1209  void DataTaggedTestCase::testAddTaggedVa Line 1066  void DataTaggedTestCase::testAddTaggedVa
1066    
1067      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
1068    
1069      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
1070      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
1071      assert(myDataView.getOffset()==1);      assert(myData.getShape().size()==0);
1072      assert(myDataView.getRank()==0);  
1073      assert(myDataView.noValues()==1);  
1074      assert(myDataView.getShape().size()==0);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1075      assert(myDataView()==1.0);      int offset=myData.getPointOffset(0,0);
1076        assert(offset==1);
1077      myDataView = myData.getDataPointByTag(1);      assert(myData.getDataAtOffset(offset)==1.0);
1078      assert(!myDataView.isEmpty());  
1079      assert(myDataView.getOffset()==1);  //     myDataView = myData.getDataPointByTag(1);
1080      assert(myDataView.getRank()==0);      offset=myData.getOffsetForTag(1);
1081      assert(myDataView.noValues()==1);      assert(offset==1);
1082      assert(myDataView.getShape().size()==0);      assert(myData.getDataAtOffset(offset)==1.0);
1083      assert(myDataView()==1.0);  
1084    //     myDataView = myData.getDataPointByTag(2);
1085      myDataView = myData.getDataPointByTag(2);      offset=myData.getOffsetForTag(2);
1086      assert(!myDataView.isEmpty());      assert(offset==2);
1087      assert(myDataView.getOffset()==2);      assert(myData.getDataAtOffset(offset)==1.0);
1088      assert(myDataView.getRank()==0);  
1089      assert(myDataView.noValues()==1);  //     myDataView = myData.getDataPointByTag(3);
1090      assert(myDataView.getShape().size()==0);      offset=myData.getOffsetForTag(3);
1091      assert(myDataView()==1.0);      assert(offset==3);
1092        assert(myData.getDataAtOffset(offset)==1.0);
1093      myDataView = myData.getDataPointByTag(3);  
1094      assert(!myDataView.isEmpty());  //     myDataView = myData.getDefaultValue();
1095      assert(myDataView.getOffset()==3);      offset=myData.getDefaultOffset();
1096      assert(myDataView.getRank()==0);      assert(offset==0);
1097      assert(myDataView.noValues()==1);      assert(myData.getDataAtOffset(offset)==0.0);
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1.0);  
   
     myDataView = myData.getDefaultValue();  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
1098    
1099      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1100      // the first element of the data array      // the first element of the data array
# Line 1272  void DataTaggedTestCase::testAddTaggedVa Line 1119  void DataTaggedTestCase::testAddTaggedVa
1119      keys.push_back(2);      keys.push_back(2);
1120      keys.push_back(3);      keys.push_back(3);
1121    
1122      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1123    
1124      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1125      DataArrayView::ValueType viewData1(1);  /*    DataTypes::ValueType viewData1(1);
1126      viewData1[0]=1.0;      viewData1[0]=1.0;
1127      DataArrayView::ValueType viewData2(1);      DataTypes::ValueType viewData2(1);
1128      viewData2[0]=2.0;      viewData2[0]=2.0;
1129      DataArrayView::ValueType viewData3(1);      DataTypes::ValueType viewData3(1);
1130      viewData3[0]=3.0;      viewData3[0]=3.0;
1131      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1132      DataArrayView myView2(viewData2,viewShape);      DataArrayView myView2(viewData2,viewShape);
1133      DataArrayView myView3(viewData3,viewShape);      DataArrayView myView3(viewData3,viewShape);*/
1134      values.push_back(myView1);      values.push_back(1.0);
1135      values.push_back(myView2);      values.push_back(2.0);
1136      values.push_back(myView3);      values.push_back(3.0);
1137    
1138      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1139    
1140      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
1141      assert(myData.isCurrentTag(2));      assert(myData.isCurrentTag(2));
# Line 1303  void DataTaggedTestCase::testAddTaggedVa Line 1150  void DataTaggedTestCase::testAddTaggedVa
1150    
1151      assert(myData.getPointOffset(0,0)==1);      assert(myData.getPointOffset(0,0)==1);
1152    
1153      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
1154      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
1155      assert(myDataView.getOffset()==1);      assert(myData.getShape().size()==0);
1156      assert(myDataView.getRank()==0);  
1157      assert(myDataView.noValues()==1);  
1158      assert(myDataView.getShape().size()==0);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1159      assert(myDataView()==1.0);      int offset=myData.getPointOffset(0,0);
1160        assert(offset==1);
1161      myDataView = myData.getDataPointByTag(1);      assert(myData.getDataAtOffset(offset)==1.0);
1162      assert(!myDataView.isEmpty());  
1163      assert(myDataView.getOffset()==1);  //     myDataView = myData.getDataPointByTag(1);
1164      assert(myDataView.getRank()==0);      offset=myData.getOffsetForTag(1);
1165      assert(myDataView.noValues()==1);      assert(offset==1);
1166      assert(myDataView.getShape().size()==0);      assert(myData.getDataAtOffset(offset)==1.0);
1167      assert(myDataView()==1.0);  
1168    //     myDataView = myData.getDataPointByTag(2);
1169      myDataView = myData.getDataPointByTag(2);      offset=myData.getOffsetForTag(2);
1170      assert(!myDataView.isEmpty());      assert(offset==2);
1171      assert(myDataView.getOffset()==2);      assert(myData.getDataAtOffset(offset)==2.0);
1172      assert(myDataView.getRank()==0);  
1173      assert(myDataView.noValues()==1);  //     myDataView = myData.getDataPointByTag(3);
1174      assert(myDataView.getShape().size()==0);      offset=myData.getOffsetForTag(3);
1175      assert(myDataView()==2.0);      assert(offset==3);
1176        assert(myData.getDataAtOffset(offset)==3.0);
1177      myDataView = myData.getDataPointByTag(3);  
1178      assert(!myDataView.isEmpty());  //     myDataView = myData.getDefaultValue();
1179      assert(myDataView.getOffset()==3);      offset=myData.getDefaultOffset();
1180      assert(myDataView.getRank()==0);      assert(offset==0);
1181      assert(myDataView.noValues()==1);      assert(myData.getDataAtOffset(offset)==0.0);
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==3.0);  
   
     myDataView = myData.getDefaultValue();  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
1182    
1183      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1184      // the first element of the data array      // the first element of the data array
# Line 1356  void DataTaggedTestCase::testAddTaggedVa Line 1193  void DataTaggedTestCase::testAddTaggedVa
1193    
1194      cout << "\tTest adding one key with empty value list to DataTagged with default value only." << endl;      cout << "\tTest adding one key with empty value list to DataTagged with default value only." << endl;
1195    
1196      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1197      viewShape.push_back(3);      viewShape.push_back(3);
1198    
1199      DataTagged::TagListType keys;      DataTagged::TagListType keys;
1200    
1201      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1202    
1203      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
1204      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1205        viewData[i]=i;        viewData[i]=i;
1206      }      }
     DataArrayView myView(viewData,viewShape);  
1207    
1208      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
1209    
1210      keys.push_back(1);      keys.push_back(1);
1211      values.clear();      values.clear();
1212    
1213      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1214    
1215      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
1216    
# Line 1387  void DataTaggedTestCase::testAddTaggedVa Line 1223  void DataTaggedTestCase::testAddTaggedVa
1223    
1224      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
1225    
1226      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
1227      assert(myDataView==myView);      assert(myData.getNoValues()==3);
1228      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1229      assert(myDataView.getOffset()==3);  
1230      assert(myDataView.getRank()==1);  
1231      assert(myDataView.noValues()==3);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1232      assert(myDataView.getShape().size()==1);      int offset=myData.getPointOffset(0,0);
1233      assert(myDataView(0)==0);      assert(offset==3);
1234      assert(myDataView(1)==1);      assert(getRef(myData,offset,0)==0);
1235      assert(myDataView(2)==2);      assert(getRef(myData,offset,1)==1);
1236        assert(getRef(myData,offset,2)==2);
1237      myDataView = myData.getDataPointByTag(1);  
1238      assert(myDataView==myView);  //     myDataView = myData.getDataPointByTag(1);
1239      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(1);
1240      assert(myDataView.getOffset()==3);      assert(offset==3);
1241      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,0)==0);
1242      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,1)==1);
1243      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,2)==2);
1244      assert(myDataView(0)==0);  
1245      assert(myDataView(1)==1);  //     myDataView = myData.getDefaultValue();
1246      assert(myDataView(2)==2);      offset=myData.getDefaultOffset();
1247        assert(offset==0);
1248      myDataView = myData.getDefaultValue();      assert(getRef(myData,offset,0)==0);
1249      assert(myDataView==myView);      assert(getRef(myData,offset,1)==1);
1250      assert(!myDataView.isEmpty());      assert(getRef(myData,offset,2)==2);
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
1251    
1252      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1253      // the first element of the data array      // the first element of the data array
# Line 1433  void DataTaggedTestCase::testAddTaggedVa Line 1262  void DataTaggedTestCase::testAddTaggedVa
1262    
1263      cout << "\tTest adding one key with one value to DataTagged with default value only." << endl;      cout << "\tTest adding one key with one value to DataTagged with default value only." << endl;
1264    
1265      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1266      viewShape.push_back(3);      viewShape.push_back(3);
1267    
1268      DataTagged::TagListType keys;      DataTagged::TagListType keys;
1269    
1270      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1271    
1272      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
1273      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1274        viewData[i]=i;        viewData[i]=i;
1275      }      }
1276      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1277    
1278      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
1279    
1280      keys.push_back(1);      keys.push_back(1);
1281    
1282      DataArrayView::ValueType viewData1(3);  //     DataTypes::ValueType viewData1(3);
1283      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1284        viewData1[i]=i+3;  //       viewData1[i]=i+3;
1285        values.push_back(i+3);
1286      }      }
1287      DataArrayView myView1(viewData1,viewShape);  //     DataArrayView myView1(viewData1,viewShape);
1288      values.push_back(myView1);  //     values.push_back(myView1);
1289    
1290      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1291    
1292      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
1293    
# Line 1470  void DataTaggedTestCase::testAddTaggedVa Line 1300  void DataTaggedTestCase::testAddTaggedVa
1300    
1301      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
1302    
1303      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
1304      assert(myDataView==myView1);      assert(myData.getNoValues()==3);
1305      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1306      assert(myDataView.getOffset()==3);  
1307      assert(myDataView.getRank()==1);  
1308      assert(myDataView.noValues()==3);      int offset=myData.getPointOffset(0,0);
1309      assert(myDataView.getShape().size()==1);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1310      assert(myDataView(0)==3);      assert(offset==3);
1311      assert(myDataView(1)==4);      assert(getRef(myData,offset,0)==3);
1312      assert(myDataView(2)==5);      assert(getRef(myData,offset,1)==4);
1313        assert(getRef(myData,offset,2)==5);
1314      myDataView = myData.getDataPointByTag(1);  
1315      assert(myDataView==myView1);  //     myDataView = myData.getDataPointByTag(1);
1316      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(1);
1317      assert(myDataView.getOffset()==3);      assert(offset==3);
1318      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,0)==3);
1319      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,1)==4);
1320      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,2)==5);
1321      assert(myDataView(0)==3);  
1322      assert(myDataView(1)==4);  //     myDataView = myData.getDefaultValue();
1323      assert(myDataView(2)==5);      offset=myData.getDefaultOffset();
1324        assert(offset==0);
1325      myDataView = myData.getDefaultValue();      assert(getRef(myData,offset,0)==0);
1326      assert(myDataView==myView);      assert(getRef(myData,offset,1)==1);
1327      assert(!myDataView.isEmpty());      assert(getRef(myData,offset,2)==2);
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
1328    
1329      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1330      // the first element of the data array      // the first element of the data array
# Line 1516  void DataTaggedTestCase::testAddTaggedVa Line 1339  void DataTaggedTestCase::testAddTaggedVa
1339    
1340      cout << "\tTest adding three keys with one value to DataTagged with default value only." << endl;      cout << "\tTest adding three keys with one value to DataTagged with default value only." << endl;
1341    
1342      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1343      viewShape.push_back(3);      viewShape.push_back(3);
1344    
1345      DataTagged::TagListType keys;      DataTagged::TagListType keys;
1346    
1347      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1348    
1349      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
1350      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1351        viewData[i]=i;        viewData[i]=i;
1352      }      }
1353      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1354    
1355      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
1356    
1357      keys.push_back(1);      keys.push_back(1);
1358      keys.push_back(2);      keys.push_back(2);
1359      keys.push_back(3);      keys.push_back(3);
1360    
1361      DataArrayView::ValueType viewData1(3);  //     DataTypes::ValueType viewData1(3);
1362      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1363        viewData1[i]=3;  //       viewData1[i]=3;
1364        values.push_back(3);
1365      }      }
1366      DataArrayView myView1(viewData1,viewShape);  //     DataArrayView myView1(viewData1,viewShape);
1367      values.push_back(myView1);  //     values.push_back(myView1);
1368    
1369      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1370    
1371      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
1372      assert(myData.isCurrentTag(2));      assert(myData.isCurrentTag(2));
# Line 1557  void DataTaggedTestCase::testAddTaggedVa Line 1381  void DataTaggedTestCase::testAddTaggedVa
1381    
1382      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
1383    
1384      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
1385      assert(myDataView==myView1);      assert(myData.getNoValues()==3);
1386      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1387      assert(myDataView.getOffset()==3);  
1388      assert(myDataView.getRank()==1);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1389      assert(myDataView.noValues()==3);      int offset=myData.getPointOffset(0,0);
1390      assert(myDataView.getShape().size()==1);      assert(offset==3);
1391      assert(myDataView(0)==3);      assert(getRef(myData,offset,0)==3);
1392      assert(myDataView(1)==3);      assert(getRef(myData,offset,1)==3);
1393      assert(myDataView(2)==3);      assert(getRef(myData,offset,2)==3);
1394    
1395      myDataView = myData.getDataPointByTag(1);  //     myDataView = myData.getDataPointByTag(1);
1396      assert(myDataView==myView1);      offset=myData.getOffsetForTag(1);
1397      assert(!myDataView.isEmpty());      assert(offset==3);
1398      assert(myDataView.getOffset()==3);      assert(getRef(myData,offset,0)==3);
1399      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==3);
1400      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==3);
1401      assert(myDataView.getShape().size()==1);  
1402      assert(myDataView(0)==3);  //     myDataView = myData.getDataPointByTag(2);
1403      assert(myDataView(1)==3);      offset=myData.getOffsetForTag(2);
1404      assert(myDataView(2)==3);      assert(offset==6);
1405        assert(getRef(myData,offset,0)==3);
1406      myDataView = myData.getDataPointByTag(2);      assert(getRef(myData,offset,1)==3);
1407      assert(myDataView==myView1);      assert(getRef(myData,offset,2)==3);
1408      assert(!myDataView.isEmpty());  
1409      assert(myDataView.getOffset()==6);  //     myDataView = myData.getDataPointByTag(3);
1410      assert(myDataView.getRank()==1);      offset=myData.getOffsetForTag(3);
1411      assert(myDataView.noValues()==3);      assert(offset==9);
1412      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,0)==3);
1413      assert(myDataView(0)==3);      assert(getRef(myData,offset,1)==3);
1414      assert(myDataView(1)==3);      assert(getRef(myData,offset,2)==3);
1415      assert(myDataView(2)==3);  
1416    //     myDataView = myData.getDefaultValue();
1417      myDataView = myData.getDataPointByTag(3);      offset=myData.getDefaultOffset();
1418      assert(myDataView==myView1);      assert(offset==0);
1419      assert(!myDataView.isEmpty());      assert(getRef(myData,offset,0)==0);
1420      assert(myDataView.getOffset()==9);      assert(getRef(myData,offset,1)==1);
1421      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,2)==2);
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==3);  
     assert(myDataView(1)==3);  
     assert(myDataView(2)==3);  
   
     myDataView = myData.getDefaultValue();  
     assert(myDataView==myView);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
1422    
1423      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1424      // the first element of the data array      // the first element of the data array
# Line 1629  void DataTaggedTestCase::testAddTaggedVa Line 1437  void DataTaggedTestCase::testAddTaggedVa
1437    
1438      cout << "\tTest adding three keys with three values to DataTagged with default value only." << endl;      cout << "\tTest adding three keys with three values to DataTagged with default value only." << endl;
1439    
1440      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1441      viewShape.push_back(3);      viewShape.push_back(3);
1442    
1443      DataTagged::TagListType keys;      DataTagged::TagListType keys;
1444    
1445      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1446    
1447      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
1448      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1449        viewData[i]=i;        viewData[i]=i;
1450      }      }
1451      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1452    
1453      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
1454    
1455      keys.push_back(1);      keys.push_back(1);
1456      keys.push_back(2);      keys.push_back(2);
1457      keys.push_back(3);      keys.push_back(3);
1458    
1459      DataArrayView::ValueType viewData1(3);  //     DataTypes::ValueType viewData1(3);
1460      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1461        viewData1[i]=i+1;  //       viewData1[i]=i+1;
1462        values.push_back(i+1);
1463      }      }
1464      DataArrayView myView1(viewData1,viewShape);  //     DataArrayView myView1(viewData1,viewShape);
1465      values.push_back(myView1);  //     values.push_back(myView1);
1466    
1467      DataArrayView::ValueType viewData2(3);  //     DataTypes::ValueType viewData2(3);
1468      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1469        viewData2[i]=i+2;  //       viewData2[i]=i+2;
1470        values.push_back(i+2);
1471      }      }
1472      DataArrayView myView2(viewData2,viewShape);  //     DataArrayView myView2(viewData2,viewShape);
1473      values.push_back(myView2);  //     values.push_back(myView2);
1474    
1475      DataArrayView::ValueType viewData3(3);  //     DataTypes::ValueType viewData3(3);
1476      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1477        viewData3[i]=i+3;  //       viewData3[i]=i+3;
1478        values.push_back(i+3);
1479      }      }
1480      DataArrayView myView3(viewData3,viewShape);  //     DataArrayView myView3(viewData3,viewShape);
1481      values.push_back(myView3);  //     values.push_back(myView3);
1482    
1483      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1484    
1485      assert(myData.isCurrentTag(1));      assert(myData.isCurrentTag(1));
1486      assert(myData.isCurrentTag(2));      assert(myData.isCurrentTag(2));
# Line 1684  void DataTaggedTestCase::testAddTaggedVa Line 1495  void DataTaggedTestCase::testAddTaggedVa
1495    
1496      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
1497    
1498      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
1499      assert(myDataView==myView1);      assert(myData.getNoValues()==3);
1500      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1501      assert(myDataView.getOffset()==3);  
1502      assert(myDataView.getRank()==1);  
1503      assert(myDataView.noValues()==3);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
1504      assert(myDataView.getShape().size()==1);      int offset=myData.getPointOffset(0,0);
1505      assert(myDataView(0)==1);      assert(offset==3);
1506      assert(myDataView(1)==2);      assert(getRef(myData,offset,0)==1);
1507      assert(myDataView(2)==3);      assert(getRef(myData,offset,1)==2);
1508        assert(getRef(myData,offset,2)==3);
1509      myDataView = myData.getDataPointByTag(1);  
1510      assert(myDataView==myView1);  //     myDataView = myData.getDataPointByTag(1);
1511      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(1);
1512      assert(myDataView.getOffset()==3);      assert(offset==3);
1513      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,0)==1);
1514      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,1)==2);
1515      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,2)==3);
1516      assert(myDataView(0)==1);  
1517      assert(myDataView(1)==2);  //     myDataView = myData.getDataPointByTag(2);
1518      assert(myDataView(2)==3);      offset=myData.getOffsetForTag(2);
1519        assert(offset==6);
1520      myDataView = myData.getDataPointByTag(2);      assert(getRef(myData,offset,0)==2);
1521      assert(myDataView==myView2);      assert(getRef(myData,offset,1)==3);
1522      assert(!myDataView.isEmpty());      assert(getRef(myData,offset,2)==4);
1523      assert(myDataView.getOffset()==6);  
1524      assert(myDataView.getRank()==1);  //     myDataView = myData.getDataPointByTag(3);
1525      assert(myDataView.noValues()==3);      offset=myData.getOffsetForTag(3);
1526      assert(myDataView.getShape().size()==1);      assert(offset==9);
1527      assert(myDataView(0)==2);      assert(getRef(myData,offset,0)==3);
1528      assert(myDataView(1)==3);      assert(getRef(myData,offset,1)==4);
1529      assert(myDataView(2)==4);      assert(getRef(myData,offset,2)==5);
1530    
1531      myDataView = myData.getDataPointByTag(3);  //     myDataView = myData.getDefaultValue();
1532      assert(myDataView==myView3);      offset=myData.getDefaultOffset();
1533      assert(!myDataView.isEmpty());      assert(offset==0);
1534      assert(myDataView.getOffset()==9);      assert(getRef(myData,offset,0)==0);
1535      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==1);
1536      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==2);
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==3);  
     assert(myDataView(1)==4);  
     assert(myDataView(2)==5);  
   
     myDataView = myData.getDefaultValue();  
     assert(myDataView==myView);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
1537    
1538      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1539      // the first element of the data array      // the first element of the data array
# Line 1765  void DataTaggedTestCase::testAddTaggedVa Line 1561  void DataTaggedTestCase::testAddTaggedVa
1561      keys.push_back(2);      keys.push_back(2);
1562      keys.push_back(3);      keys.push_back(3);
1563    
1564      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1565    
1566      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1567      viewShape.push_back(3);      viewShape.push_back(3);
1568    
1569      // default value      // default value
1570      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
1571      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1572        viewData[i]=i;        viewData[i]=i;
1573      }      }
1574      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1575    
1576      // value for tag "1"      // value for tag "1"
1577      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
1578      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
1579        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
1580    //       eOneView(i)=i+1.0;
1581          viewData[viewShape[0]+i]=i+1.0;
1582      }      }
1583      values.push_back(eOne.getView());  //     values.push_back(eOneView);
1584    
1585      // value for tag "2"      // value for tag "2"
1586      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
1587      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
1588        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
1589    //       eTwoView(i)=i+2.0;
1590        viewData[2*viewShape[0]+i]=i+2.0;
1591      }      }
1592      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
1593    
1594      // value for tag "3"      // value for tag "3"
1595      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
1596      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
1597        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
1598    //       eThreeView(i)=i+3.0;
1599        viewData[3*viewShape[0]+i]=i+3.0;
1600      }      }
1601      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
1602    
1603      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1604    
1605      keys.clear();      keys.clear();
1606      keys.push_back(4);      keys.push_back(4);
1607      values.clear();      values.clear();
1608    
1609      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1610    
1611      assert(myData.isCurrentTag(4));      assert(myData.isCurrentTag(4));
1612    
# Line 1812  void DataTaggedTestCase::testAddTaggedVa Line 1614  void DataTaggedTestCase::testAddTaggedVa
1614    
1615      assert(myData.getLength()==15);      assert(myData.getLength()==15);
1616    
1617      DataArrayView myDataView = myData.getDataPointByTag(4);      assert(myData.getRank()==1);
1618      assert(myDataView==myView);      assert(myData.getNoValues()==3);
1619      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1620      assert(myDataView.getOffset()==12);  
1621      assert(myDataView.getRank()==1);  //     DataArrayView myDataView = myData.getDataPointByTag(4);
1622      assert(myDataView.noValues()==3);      int offset=myData.getOffsetForTag(4);
1623      assert(myDataView.getShape().size()==1);      assert(offset==12);
1624      assert(myDataView(0)==0);      assert(getRef(myData,offset,0)==0);
1625      assert(myDataView(1)==1);      assert(getRef(myData,offset,1)==1);
1626      assert(myDataView(2)==2);      assert(getRef(myData,offset,2)==2);
1627    
1628      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1629      // the first element of the data array      // the first element of the data array
# Line 1851  void DataTaggedTestCase::testAddTaggedVa Line 1653  void DataTaggedTestCase::testAddTaggedVa
1653      keys.push_back(2);      keys.push_back(2);
1654      keys.push_back(3);      keys.push_back(3);
1655    
1656      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1657    
1658      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1659      viewShape.push_back(3);      viewShape.push_back(3);
1660    
1661      // default value      // default value
1662      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
1663      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1664        viewData[i]=i;        viewData[i]=i;
1665      }      }
1666      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1667    
1668      // value for tag "1"      // value for tag "1"
1669      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
1670      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
1671        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
1672    //       eOneView(i)=i+1.0;
1673        viewData[viewShape[0]+i]=i+1.0;
1674      }      }
1675      values.push_back(eOne.getView());  //     values.push_back(eOneView);
1676    
1677      // value for tag "2"      // value for tag "2"
1678      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
1679      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
1680        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
1681    //       eTwoView(i)=i+2.0;
1682        viewData[2*viewShape[0]+i]=i+2.0;
1683      }      }
1684      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
1685    
1686      // value for tag "3"      // value for tag "3"
1687      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
1688      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
1689        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
1690    //       eThreeView(i)=i+3.0;
1691        viewData[3*viewShape[0]+i]=i+3.0;
1692      }      }
1693      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
1694    
1695      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1696    
1697      keys.clear();      keys.clear();
1698      keys.push_back(4);      keys.push_back(4);
1699    
1700      values.clear();      values.clear();
1701      // value for tag "4"      // value for tag "4"
1702      DataArray eFour(myView);  //     DataTypes::ValueType eFourData(viewData);
1703      for (int i=0;i<eFour.getView().getShape()[0];i++) {  //     DataArrayView eFourView(eFourData, viewShape);
1704        eFour.getView()(i)=i+4.0;      for (int i=0;i<viewShape[0];i++) {
1705          values.push_back(i+4.0);
1706      }      }
1707      values.push_back(eFour.getView());  //     values.push_back(eFourView);
1708    
1709      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1710    
1711      assert(myData.isCurrentTag(4));      assert(myData.isCurrentTag(4));
1712    
# Line 1905  void DataTaggedTestCase::testAddTaggedVa Line 1714  void DataTaggedTestCase::testAddTaggedVa
1714    
1715      assert(myData.getLength()==15);      assert(myData.getLength()==15);
1716    
1717      DataArrayView myDataView = myData.getDataPointByTag(4);      assert(myData.getRank()==1);
1718      assert(myDataView==eFour.getView());      assert(myData.getNoValues()==3);
1719      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1720      assert(myDataView.getOffset()==12);  
1721      assert(myDataView.getRank()==1);  
1722      assert(myDataView.noValues()==3);  //     DataArrayView myDataView = myData.getDataPointByTag(4);
1723      assert(myDataView.getShape().size()==1);      int offset=myData.getOffsetForTag(4);
1724      assert(myDataView(0)==4);      assert(offset==12);
1725      assert(myDataView(1)==5);      assert(getRef(myData,offset,0)==4);
1726      assert(myDataView(2)==6);      assert(getRef(myData,offset,1)==5);
1727        assert(getRef(myData,offset,2)==6);
1728    
1729      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1730      // the first element of the data array      // the first element of the data array
# Line 1944  void DataTaggedTestCase::testAddTaggedVa Line 1754  void DataTaggedTestCase::testAddTaggedVa
1754      keys.push_back(2);      keys.push_back(2);
1755      keys.push_back(3);      keys.push_back(3);
1756    
1757      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1758    
1759      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1760      viewShape.push_back(3);      viewShape.push_back(3);
1761    
1762      // default value      // default value
1763      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
1764      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1765        viewData[i]=i;        viewData[i]=i;
1766      }      }
1767      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1768    
1769      // value for tag "1"      // value for tag "1"
1770      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
1771      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
1772        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
1773          viewData[viewShape[0]+i]=i+1.0;
1774      }      }
1775      values.push_back(eOne.getView());  //     values.push_back(eOneView);
1776    
1777      // value for tag "2"      // value for tag "2"
1778      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
1779      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
1780        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
1781    //       eTwoView(i)=i+2.0;
1782        viewData[2*viewShape[0]+i]=i+2.0;
1783      }      }
1784      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
1785    
1786      // value for tag "3"      // value for tag "3"
1787      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
1788      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
1789        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
1790    //       eThreeView(i)=i+3.0;
1791        viewData[3*viewShape[0]+i]=i+3.0;
1792      }      }
1793      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
1794    
1795      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1796    
1797      keys.clear();      keys.clear();
1798      keys.push_back(4);      keys.push_back(4);
# Line 1986  void DataTaggedTestCase::testAddTaggedVa Line 1801  void DataTaggedTestCase::testAddTaggedVa
1801    
1802      values.clear();      values.clear();
1803      // value for tags "4", "5" and "6"      // value for tags "4", "5" and "6"
1804      DataArray eFour(myView);  //     DataTypes::ValueType eFourData(viewData);
1805      for (int i=0;i<eFour.getView().getShape()[0];i++) {  //     DataArrayView eFourView(eFourData, viewShape);
1806        eFour.getView()(i)=i+4.0;      for (int i=0;i<viewShape[0];i++) {
1807    //       eFourView(i)=i+4.0;
1808        values.push_back(i+4.0);
1809      }      }
1810      values.push_back(eFour.getView());  //     values.push_back(eFourView);
1811    
1812      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1813    
1814      assert(myData.isCurrentTag(4));      assert(myData.isCurrentTag(4));
1815      assert(myData.isCurrentTag(5));      assert(myData.isCurrentTag(5));
# Line 2002  void DataTaggedTestCase::testAddTaggedVa Line 1819  void DataTaggedTestCase::testAddTaggedVa
1819    
1820      assert(myData.getLength()==21);      assert(myData.getLength()==21);
1821    
1822      DataArrayView myDataView = myData.getDataPointByTag(4);      assert(myData.getRank()==1);
1823      assert(myDataView==eFour.getView());      assert(myData.getNoValues()==3);
1824      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1825      assert(myDataView.getOffset()==12);  
1826      assert(myDataView.getRank()==1);  //     DataArrayView myDataView = myData.getDataPointByTag(4);
1827      assert(myDataView.noValues()==3);      int offset=myData.getOffsetForTag(4);
1828      assert(myDataView.getShape().size()==1);      assert(offset==12);
1829      assert(myDataView(0)==4);      assert(getRef(myData,offset,0)==4);
1830      assert(myDataView(1)==5);      assert(getRef(myData,offset,1)==5);
1831      assert(myDataView(2)==6);      assert(getRef(myData,offset,2)==6);
1832    
1833      myDataView = myData.getDataPointByTag(5);  //     myDataView = myData.getDataPointByTag(5);
1834      assert(myDataView==eFour.getView());      offset=myData.getOffsetForTag(5);
1835      assert(!myDataView.isEmpty());      assert(offset==15);
1836      assert(myDataView.getOffset()==15);      assert(getRef(myData,offset,0)==4);
1837      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==5);
1838      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==6);
1839      assert(myDataView.getShape().size()==1);  
1840      assert(myDataView(0)==4);  //     myDataView = myData.getDataPointByTag(6);
1841      assert(myDataView(1)==5);      offset=myData.getOffsetForTag(6);
1842      assert(myDataView(2)==6);      assert(offset==18);
1843        assert(getRef(myData,offset,0)==4);
1844      myDataView = myData.getDataPointByTag(6);      assert(getRef(myData,offset,1)==5);
1845      assert(myDataView==eFour.getView());      assert(getRef(myData,offset,2)==6);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==18);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==4);  
     assert(myDataView(1)==5);  
     assert(myDataView(2)==6);  
1846    
1847      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1848      // the first element of the data array      // the first element of the data array
# Line 2067  void DataTaggedTestCase::testAddTaggedVa Line 1876  void DataTaggedTestCase::testAddTaggedVa
1876      keys.push_back(2);      keys.push_back(2);
1877      keys.push_back(3);      keys.push_back(3);
1878    
1879      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
1880    
1881      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
1882      viewShape.push_back(3);      viewShape.push_back(3);
1883    
1884      // default value      // default value
1885      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
1886      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1887        viewData[i]=i;        viewData[i]=i;
1888      }      }
1889      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
1890    
1891      // value for tag "1"      // value for tag "1"
1892      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
1893      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
1894        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
1895          viewData[viewShape[0]+i]=i+1.0;
1896      }      }
1897      values.push_back(eOne.getView());  //     values.push_back(eOneView);
1898    
1899      // value for tag "2"      // value for tag "2"
1900      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
1901      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
1902        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
1903    //       eTwoView(i)=i+2.0;
1904        viewData[2*viewShape[0]+i]=i+2.0;
1905      }      }
1906      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
1907    
1908      // value for tag "3"      // value for tag "3"
1909      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
1910      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
1911        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
1912          viewData[3*viewShape[0]+i]=i+3.0;
1913      }      }
1914      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
1915    
1916      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
1917    
1918      keys.clear();      keys.clear();
1919      keys.push_back(4);      keys.push_back(4);
# Line 2110  void DataTaggedTestCase::testAddTaggedVa Line 1923  void DataTaggedTestCase::testAddTaggedVa
1923      values.clear();      values.clear();
1924    
1925      // value for tag "4"      // value for tag "4"
1926      DataArray eFour(myView);  //     DataTypes::ValueType eFourData(viewData);
1927      for (int i=0;i<eFour.getView().getShape()[0];i++) {  //     DataArrayView eFourView(eFourData, viewShape);
1928        eFour.getView()(i)=i+4.0;      for (int i=0;i<viewShape[0];i++) {
1929          values.push_back(i+4.0);
1930      }      }
1931      values.push_back(eFour.getView());  //     values.push_back(eFourView);
1932    
1933      // value for tag "5"      // value for tag "5"
1934      DataArray eFive(myView);  //     DataTypes::ValueType eFiveData(viewData);
1935      for (int i=0;i<eFive.getView().getShape()[0];i++) {  //     DataArrayView eFiveView(eFiveData, viewShape);
1936        eFive.getView()(i)=i+5.0;      for (int i=0;i<viewShape[0];i++) {
1937          values.push_back(i+5.0);
1938      }      }
1939      values.push_back(eFive.getView());  //     values.push_back(eFiveView);
1940    
1941      // value for tag "6"      // value for tag "6"
1942      DataArray eSix(myView);  //     DataTypes::ValueType eSixData(viewData);
1943      for (int i=0;i<eSix.getView().getShape()[0];i++) {  //     DataArrayView eSixView(eSixData, viewShape);
1944        eSix.getView()(i)=i+6.0;      for (int i=0;i<viewShape[0];i++) {
1945    //       eSixView(i)=i+6.0;
1946        values.push_back(i+6.0);
1947      }      }
1948      values.push_back(eSix.getView());  //     values.push_back(eSixView);
1949    
1950      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values,viewShape);
1951    
1952      assert(myData.isCurrentTag(4));      assert(myData.isCurrentTag(4));
1953      assert(myData.isCurrentTag(5));      assert(myData.isCurrentTag(5));
# Line 2140  void DataTaggedTestCase::testAddTaggedVa Line 1957  void DataTaggedTestCase::testAddTaggedVa
1957    
1958      assert(myData.getLength()==21);      assert(myData.getLength()==21);
1959    
1960      DataArrayView myDataView = myData.getDataPointByTag(4);      assert(myData.getRank()==1);
1961      assert(myDataView==eFour.getView());      assert(myData.getNoValues()==3);
1962      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
1963      assert(myDataView.getOffset()==12);  
1964      assert(myDataView.getRank()==1);  //     DataArrayView myDataView = myData.getDataPointByTag(4);
1965      assert(myDataView.noValues()==3);      int offset=myData.getOffsetForTag(4);
1966      assert(myDataView.getShape().size()==1);      assert(offset==12);
1967      assert(myDataView(0)==4);      assert(getRef(myData,offset,0)==4);
1968      assert(myDataView(1)==5);      assert(getRef(myData,offset,1)==5);
1969      assert(myDataView(2)==6);      assert(getRef(myData,offset,2)==6);
1970    
1971      myDataView = myData.getDataPointByTag(5);  //     myDataView = myData.getDataPointByTag(5);
1972      assert(myDataView==eFive.getView());      offset=myData.getOffsetForTag(5);
1973      assert(!myDataView.isEmpty());      assert(offset==15);
1974      assert(myDataView.getOffset()==15);      assert(getRef(myData,offset,0)==5);
1975      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==6);
1976      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==7);
1977      assert(myDataView.getShape().size()==1);  
1978      assert(myDataView(0)==5);  //     myDataView = myData.getDataPointByTag(6);
1979      assert(myDataView(1)==6);      offset=myData.getOffsetForTag(6);
1980      assert(myDataView(2)==7);      assert(offset==18);
1981        assert(getRef(myData,offset,0)==6);
1982      myDataView = myData.getDataPointByTag(6);      assert(getRef(myData,offset,1)==7);
1983      assert(myDataView==eSix.getView());      assert(getRef(myData,offset,2)==8);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==18);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==6);  
     assert(myDataView(1)==7);  
     assert(myDataView(2)==8);  
1984    
1985      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
1986      // the first element of the data array      // the first element of the data array
# Line 2211  void DataTaggedTestCase::testSetTaggedVa Line 2020  void DataTaggedTestCase::testSetTaggedVa
2020      keys.push_back(2);      keys.push_back(2);
2021      keys.push_back(3);      keys.push_back(3);
2022    
2023      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2024    
2025      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2026      viewShape.push_back(3);      viewShape.push_back(3);
2027    
2028      // default value      // default value
2029      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
2030      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
2031        viewData[i]=i;        viewData[i]=i;
2032      }      }
2033      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2034    
2035      // value for tag "1"      // value for tag "1"
2036      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
2037      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
2038        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
2039          viewData[viewShape[0]+i]=i+1.0;
2040      }      }
2041      values.push_back(eOne.getView());  //     values.push_back(eOneView);
2042    
2043      // value for tag "2"      // value for tag "2"
2044      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
2045      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
2046        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
2047    //       eTwoView(i)=i+2.0;
2048          viewData[2*viewShape[0]+i]=i+2.0;
2049      }      }
2050      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
2051    
2052      // value for tag "3"      // value for tag "3"
2053      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
2054      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
2055        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
2056    //       eThreeView(i)=i+3.0;
2057        viewData[3*viewShape[0]+i]=i+3.0;
2058      }      }
2059      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
2060    
2061      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
2062    
2063      // new value for tag "2"      // new value for tag "2"
2064      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      ValueType tmp(viewShape[0]);
2065        eTwo.getView()(i)=i+5.0;      for (int i=0;i<viewShape[0];i++) {
2066          tmp[i]=i+5.0;
2067      }      }
2068    
2069      myData.setTaggedValue(2,eTwo.getView());      myData.setTaggedValue(2,viewShape,tmp);
2070    
2071      assert(myData.isCurrentTag(2));      assert(myData.isCurrentTag(2));
2072    
# Line 2259  void DataTaggedTestCase::testSetTaggedVa Line 2074  void DataTaggedTestCase::testSetTaggedVa
2074    
2075      assert(myData.getLength()==12);      assert(myData.getLength()==12);
2076    
2077      DataArrayView myDataView = myData.getDataPointByTag(2);      assert(myData.getRank()==1);
2078      assert(myDataView==eTwo.getView());      assert(myData.getNoValues()==3);
2079      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
2080      assert(myDataView.getOffset()==6);  //     DataArrayView myDataView = myData.getDataPointByTag(2);
2081      assert(myDataView.getRank()==1);      int offset=myData.getOffsetForTag(2);
2082      assert(myDataView.noValues()==3);      assert(offset==6);
2083      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,0)==5);
2084      assert(myDataView(0)==5);      assert(getRef(myData,offset,1)==6);
2085      assert(myDataView(1)==6);      assert(getRef(myData,offset,2)==7);
     assert(myDataView(2)==7);  
2086    
2087      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2088      // the first element of the data array      // the first element of the data array
# Line 2319  void DataTaggedTestCase::testAll() { Line 2133  void DataTaggedTestCase::testAll() {
2133    
2134      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
2135    
2136      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
2137      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
2138      assert(myDataView.getOffset()==0);      assert(myData.getShape().size()==0);
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
2139    
     // Test non-existent tag returns the default value.  
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==0.0);  
2140    
2141      myDataView = myData.getDefaultValue();  //     DataArrayView myDataView = myData.getDataPoint(0,0);
2142      assert(!myDataView.isEmpty());      int offset=myData.getPointOffset(0,0);
2143      assert(myDataView.getOffset()==0);      assert(offset==0);
2144      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==0.0);
2145      assert(myDataView.noValues()==1);  
2146      assert(myDataView.getShape().size()==0);      // Test non-existent tag returns the default value.
2147      assert(myDataView()==0.0);  //     myDataView = myData.getDataPointByTag(1);
2148        offset=myData.getOffsetForTag(1);
2149        assert(offset==0);
2150        assert(myData.getDataAtOffset(offset)==0.0);
2151    
2152    //     myDataView = myData.getDefaultValue();
2153        offset=myData.getDefaultOffset();
2154        assert(offset==0);
2155        assert(myData.getDataAtOffset(offset)==0.0);
2156    
2157      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2158      // the first element of the data array      // the first element of the data array
# Line 2351  void DataTaggedTestCase::testAll() { Line 2161  void DataTaggedTestCase::testAll() {
2161        assert(sampleData[i]==i);        assert(sampleData[i]==i);
2162      }      }
2163      sampleData=myData.getSampleData(0);      sampleData=myData.getSampleData(0);
2164      for (int i=0; i<myDataView.noValues(); i++) {      for (unsigned int i=0; i<myData.getNoValues(); i++) {
2165        assert(sampleData[i]==i);        assert(sampleData[i]==i);
2166      }      }
2167    
# Line 2361  void DataTaggedTestCase::testAll() { Line 2171  void DataTaggedTestCase::testAll() {
2171    
2172      cout << "\tTest DataTagged with default value only." << endl;      cout << "\tTest DataTagged with default value only." << endl;
2173    
2174      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2175      viewShape.push_back(3);      viewShape.push_back(3);
2176    
2177      DataTagged::TagListType keys;      DataTagged::TagListType keys;
2178    
2179      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2180    
2181      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
2182      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
2183        viewData[i]=i;        viewData[i]=i;
2184      }      }
2185      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2186        DataTagged myData(FunctionSpace(),viewShape, viewData);
     DataTagged myData(keys,values,myView,FunctionSpace());  
   
2187      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
2188    
2189      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
# Line 2397  void DataTaggedTestCase::testAll() { Line 2205  void DataTaggedTestCase::testAll() {
2205    
2206      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
2207    
2208      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
2209      assert(myDataView==myView);      assert(myData.getNoValues()==3);
2210      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
2211      assert(myDataView.getOffset()==0);  
2212      assert(myDataView.getRank()==1);  //    DataArrayView myDataView = myData.getDataPoint(0,0);
2213      assert(myDataView.noValues()==3);      int offset=myData.getPointOffset(0,0);
2214      assert(myDataView.getShape().size()==1);      assert(offset==0);
2215      assert(myDataView(0)==0);      assert(getRef(myData,offset,0)==0);
2216      assert(myDataView(1)==1);      assert(getRef(myData,offset,1)==1);
2217      assert(myDataView(2)==2);      assert(getRef(myData,offset,2)==2);
2218    
2219      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2220      myDataView = myData.getDataPointByTag(1);  //     myDataView = myData.getDataPointByTag(1);
2221      assert(myDataView==myView);      offset=myData.getOffsetForTag(1);
2222      assert(!myDataView.isEmpty());      assert(offset==0);
2223      assert(myDataView.getOffset()==0);      assert(getRef(myData,offset,0)==0);
2224      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==1);
2225      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==2);
2226      assert(myDataView.getShape().size()==1);  
2227      assert(myDataView(0)==0);  //     myDataView = myData.getDefaultValue();
2228      assert(myDataView(1)==1);      offset=myData.getDefaultOffset();
2229      assert(myDataView(2)==2);      assert(offset==0);
2230        assert(getRef(myData,offset,0)==0);
2231      myDataView = myData.getDefaultValue();      assert(getRef(myData,offset,1)==1);
2232      assert(myDataView==myView);      assert(getRef(myData,offset,2)==2);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
2233    
2234      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2235      // the first element of the data array      // the first element of the data array
# Line 2438  void DataTaggedTestCase::testAll() { Line 2238  void DataTaggedTestCase::testAll() {
2238        assert(sampleData[i]==i);        assert(sampleData[i]==i);
2239      }      }
2240      sampleData=myData.getSampleDataByTag(0);      sampleData=myData.getSampleDataByTag(0);
2241      for (int i=0; i<myDataView.noValues(); i++) {      for (unsigned int i=0; i<myData.getNoValues(); i++) {
2242        assert(sampleData[i]==i);        assert(sampleData[i]==i);
2243      }      }
2244    
# Line 2453  void DataTaggedTestCase::testAll() { Line 2253  void DataTaggedTestCase::testAll() {
2253      DataTagged::TagListType keys;      DataTagged::TagListType keys;
2254      keys.push_back(1);      keys.push_back(1);
2255    
2256      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2257    
2258      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2259      viewShape.push_back(3);      viewShape.push_back(3);
2260    
2261      // default value      // default value
2262      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*2);
2263      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
2264        viewData[i]=i;        viewData[i]=i;
2265      }      }
2266      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2267    
2268      // value for tag "1"      // value for tag "1"
2269      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
2270      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
2271        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
2272    //       eOneView(i)=i+1.0;
2273        viewData[viewShape[0]+i]=i+1.0;
2274      }      }
2275      values.push_back(eOne.getView());  //     values.push_back(eOneView);
2276        DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
     DataTagged myData(keys,values,myView,FunctionSpace());  
2277    
2278      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
2279    
# Line 2496  void DataTaggedTestCase::testAll() { Line 2297  void DataTaggedTestCase::testAll() {
2297    
2298      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
2299    
2300      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
2301      assert(myDataView==eOne.getView());      assert(myData.getNoValues()==3);
2302      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
2303      assert(myDataView.getOffset()==3);  
2304      assert(myDataView.getRank()==1);  
2305      assert(myDataView.noValues()==3);      int offset=myData.getPointOffset(0,0);
2306      assert(myDataView.getShape().size()==1);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
2307      assert(myDataView(0)==1);      assert(offset==3);
2308      assert(myDataView(1)==2);      assert(getRef(myData,offset,0)==1);
2309      assert(myDataView(2)==3);      assert(getRef(myData,offset,1)==2);
2310        assert(getRef(myData,offset,2)==3);
2311      myDataView = myData.getDataPointByTag(1);  
2312      assert(myDataView==eOne.getView());  //     myDataView = myData.getDataPointByTag(1);
2313      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(1);
2314      assert(myDataView.getOffset()==3);      assert(offset==3);
2315      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,0)==1);
2316      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,1)==2);
2317      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,2)==3);
     assert(myDataView(0)==1);  
     assert(myDataView(1)==2);  
     assert(myDataView(2)==3);  
2318    
2319      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2320      myDataView = myData.getDataPointByTag(9);  //     myDataView = myData.getDataPointByTag(9);
2321      assert(myDataView==myView);      offset=myData.getOffsetForTag(9);
2322      assert(!myDataView.isEmpty());      assert(offset==0);
2323      assert(myDataView.getOffset()==0);      assert(getRef(myData,offset,0)==0);
2324      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==1);
2325      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==2);
2326      assert(myDataView.getShape().size()==1);  
2327      assert(myDataView(0)==0);  //     myDataView = myData.getDefaultValue();
2328      assert(myDataView(1)==1);      offset=myData.getDefaultOffset();
2329      assert(myDataView(2)==2);      assert(offset==0);
2330        assert(getRef(myData,offset,0)==0);
2331      myDataView = myData.getDefaultValue();      assert(getRef(myData,offset,1)==1);
2332      assert(myDataView==myView);      assert(getRef(myData,offset,2)==2);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
2333    
2334      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2335      // the first element of the data array      // the first element of the data array
# Line 2552  void DataTaggedTestCase::testAll() { Line 2342  void DataTaggedTestCase::testAll() {
2342        }        }
2343      }      }
2344      sampleData=myData.getSampleData(0);      sampleData=myData.getSampleData(0);
2345      for (int i=0; i<myDataView.noValues(); i++) {      for (unsigned int i=0; i<myData.getNoValues(); i++) {
2346        assert(sampleData[i]==i+1);        assert(sampleData[i]==i+1);
2347      }      }
2348    
# Line 2569  void DataTaggedTestCase::testAll() { Line 2359  void DataTaggedTestCase::testAll() {
2359      keys.push_back(2);      keys.push_back(2);
2360      keys.push_back(3);      keys.push_back(3);
2361    
2362      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2363    
2364      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2365      viewShape.push_back(3);      viewShape.push_back(3);
2366    
2367      // default value      // default value
2368      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
2369      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
2370        viewData[i]=i;        viewData[i]=i;
2371      }      }
2372      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2373    
2374      // value for tag "1"      // value for tag "1"
2375      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
2376      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
2377        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
2378    /*      eOneView(i)=i+1.0;*/
2379          viewData[viewShape[0]+i]=i+1.0;
2380      }      }
2381      values.push_back(eOne.getView());  //     values.push_back(eOneView);
2382    
2383      // value for tag "2"      // value for tag "2"
2384      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
2385      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
2386        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
2387          viewData[2*viewShape[0]+i]=i+2.0;
2388      }      }
2389      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
2390    
2391      // value for tag "3"      // value for tag "3"
2392      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
2393      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
2394        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
2395    /*      eThreeView(i)=i+3.0;*/
2396          viewData[3*viewShape[0]+i]=i+3.0;
2397      }      }
2398      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
2399    
2400      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
2401    
2402      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
2403    
# Line 2628  void DataTaggedTestCase::testAll() { Line 2423  void DataTaggedTestCase::testAll() {
2423    
2424      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
2425    
2426      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==1);
2427      assert(myDataView==eOne.getView());      assert(myData.getNoValues()==3);
2428      assert(!myDataView.isEmpty());      assert(myData.getShape().size()==1);
2429      assert(myDataView.getOffset()==3);  
2430      assert(myDataView.getRank()==1);  
2431      assert(myDataView.noValues()==3);      int offset=myData.getPointOffset(0,0);
2432      assert(myDataView.getShape().size()==1);  //     DataArrayView myDataView = myData.getDataPoint(0,0);
2433      assert(myDataView(0)==1);      assert(offset==3);
2434      assert(myDataView(1)==2);      assert(getRef(myData,offset,0)==1);
2435      assert(myDataView(2)==3);      assert(getRef(myData,offset,1)==2);
2436        assert(getRef(myData,offset,2)==3);
2437      myDataView = myData.getDataPointByTag(1);  
2438      assert(myDataView==eOne.getView());  //     myDataView = myData.getDataPointByTag(1);
2439      assert(!myDataView.isEmpty());      offset=myData.getOffsetForTag(1);
2440      assert(myDataView.getOffset()==3);      assert(offset==3);
2441      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,0)==1);
2442      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,1)==2);
2443      assert(myDataView.getShape().size()==1);      assert(getRef(myData,offset,2)==3);
     assert(myDataView(0)==1);  
     assert(myDataView(1)==2);  
     assert(myDataView(2)==3);  
2444    
2445      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2446      myDataView = myData.getDataPointByTag(0);  //     myDataView = myData.getDataPointByTag(0);
2447      assert(myDataView==myView);      offset=myData.getOffsetForTag(0);
2448      assert(!myDataView.isEmpty());      assert(offset==0);
2449      assert(myDataView.getOffset()==0);      assert(getRef(myData,offset,0)==0);
2450      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==1);
2451      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==2);
2452      assert(myDataView.getShape().size()==1);  
2453      assert(myDataView(0)==0);  //     myDataView = myData.getDefaultValue();
2454      assert(myDataView(1)==1);      offset=myData.getDefaultOffset();
2455      assert(myDataView(2)==2);      assert(offset==0);
2456        assert(getRef(myData,offset,0)==0);
2457      myDataView = myData.getDefaultValue();      assert(getRef(myData,offset,1)==1);
2458      assert(myDataView==myView);      assert(getRef(myData,offset,2)==2);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
2459    
2460      // Test data-points held for remaining tags      // Test data-points held for remaining tags
2461      myDataView = myData.getDataPointByTag(2);  //     myDataView = myData.getDataPointByTag(2);
2462      assert(myDataView==eTwo.getView());      offset=myData.getOffsetForTag(2);
2463      assert(!myDataView.isEmpty());      assert(offset==6);
2464      assert(myDataView.getOffset()==6);      assert(getRef(myData,offset,0)==2);
2465      assert(myDataView.getRank()==1);      assert(getRef(myData,offset,1)==3);
2466      assert(myDataView.noValues()==3);      assert(getRef(myData,offset,2)==4);
2467      assert(myDataView.getShape().size()==1);  
2468      assert(myDataView(0)==2);  //     myDataView = myData.getDataPointByTag(3);
2469      assert(myDataView(1)==3);      offset=myData.getOffsetForTag(3);
2470      assert(myDataView(2)==4);      assert(offset==9);
2471        assert(getRef(myData,offset,0)==3);
2472      myDataView = myData.getDataPointByTag(3);      assert(getRef(myData,offset,1)==4);
2473      assert(myDataView==eThree.getView());      assert(getRef(myData,offset,2)==5);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==9);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==3);  
     assert(myDataView(1)==4);  
     assert(myDataView(2)==5);  
2474    
2475      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2476      // the first element of the data array      // the first element of the data array
# Line 2711  void DataTaggedTestCase::testAll() { Line 2487  void DataTaggedTestCase::testAll() {
2487        }        }
2488      }      }
2489      sampleData=myData.getSampleData(0);      sampleData=myData.getSampleData(0);
2490      for (int i=0; i<myDataView.noValues(); i++) {      for (unsigned int i=0; i<myData.getNoValues(); i++) {
2491        assert(sampleData[i]==i+1);        assert(sampleData[i]==i+1);
2492      }      }
2493    
# Line 2734  void DataTaggedTestCase::testCopyConstru Line 2510  void DataTaggedTestCase::testCopyConstru
2510      keys.push_back(2);      keys.push_back(2);
2511      keys.push_back(3);      keys.push_back(3);
2512    
2513      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2514    
2515      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2516      viewShape.push_back(3);      viewShape.push_back(3);
2517    
2518      // default value      // default value
2519      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
2520      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
2521        viewData[i]=i;        viewData[i]=i;
2522      }      }
2523      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2524    
2525      // value for tag "1"      // value for tag "1"
2526      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
2527      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
2528        eOne.getView()(i)=i+1.0;      for (int i=0;i<viewShape[0];i++) {
2529          viewData[viewShape[0]+i]=i+1.0;
2530      }      }
2531      values.push_back(eOne.getView());  //     values.push_back(eOneView);
2532    
2533      // value for tag "2"      // value for tag "2"
2534      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
2535      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
2536        eTwo.getView()(i)=i+2.0;      for (int i=0;i<viewShape[0];i++) {
2537    //       eTwoView(i)=i+2.0;
2538        viewData[2*viewShape[0]+i]=i+2.0;
2539      }      }
2540      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
2541    
2542      // value for tag "3"      // value for tag "3"
2543      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
2544      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
2545        eThree.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
2546    //       eThreeView(i)=i+3.0;
2547        viewData[3*viewShape[0]+i]=i+3.0;
2548      }      }
2549      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
2550    
2551      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
2552    
2553      DataTagged myDataCopy(myData);      DataTagged myDataCopy(myData);
2554    
# Line 2795  void DataTaggedTestCase::testCopyConstru Line 2576  void DataTaggedTestCase::testCopyConstru
2576    
2577      assert(myDataCopy.getPointOffset(0,0)==3);      assert(myDataCopy.getPointOffset(0,0)==3);
2578    
2579      DataArrayView myDataView = myDataCopy.getDataPoint(0,0);      assert(myDataCopy.getRank()==1);
2580      assert(myDataView==eOne.getView());      assert(myDataCopy.getNoValues()==3);
2581      assert(!myDataView.isEmpty());      assert(myDataCopy.getShape().size()==1);
2582      assert(myDataView.getOffset()==3);  
2583      assert(myDataView.getRank()==1);      int offset=myDataCopy.getPointOffset(0,0);
2584      assert(myDataView.noValues()==3);  //     DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
2585      assert(myDataView.getShape().size()==1);      assert(offset==3);
2586      assert(myDataView(0)==1);      assert(getRef(myDataCopy,offset,0)==1);
2587      assert(myDataView(1)==2);      assert(getRef(myDataCopy,offset,1)==2);
2588      assert(myDataView(2)==3);      assert(getRef(myDataCopy,offset,2)==3);
2589    
2590      myDataView = myDataCopy.getDataPointByTag(1);  //     myDataView = myDataCopy.getDataPointByTag(1);
2591      assert(myDataView==eOne.getView());      offset=myDataCopy.getOffsetForTag(1);
2592      assert(!myDataView.isEmpty());      assert(offset==3);
2593      assert(myDataView.getOffset()==3);      assert(getRef(myDataCopy,offset,0)==1);
2594      assert(myDataView.getRank()==1);      assert(getRef(myDataCopy,offset,1)==2);
2595      assert(myDataView.noValues()==3);      assert(getRef(myDataCopy,offset,2)==3);
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1);  
     assert(myDataView(1)==2);  
     assert(myDataView(2)==3);  
2596    
2597      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2598      myDataView = myDataCopy.getDataPointByTag(0);  //     myDataView = myDataCopy.getDataPointByTag(0);
2599      assert(myDataView==myView);      offset=myDataCopy.getOffsetForTag(0);
2600      assert(!myDataView.isEmpty());      assert(offset==0);
2601      assert(myDataView.getOffset()==0);      assert(getRef(myDataCopy,offset,0)==0);
2602      assert(myDataView.getRank()==1);      assert(getRef(myDataCopy,offset,1)==1);
2603      assert(myDataView.noValues()==3);      assert(getRef(myDataCopy,offset,2)==2);
2604      assert(myDataView.getShape().size()==1);  
2605      assert(myDataView(0)==0);      //myDataView = myDataCopy.getDefaultValue();
2606      assert(myDataView(1)==1);      offset=myDataCopy.getDefaultOffset();
2607      assert(myDataView(2)==2);      assert(offset==0);
2608        assert(getRef(myDataCopy,offset,0)==0);
2609      myDataView = myDataCopy.getDefaultValue();      assert(getRef(myDataCopy,offset,1)==1);
2610      assert(myDataView==myView);      assert(getRef(myDataCopy,offset,2)==2);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==0);  
     assert(myDataView(1)==1);  
     assert(myDataView(2)==2);  
2611    
2612      // Test data-points held for remaining tags      // Test data-points held for remaining tags
2613      myDataView = myDataCopy.getDataPointByTag(2);  //     myDataView = myDataCopy.getDataPointByTag(2);
2614      assert(myDataView==eTwo.getView());      offset=myDataCopy.getOffsetForTag(2);
2615      assert(!myDataView.isEmpty());      assert(offset==6);
2616      assert(myDataView.getOffset()==6);      assert(getRef(myDataCopy,offset,0)==2);
2617      assert(myDataView.getRank()==1);      assert(getRef(myDataCopy,offset,1)==3);
2618      assert(myDataView.noValues()==3);      assert(getRef(myDataCopy,offset,2)==4);
2619      assert(myDataView.getShape().size()==1);  
2620      assert(myDataView(0)==2);  //     myDataView = myDataCopy.getDataPointByTag(3);
2621      assert(myDataView(1)==3);      offset=myDataCopy.getOffsetForTag(3);
2622      assert(myDataView(2)==4);      assert(offset==9);
2623        assert(getRef(myDataCopy,offset,0)==3);
2624      myDataView = myDataCopy.getDataPointByTag(3);      assert(getRef(myDataCopy,offset,1)==4);
2625      assert(myDataView==eThree.getView());      assert(getRef(myDataCopy,offset,2)==5);
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==9);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==3);  
     assert(myDataView(1)==4);  
     assert(myDataView(2)==5);  
2626    
2627      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2628      // the first element of the data array      // the first element of the data array
# Line 2885  void DataTaggedTestCase::testCopyConstru Line 2646  void DataTaggedTestCase::testCopyConstru
2646      cout << "\tTest DataTagged copy constructor for DataConstant." << endl;      cout << "\tTest DataTagged copy constructor for DataConstant." << endl;
2647    
2648      // Create a DataConstant      // Create a DataConstant
2649      DataArrayView::ShapeType shape;      DataTypes::ShapeType shape;
2650      DataArrayView::ValueType data(DataArrayView::noValues(shape),0);      DataTypes::ValueType data(DataTypes::noValues(shape),0);
2651      DataArrayView pointData(data,shape);  //     DataArrayView pointData(data,shape);
2652      pointData()=1.0;      data[0]=1.0;
2653      DataConstant myConstantData(pointData, FunctionSpace());      DataConstant myConstantData(FunctionSpace(),shape,data);
2654    
2655      // use this DataConstant to initialise a DataTagged      // use this DataConstant to initialise a DataTagged
2656      DataTagged myData(myConstantData);      DataTagged myData(myConstantData);
# Line 2915  void DataTaggedTestCase::testCopyConstru Line 2676  void DataTaggedTestCase::testCopyConstru
2676    
2677      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
2678    
2679      DataArrayView myDataView = myData.getDataPoint(0,0);      assert(myData.getRank()==0);
2680      assert(!myDataView.isEmpty());      assert(myData.getNoValues()==1);
2681      assert(myDataView.getOffset()==0);      assert(myData.getShape().size()==0);
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1.0);  
2682    
     // Test non-existent tag returns the default value.  
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1.0);  
2683    
2684      myDataView = myData.getDefaultValue();  //     DataArrayView myDataView = myData.getDataPoint(0,0);
2685      assert(!myDataView.isEmpty());      int offset=myData.getPointOffset(0,0);
2686      assert(myDataView.getOffset()==0);      assert(offset==0);
2687      assert(myDataView.getRank()==0);      assert(myData.getDataAtOffset(offset)==1.0);
2688      assert(myDataView.noValues()==1);  
2689      assert(myDataView.getShape().size()==0);      // Test non-existent tag returns the default value.
2690      assert(myDataView()==1.0);  //     myDataView = myData.getDataPointByTag(1);
2691        offset=myData.getOffsetForTag(1);
2692        assert(offset==0);
2693        assert(myData.getDataAtOffset(offset)==1.0);
2694    
2695    //     myDataView = myData.getDefaultValue();
2696        offset=myData.getDefaultOffset();
2697        assert(offset==0);
2698        assert(myData.getDataAtOffset(offset)==1.0);
2699    
2700      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
2701      // the first element of the data array      // the first element of the data array
# Line 2961  void DataTaggedTestCase::testGetSlice() Line 2718  void DataTaggedTestCase::testGetSlice()
2718    
2719      DataTagged myData;      DataTagged myData;
2720    
2721      DataArrayView::RegionType region;      DataTypes::RegionType region;
2722    
2723      DataAbstract* slicedDefault = myData.getSlice(region);      DataAbstract* slicedDefault = myData.getSlice(region);
2724    
# Line 2973  void DataTaggedTestCase::testGetSlice() Line 2730  void DataTaggedTestCase::testGetSlice()
2730    
2731      assert(myDataSliced->getLength()==1);      assert(myDataSliced->getLength()==1);
2732    
2733      DataArrayView myDataView = myDataSliced->getDefaultValue();  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
2734      assert(!myDataView.isEmpty());      int offset=myDataSliced->getDefaultOffset();
2735      assert(myDataView.getOffset()==0);      assert(offset==0);
2736      assert(myDataView.getRank()==0);      assert(myDataSliced->getRank()==0);
2737      assert(myDataView.noValues()==1);      assert(myDataSliced->getNoValues()==1);
2738      assert(myDataView.getShape().size()==0);      assert(myDataSliced->getShape().size()==0);
2739      assert(myDataView()==0.0);      assert(myDataSliced->getVector()[0]==0.0);
2740    
2741        delete slicedDefault;
2742    }    }
2743    
2744    {    {
2745    
2746      cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;      cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
2747    
2748      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2749      viewShape.push_back(3);      viewShape.push_back(3);
2750    
2751      DataTagged::TagListType keys;      DataTagged::TagListType keys;
2752    
2753      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2754    
2755      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3);
2756      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
2757        viewData[i]=i;        viewData[i]=i;
2758      }      }
2759      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2760    
2761      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
2762    
2763      // full slice      // full slice
2764    
2765      std::pair<int, int> region_element;      std::pair<int, int> region_element;
2766      region_element.first=0;      region_element.first=0;
2767      region_element.second=3;      region_element.second=3;
2768      DataArrayView::RegionType region;      DataTypes::RegionType region;
2769      region.push_back(region_element);      region.push_back(region_element);
2770    
2771      DataAbstract* slicedDefault = myData.getSlice(region);      DataAbstract* slicedDefault = myData.getSlice(region);
# Line 3020  void DataTaggedTestCase::testGetSlice() Line 2778  void DataTaggedTestCase::testGetSlice()
2778    
2779      assert(myDataSliced->getLength()==3);      assert(myDataSliced->getLength()==3);
2780    
2781      DataArrayView myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==1);
2782      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==3);
2783      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==1);
2784      assert(myDataView.getRank()==1);  
2785      assert(myDataView.noValues()==3);  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
2786      assert(myDataView.getShape().size()==1);      int offset=myDataSliced->getDefaultOffset();
2787      assert(myDataView(0)==0.0);      assert(offset==0);
2788      assert(myDataView(1)==1.0);  
2789      assert(myDataView(2)==2.0);      assert(getRef(*myDataSliced,offset,0)==0.0);
2790        assert(getRef(*myDataSliced,offset,1)==1.0);
2791        assert(getRef(*myDataSliced,offset,2)==2.0);
2792    
2793      // scalar slice      // scalar slice
2794    
# Line 3037  void DataTaggedTestCase::testGetSlice() Line 2797  void DataTaggedTestCase::testGetSlice()
2797      region_element.second=0;      region_element.second=0;
2798      region.push_back(region_element);      region.push_back(region_element);
2799    
2800        delete slicedDefault;
2801    
2802      slicedDefault = myData.getSlice(region);      slicedDefault = myData.getSlice(region);
2803    
2804      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
# Line 3047  void DataTaggedTestCase::testGetSlice() Line 2809  void DataTaggedTestCase::testGetSlice()
2809    
2810      assert(myDataSliced->getLength()==1);      assert(myDataSliced->getLength()==1);
2811    
2812      myDataView = myDataSliced->getDefaultValue();  //     myDataView = myDataSliced->getDefaultValue();
2813      assert(!myDataView.isEmpty());      offset=myDataSliced->getDefaultOffset();
2814      assert(myDataView.getOffset()==0);      assert(offset==0);
2815      assert(myDataView.getRank()==0);      assert(myDataSliced->getRank()==0);
2816      assert(myDataView.noValues()==1);      assert(myDataSliced->getNoValues()==1);
2817      assert(myDataView.getShape().size()==0);      assert(myDataSliced->getShape().size()==0);
2818      assert(myDataView()==0.0);      assert(myDataSliced->getVector()[0]==0.0);
2819    
2820        delete slicedDefault;
2821    }    }
2822    
2823    {    {
2824    
2825      cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;      cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
2826    
2827      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2828      viewShape.push_back(3);      viewShape.push_back(3);
2829      viewShape.push_back(3);      viewShape.push_back(3);
2830      viewShape.push_back(3);      viewShape.push_back(3);
2831    
2832      DataTagged::TagListType keys;      DataTagged::TagListType keys;
2833    
2834      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2835    
2836      DataArrayView::ValueType viewData(27);      DataTypes::ValueType viewData(27);
2837      for (int i=0;i<viewData.size();i++) {      for (int i=0;i<viewData.size();i++) {
2838        viewData[i]=i;        viewData[i]=i;
2839      }      }
2840      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2841    
2842      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,viewData);
2843    
2844      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
2845    
# Line 3085  void DataTaggedTestCase::testGetSlice() Line 2848  void DataTaggedTestCase::testGetSlice()
2848      std::pair<int, int> region_element;      std::pair<int, int> region_element;
2849      region_element.first=0;      region_element.first=0;
2850      region_element.second=3;      region_element.second=3;
2851      DataArrayView::RegionType region;      DataTypes::RegionType region;
2852      region.push_back(region_element);      region.push_back(region_element);
2853      region.push_back(region_element);      region.push_back(region_element);
2854      region.push_back(region_element);      region.push_back(region_element);
# Line 3100  void DataTaggedTestCase::testGetSlice() Line 2863  void DataTaggedTestCase::testGetSlice()
2863    
2864      assert(myDataSliced->getLength()==27);      assert(myDataSliced->getLength()==27);
2865    
2866      DataArrayView myDataView = myDataSliced->getDefaultValue();  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
2867      assert(!myDataView.isEmpty());      int offset=myDataSliced->getDefaultOffset();
2868      assert(myDataView.getOffset()==0);      assert(offset==0);
2869      assert(myDataView.getRank()==3);      assert(myDataSliced->getRank()==3);
2870      assert(myDataView.noValues()==27);      assert(myDataSliced->getNoValues()==27);
2871      assert(myDataView.getShape().size()==3);      assert(myDataSliced->getShape().size()==3);
2872    
2873      // rank 1 slice      // rank 1 slice
2874    
# Line 3115  void DataTaggedTestCase::testGetSlice() Line 2878  void DataTaggedTestCase::testGetSlice()
2878      region.push_back(region_element);      region.push_back(region_element);
2879      region.push_back(region_element);      region.push_back(region_element);
2880    
2881        delete slicedDefault;
2882    
2883      slicedDefault = myData.getSlice(region);      slicedDefault = myData.getSlice(region);
2884    
2885      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
# Line 3125  void DataTaggedTestCase::testGetSlice() Line 2890  void DataTaggedTestCase::testGetSlice()
2890    
2891      assert(myDataSliced->getLength()==3);      assert(myDataSliced->getLength()==3);
2892    
2893      myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==1);
2894      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==3);
2895      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==1);
2896      assert(myDataView.getRank()==1);  
2897      assert(myDataView.noValues()==3);  //     myDataView = myDataSliced->getDefaultValue();
2898      assert(myDataView.getShape().size()==1);      offset=myDataSliced->getDefaultOffset();
2899      assert(myDataView(0)==0.0);      assert(offset==0);
2900      assert(myDataView(1)==1.0);      assert(getRef(*myDataSliced,offset,0)==0.0);
2901      assert(myDataView(2)==2.0);      assert(getRef(*myDataSliced,offset,1)==1.0);
2902        assert(getRef(*myDataSliced,offset,2)==2.0);
2903    
2904      // scalar slice      // scalar slice
2905    
# Line 3144  void DataTaggedTestCase::testGetSlice() Line 2910  void DataTaggedTestCase::testGetSlice()
2910      region.push_back(region_element);      region.push_back(region_element);
2911      region.push_back(region_element);      region.push_back(region_element);
2912    
2913        delete slicedDefault;
2914    
2915      slicedDefault = myData.getSlice(region);      slicedDefault = myData.getSlice(region);
2916    
2917      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
# Line 3154  void DataTaggedTestCase::testGetSlice() Line 2922  void DataTaggedTestCase::testGetSlice()
2922    
2923      assert(myDataSliced->getLength()==1);      assert(myDataSliced->getLength()==1);
2924    
2925      myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==0);
2926      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==1);
2927      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==0);
2928      assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==26);  
2929    
2930    //     myDataView = myDataSliced->getDefaultValue();
2931        offset=myDataSliced->getDefaultOffset();
2932        assert(offset==0);
2933        assert(myDataSliced->getVector()[0]==26);
2934        delete slicedDefault;
2935    }    }
2936    
2937    {    {
# Line 3171  void DataTaggedTestCase::testGetSlice() Line 2941  void DataTaggedTestCase::testGetSlice()
2941      DataTagged::TagListType keys;      DataTagged::TagListType keys;
2942      keys.push_back(1);      keys.push_back(1);
2943    
2944      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
2945    
2946      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2947    
2948      // default value      // default value
2949      DataArrayView::ValueType viewData(1);      DataTypes::ValueType viewData(1*2);
2950      viewData[0]=0.0;      viewData[0]=0.0;
2951      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
2952    
2953      // value for tag "1"      // value for tag "1"
2954      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
2955      eOne.getView()()=1.0;  //     DataArrayView eOneView(eOneData, viewShape);
2956      values.push_back(eOne.getView());      viewData[1]=1.0;
2957    //     values.push_back(eOneView);
2958    
2959      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys, viewData);
2960    
2961      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
2962    
2963      // full slice      // full slice
2964    
2965      DataArrayView::RegionType region;      DataTypes::RegionType region;
2966    
2967      DataAbstract* slicedDefault = myData.getSlice(region);      DataAbstract* slicedDefault = myData.getSlice(region);
2968    
# Line 3203  void DataTaggedTestCase::testGetSlice() Line 2974  void DataTaggedTestCase::testGetSlice()
2974    
2975      assert(myDataSliced->getLength()==2);      assert(myDataSliced->getLength()==2);
2976    
2977      DataArrayView myDataView = myDataSliced->getDefaultValue();  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
2978      assert(!myDataView.isEmpty());      int offset=myDataSliced->getDefaultOffset();
2979      assert(myDataView.getOffset()==0);      assert(offset==0);
2980      assert(myDataView.getRank()==0);      assert(myDataSliced->getRank()==0);
2981      assert(myDataView.noValues()==1);      assert(myDataSliced->getNoValues()==1);
2982      assert(myDataView.getShape().size()==0);      assert(myDataSliced->getShape().size()==0);
2983      assert(myDataView()==0);      assert(myDataSliced->getVector()[offset]==0);
2984    
2985    //     myDataView = myDataSliced->getDataPointByTag(1);
2986        offset=myDataSliced->getOffsetForTag(1);
2987        assert(offset==1);
2988        assert(myDataSliced->getVector()[offset]==1);
2989    
2990      myDataView = myDataSliced->getDataPointByTag(1);      delete slicedDefault;
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==1);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1);  
2991    
2992    }    }
2993    
# Line 3225  void DataTaggedTestCase::testGetSlice() Line 2995  void DataTaggedTestCase::testGetSlice()
2995    
2996      cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;      cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
2997    
2998      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
2999      viewShape.push_back(3);      viewShape.push_back(3);
3000    
3001      DataTagged::TagListType keys;      DataTagged::TagListType keys;
3002      keys.push_back(1);      keys.push_back(1);
3003    
3004      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
3005    
3006      // default value      // default value
3007      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*2);
3008      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
3009        viewData[i]=i;        viewData[i]=i;
3010      }      }
3011      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
3012    
3013      // value for tag "1"      // value for tag "1"
3014      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
3015      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
3016        eOne.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
3017    //       eOneView(i)=i+3.0;
3018           viewData[viewShape[0]+i]=i+3.0;
3019      }      }
3020      values.push_back(eOne.getView());  //     values.push_back(eOneView);
3021    
3022      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
3023    
3024      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
3025    
# Line 3256  void DataTaggedTestCase::testGetSlice() Line 3028  void DataTaggedTestCase::testGetSlice()
3028      std::pair<int, int> region_element;      std::pair<int, int> region_element;
3029      region_element.first=0;      region_element.first=0;
3030      region_element.second=3;      region_element.second=3;
3031      DataArrayView::RegionType region;      DataTypes::RegionType region;
3032      region.push_back(region_element);      region.push_back(region_element);
3033    
3034      DataAbstract* slicedDefault = myData.getSlice(region);      DataAbstract* slicedDefault = myData.getSlice(region);
# Line 3268  void DataTaggedTestCase::testGetSlice() Line 3040  void DataTaggedTestCase::testGetSlice()
3040      assert(myDataSliced->getTagLookup().size()==1);      assert(myDataSliced->getTagLookup().size()==1);
3041    
3042      assert(myDataSliced->getLength()==6);      assert(myDataSliced->getLength()==6);
3043        assert(myDataSliced->getRank()==1);
3044      DataArrayView myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getNoValues()==3);
3045      assert(!myDataView.isEmpty());      assert(myDataSliced->getShape().size()==1);
3046      assert(myDataView.getOffset()==0);  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
3047      assert(myDataView.getRank()==1);      int offset=myDataSliced->getDefaultOffset();
3048      assert(myDataView.noValues()==3);      assert(offset==0);
3049      assert(myDataView.getShape().size()==1);      assert(getRef(*myDataSliced,offset,0)==0);
3050      assert(myDataView(0)==0);      assert(getRef(*myDataSliced,offset,1)==1);
3051      assert(myDataView(1)==1);      assert(getRef(*myDataSliced,offset,2)==2);
3052      assert(myDataView(2)==2);  
3053    //     myDataView = myDataSliced->getDataPointByTag(1);
3054      myDataView = myDataSliced->getDataPointByTag(1);      offset=myDataSliced->getOffsetForTag(1);
3055      assert(!myDataView.isEmpty());      assert(offset==3);
3056      assert(myDataView.getOffset()==3);      assert(getRef(*myDataSliced,offset,0)==3);
3057      assert(myDataView.getRank()==1);      assert(getRef(*myDataSliced,offset,1)==4);
3058      assert(myDataView.noValues()==3);      assert(getRef(*myDataSliced,offset,2)==5);
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==3);  
     assert(myDataView(1)==4);  
     assert(myDataView(2)==5);  
3059    
3060      // scalar slice      // scalar slice
3061    
# Line 3296  void DataTaggedTestCase::testGetSlice() Line 3064  void DataTaggedTestCase::testGetSlice()
3064      region.clear();      region.clear();
3065      region.push_back(region_element);      region.push_back(region_element);
3066    
3067        delete slicedDefault;
3068    
3069      slicedDefault = myData.getSlice(region);      slicedDefault = myData.getSlice(region);
3070    
3071      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
# Line 3306  void DataTaggedTestCase::testGetSlice() Line 3076  void DataTaggedTestCase::testGetSlice()
3076    
3077      assert(myDataSliced->getLength()==2);      assert(myDataSliced->getLength()==2);
3078    
3079      myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==0);
3080      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==1);
3081      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==0);
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==1);  
3082    
3083      myDataView = myDataSliced->getDataPointByTag(1);  
3084      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDefaultValue();
3085      assert(myDataView.getOffset()==1);      offset=myDataSliced->getDefaultOffset();
3086      assert(myDataView.getRank()==0);      assert(offset==0);
3087      assert(myDataView.noValues()==1);      assert(myDataSliced->getVector()[offset]==1);
3088      assert(myDataView.getShape().size()==0);  
3089      assert(myDataView()==4);  //     myDataView = myDataSliced->getDataPointByTag(1);
3090        offset=myDataSliced->getOffsetForTag(1);
3091        assert(offset==1);
3092        assert(myDataSliced->getVector()[offset]==4);
3093        delete slicedDefault;
3094    
3095    }    }
3096    
3097    {    {
3098    
3099      cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;      cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
3100        DataTypes::ShapeType viewShape;
     DataArrayView::ShapeType viewShape;  
3101      viewShape.push_back(3);      viewShape.push_back(3);
3102      viewShape.push_back(3);      viewShape.push_back(3);
3103      viewShape.push_back(3);      viewShape.push_back(3);
# Line 3336  void DataTaggedTestCase::testGetSlice() Line 3105  void DataTaggedTestCase::testGetSlice()
3105      DataTagged::TagListType keys;      DataTagged::TagListType keys;
3106      keys.push_back(1);      keys.push_back(1);
3107    
3108      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
3109    
3110      // default value      // default value
3111      DataArrayView::ValueType viewData(27);      DataTypes::ValueType viewData(27*2);
3112      for (int i=0;i<viewData.size();i++) {      for (int i=0;i<noValues(viewShape);i++) {
3113        viewData[i]=i;        viewData[i]=i;
3114      }      }
3115      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
3116    
3117      // value for tag "1"      // value for tag "1"
3118      DataArrayView::ValueType viewData1(27);  //     DataTypes::ValueType viewData1(27);
3119      for (int i=0;i<viewData1.size();i++) {      for (int i=0;i<noValues(viewShape);i++) {
3120        viewData1[i]=i+27.0;        viewData[noValues(viewShape)+i]=i+27.0;
3121      }      }
3122      DataArrayView myView1(viewData1,viewShape);  //     DataArrayView myView1(viewData1,viewShape);
3123      values.push_back(myView1);  //     values.push_back(myView1);
3124    
3125      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
3126    
3127      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
3128    
# Line 3362  void DataTaggedTestCase::testGetSlice() Line 3131  void DataTaggedTestCase::testGetSlice()
3131      std::pair<int, int> region_element;      std::pair<int, int> region_element;
3132      region_element.first=0;      region_element.first=0;
3133      region_element.second=3;      region_element.second=3;
3134      DataArrayView::RegionType region;      DataTypes::RegionType region;
3135      region.push_back(region_element);      region.push_back(region_element);
3136      region.push_back(region_element);      region.push_back(region_element);
3137      region.push_back(region_element);      region.push_back(region_element);
# Line 3377  void DataTaggedTestCase::testGetSlice() Line 3146  void DataTaggedTestCase::testGetSlice()
3146    
3147      assert(myDataSliced->getLength()==54);      assert(myDataSliced->getLength()==54);
3148    
3149      DataArrayView myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==3);
3150      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==27);
3151      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==3);
3152      assert(myDataView.getRank()==3);  
3153      assert(myDataView.noValues()==27);  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
3154      assert(myDataView.getShape().size()==3);      int offset=myDataSliced->getDefaultOffset();
3155        assert(offset==0);
3156      myDataView = myDataSliced->getDataPointByTag(1);  
3157      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDataPointByTag(1);
3158      assert(myDataView.getOffset()==27);      offset=myDataSliced->getOffsetForTag(1);
3159      assert(myDataView.getRank()==3);      assert(offset==27);
     assert(myDataView.noValues()==27);  
     assert(myDataView.getShape().size()==3);  
3160    
3161      // rank 1 slice      // rank 1 slice
3162    
# Line 3399  void DataTaggedTestCase::testGetSlice() Line 3166  void DataTaggedTestCase::testGetSlice()
3166      region.push_back(region_element);      region.push_back(region_element);
3167      region.push_back(region_element);      region.push_back(region_element);
3168    
3169      slicedDefault = myData.getSlice(region);      delete slicedDefault;
3170    
3171        slicedDefault = myData.getSlice(region);
3172      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
3173    
3174      myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);      myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
# Line 3409  void DataTaggedTestCase::testGetSlice() Line 3177  void DataTaggedTestCase::testGetSlice()
3177    
3178      assert(myDataSliced->getLength()==6);      assert(myDataSliced->getLength()==6);
3179    
3180      myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==1);
3181      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==3);
3182      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==1);
3183      assert(myDataView.getRank()==1);  
3184      assert(myDataView.noValues()==3);  //     myDataView = myDataSliced->getDefaultValue();
3185      assert(myDataView.getShape().size()==1);      offset=myDataSliced->getDefaultOffset();
3186      assert(myDataView(0)==0);      assert(offset==0);
3187      assert(myDataView(1)==1);      assert(getRef(*myDataSliced,offset,0)==0);
3188      assert(myDataView(2)==2);      assert(getRef(*myDataSliced,offset,1)==1);
3189        assert(getRef(*myDataSliced,offset,2)==2);
3190      myDataView = myDataSliced->getDataPointByTag(1);  
3191      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDataPointByTag(1);
3192      assert(myDataView.getOffset()==3);      offset=myDataSliced->getOffsetForTag(1);
3193      assert(myDataView.getRank()==1);      assert(offset==3);
3194      assert(myDataView.noValues()==3);      assert(getRef(*myDataSliced,offset,0)==27);
3195      assert(myDataView.getShape().size()==1);      assert(getRef(*myDataSliced,offset,1)==28);
3196      assert(myDataView(0)==27);      assert(getRef(*myDataSliced,offset,2)==29);
     assert(myDataView(1)==28);  
     assert(myDataView(2)==29);  
   
3197      // scalar slice      // scalar slice
3198    
3199      region_element.first=1;      region_element.first=1;
# Line 3438  void DataTaggedTestCase::testGetSlice() Line 3203  void DataTaggedTestCase::testGetSlice()
3203      region.push_back(region_element);      region.push_back(region_element);
3204      region.push_back(region_element);      region.push_back(region_element);
3205    
3206        delete slicedDefault;
3207    
3208      slicedDefault = myData.getSlice(region);      slicedDefault = myData.getSlice(region);
3209    
3210      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
# Line 3448  void DataTaggedTestCase::testGetSlice() Line 3215  void DataTaggedTestCase::testGetSlice()
3215    
3216      assert(myDataSliced->getLength()==2);      assert(myDataSliced->getLength()==2);
3217    
3218      myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==0);
3219      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==1);
3220      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==0);
3221      assert(myDataView.getRank()==0);  
3222      assert(myDataView.noValues()==1);  //     myDataView = myDataSliced->getDefaultValue();
3223      assert(myDataView.getShape().size()==0);      offset=myDataSliced->getDefaultOffset();
3224      assert(myDataView()==13);      assert(offset==0);
3225        assert(myDataSliced->getVector()[offset]==13);
3226      myDataView = myDataSliced->getDataPointByTag(1);  
3227      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDataPointByTag(1);
3228      assert(myDataView.getOffset()==1);      offset=myDataSliced->getOffsetForTag(1);
3229      assert(myDataView.getRank()==0);      assert(offset==1);
3230      assert(myDataView.noValues()==1);      assert(myDataSliced->getVector()[offset]==40);
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==40);  
3231    
3232        delete slicedDefault;
3233    }    }
3234    
3235    {    {
# Line 3475  void DataTaggedTestCase::testGetSlice() Line 3241  void DataTaggedTestCase::testGetSlice()
3241      keys.push_back(2);      keys.push_back(2);
3242      keys.push_back(3);      keys.push_back(3);
3243    
3244      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
3245    
3246      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
3247    
3248      // default value      // default value
3249      DataArrayView::ValueType viewData(1);      DataTypes::ValueType viewData(1*4);
3250      viewData[0]=0.0;      viewData[0]=0.0;
3251      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
3252    
3253      // value for tag "1"      // value for tag "1"
3254      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
3255      eOne.getView()()=1.0;  //     DataArrayView eOneView(eOneData, viewShape);
3256      values.push_back(eOne.getView());  //     eOneView()=1.0;
3257        viewData[1]=1.0;
3258    //     values.push_back(eOneView);
3259    
3260      // value for tag "2"      // value for tag "2"
3261      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
3262      eTwo.getView()()=2.0;  //     DataArrayView eTwoView(eTwoData, viewShape);
3263      values.push_back(eTwo.getView());  //     eTwoView()=2.0;
3264        viewData[2]=2.0;
3265    //     values.push_back(eTwoView);
3266    
3267      // value for tag "3"      // value for tag "3"
3268      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
3269      eThree.getView()()=3.0;  //     DataArrayView eThreeView(eThreeData, viewShape);
3270      values.push_back(eThree.getView());  //     eThreeView()=3.0;
3271        viewData[3]=3.0;
3272    //     values.push_back(eThreeView);
3273    
3274      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
3275    
3276      // cout << myData.toString() << endl;      // cout << myData.toString() << endl;
3277    
3278      // full slice      // full slice
3279    
3280      DataArrayView::RegionType region;      DataTypes::RegionType region;
3281    
3282      DataAbstract* slicedDefault = myData.getSlice(region);      DataAbstract* slicedDefault = myData.getSlice(region);
3283    
# Line 3517  void DataTaggedTestCase::testGetSlice() Line 3289  void DataTaggedTestCase::testGetSlice()
3289    
3290      assert(myDataSliced->getLength()==4);      assert(myDataSliced->getLength()==4);
3291    
3292      DataArrayView myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==0);
3293      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==1);
3294      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==0);
3295      assert(myDataView.getRank()==0);  
3296      assert(myDataView.noValues()==1);  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
3297      assert(myDataView.getShape().size()==0);      int offset=myDataSliced->getDefaultOffset();
3298      assert(myDataView()==0);      assert(offset==0);
3299        assert(myDataSliced->getVector()[offset]==0);
3300      myDataView = myDataSliced->getDataPointByTag(1);  
3301      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDataPointByTag(1);
3302      assert(myDataView.getOffset()==1);      offset=myDataSliced->getOffsetForTag(1);
3303      assert(myDataView.getRank()==0);      assert(offset==1);
3304      assert(myDataView.noValues()==1);      assert(myDataSliced->getVector()[offset]==1);
3305      assert(myDataView.getShape().size()==0);  
3306      assert(myDataView()==1);  //     myDataView = myDataSliced->getDataPointByTag(2);
3307        offset=myDataSliced->getOffsetForTag(2);
3308      myDataView = myDataSliced->getDataPointByTag(2);      assert(offset==2);
3309      assert(!myDataView.isEmpty());      assert(myDataSliced->getVector()[offset]==2);
3310      assert(myDataView.getOffset()==2);  
3311      assert(myDataView.getRank()==0);  //     myDataView = myDataSliced->getDataPointByTag(3);
3312      assert(myDataView.noValues()==1);      offset=myDataSliced->getOffsetForTag(3);
3313      assert(myDataView.getShape().size()==0);      assert(offset==3);
3314      assert(myDataView()==2);      assert(myDataSliced->getVector()[offset]==3);
   
     myDataView = myDataSliced->getDataPointByTag(3);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==3);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==3);  
3315    
3316        delete slicedDefault;
3317    }    }
3318    
3319    {    {
3320    
3321      cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;      cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
3322    
3323      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
3324      viewShape.push_back(3);      viewShape.push_back(3);
3325    
3326      DataTagged::TagListType keys;      DataTagged::TagListType keys;
# Line 3563  void DataTaggedTestCase::testGetSlice() Line 3328  void DataTaggedTestCase::testGetSlice()
3328      keys.push_back(2);      keys.push_back(2);
3329      keys.push_back(3);      keys.push_back(3);
3330    
3331      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
3332    
3333      // default value      // default value
3334      DataArrayView::ValueType viewData(3);      DataTypes::ValueType viewData(3*4);
3335      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
3336        viewData[i]=i;        viewData[i]=i;
3337      }      }
3338      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
3339    
3340      // value for tag "1"      // value for tag "1"
3341      DataArray eOne(myView);  //     DataTypes::ValueType eOneData(viewData);
3342      for (int i=0;i<eOne.getView().getShape()[0];i++) {  //     DataArrayView eOneView(eOneData, viewShape);
3343        eOne.getView()(i)=i+3.0;      for (int i=0;i<viewShape[0];i++) {
3344    //       eOneView(i)=i+3.0;
3345        viewData[viewShape[0]+i]=i+3.0;
3346      }      }
3347      values.push_back(eOne.getView());  //     values.push_back(eOneView);
3348    
3349      // value for tag "2"      // value for tag "2"
3350      DataArray eTwo(myView);  //     DataTypes::ValueType eTwoData(viewData);
3351      for (int i=0;i<eTwo.getView().getShape()[0];i++) {  //     DataArrayView eTwoView(eTwoData, viewShape);
3352        eTwo.getView()(i)=i+6.0;      for (int i=0;i<viewShape[0];i++) {
3353    //       eTwoView(i)=i+6.0;
3354        viewData[2*viewShape[0]+i]=i+6.0;
3355      }      }
3356      values.push_back(eTwo.getView());  //     values.push_back(eTwoView);
3357    
3358      // value for tag "3"      // value for tag "3"
3359      DataArray eThree(myView);  //     DataTypes::ValueType eThreeData(viewData);
3360      for (int i=0;i<eThree.getView().getShape()[0];i++) {  //     DataArrayView eThreeView(eThreeData, viewShape);
3361        eThree.getView()(i)=i+9.0;      for (int i=0;i<viewShape[0];i++) {
3362    //       eThreeView(i)=i+9.0;
3363        viewData[3*viewShape[0]+i]=i+9.0;
3364      }      }
3365      values.push_back(eThree.getView());  //     values.push_back(eThreeView);
3366    
3367      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape, keys, viewData);
3368    
3369      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
3370    
# Line 3602  void DataTaggedTestCase::testGetSlice() Line 3373  void DataTaggedTestCase::testGetSlice()
3373      std::pair<int, int> region_element;      std::pair<int, int> region_element;
3374      region_element.first=0;      region_element.first=0;
3375      region_element.second=3;      region_element.second=3;
3376      DataArrayView::RegionType region;      DataTypes::RegionType region;
3377      region.push_back(region_element);      region.push_back(region_element);
3378    
3379      DataAbstract* slicedDefault = myData.getSlice(region);      DataAbstract* slicedDefault = myData.getSlice(region);
# Line 3615  void DataTaggedTestCase::testGetSlice() Line 3386  void DataTaggedTestCase::testGetSlice()
3386    
3387      assert(myDataSliced->getLength()==12);      assert(myDataSliced->getLength()==12);
3388    
3389      DataArrayView myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==1);
3390      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==3);
3391      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==1);
3392      assert(myDataView.getRank()==1);  
3393      assert(myDataView.noValues()==3);  
3394      assert(myDataView.getShape().size()==1);  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
3395      assert(myDataView(0)==0);      int offset=myDataSliced->getDefaultOffset();
3396      assert(myDataView(1)==1);      assert(offset==0);
3397      assert(myDataView(2)==2);      assert(getRef(*myDataSliced,offset,0)==0);
3398        assert(getRef(*myDataSliced,offset,1)==1);
3399      myDataView = myDataSliced->getDataPointByTag(1);      assert(getRef(*myDataSliced,offset,2)==2);
3400      assert(!myDataView.isEmpty());  
3401      assert(myDataView.getOffset()==3);  //     myDataView = myDataSliced->getDataPointByTag(1);
3402      assert(myDataView.getRank()==1);      offset=myDataSliced->getOffsetForTag(1);
3403      assert(myDataView.noValues()==3);      assert(offset==3);
3404      assert(myDataView.getShape().size()==1);      assert(getRef(*myDataSliced,offset,0)==3);
3405      assert(myDataView(0)==3);      assert(getRef(*myDataSliced,offset,1)==4);
3406      assert(myDataView(1)==4);      assert(getRef(*myDataSliced,offset,2)==5);
3407      assert(myDataView(2)==5);  
3408    //     myDataView = myDataSliced->getDataPointByTag(2);
3409      myDataView = myDataSliced->getDataPointByTag(2);      offset=myDataSliced->getOffsetForTag(2);
3410      assert(!myDataView.isEmpty());      assert(offset==6);
3411      assert(myDataView.getOffset()==6);      assert(getRef(*myDataSliced,offset,0)==6);
3412      assert(myDataView.getRank()==1);      assert(getRef(*myDataSliced,offset,1)==7);
3413      assert(myDataView.noValues()==3);      assert(getRef(*myDataSliced,offset,2)==8);
3414      assert(myDataView.getShape().size()==1);  
3415      assert(myDataView(0)==6);  //     myDataView = myDataSliced->getDataPointByTag(3);
3416      assert(myDataView(1)==7);      offset=myDataSliced->getOffsetForTag(3);
3417      assert(myDataView(2)==8);      assert(offset==9);
3418        assert(getRef(*myDataSliced,offset,0)==9);
3419      myDataView = myDataSliced->getDataPointByTag(3);      assert(getRef(*myDataSliced,offset,1)==10);
3420      assert(!myDataView.isEmpty());      assert(getRef(*myDataSliced,offset,2)==11);
     assert(myDataView.getOffset()==9);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==3);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==9);  
     assert(myDataView(1)==10);  
     assert(myDataView(2)==11);  
3421    
3422      // scalar slice      // scalar slice
3423    
# Line 3662  void DataTaggedTestCase::testGetSlice() Line 3426  void DataTaggedTestCase::testGetSlice()
3426      region_element.second=1;      region_element.second=1;
3427      region.push_back(region_element);      region.push_back(region_element);
3428    
3429        delete slicedDefault;
3430    
3431      slicedDefault = myData.getSlice(region);      slicedDefault = myData.getSlice(region);
3432    
3433      //cout << slicedDefault->toString() << endl;      //cout << slicedDefault->toString() << endl;
# Line 3672  void DataTaggedTestCase::testGetSlice() Line 3438  void DataTaggedTestCase::testGetSlice()
3438    
3439      assert(myDataSliced->getLength()==4);      assert(myDataSliced->getLength()==4);
3440    
3441      myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==0);
3442      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==1);
3443      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==0);
3444      assert(myDataView.getRank()==0);  
3445      assert(myDataView.noValues()==1);  //     myDataView = myDataSliced->getDefaultValue();
3446      assert(myDataView.getShape().size()==0);      offset=myDataSliced->getDefaultOffset();
3447      assert(myDataView()==1);      assert(offset==0);
3448        assert(myDataSliced->getVector()[offset]==1);
3449      myDataView = myDataSliced->getDataPointByTag(1);  
3450      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDataPointByTag(1);
3451      assert(myDataView.getOffset()==1);      offset=myDataSliced->getOffsetForTag(1);
3452      assert(myDataView.getRank()==0);      assert(offset==1);
3453      assert(myDataView.noValues()==1);      assert(myDataSliced->getVector()[offset]==4);
3454      assert(myDataView.getShape().size()==0);  
3455      assert(myDataView()==4);  //     myDataView = myDataSliced->getDataPointByTag(2);
3456        offset=myDataSliced->getOffsetForTag(2);
3457      myDataView = myDataSliced->getDataPointByTag(2);      assert(offset==2);
3458      assert(!myDataView.isEmpty());      assert(myDataSliced->getVector()[offset]==7);
3459      assert(myDataView.getOffset()==2);  
3460      assert(myDataView.getRank()==0);  //     myDataView = myDataSliced->getDataPointByTag(3);
3461      assert(myDataView.noValues()==1);      offset=myDataSliced->getOffsetForTag(3);
3462      assert(myDataView.getShape().size()==0);      assert(offset==3);
3463      assert(myDataView()==7);      assert(myDataSliced->getVector()[offset]==10);
3464        
3465      myDataView = myDataSliced->getDataPointByTag(3);      delete slicedDefault;
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==3);  
     assert(myDataView.getRank()==0);  
     assert(myDataView.noValues()==1);  
     assert(myDataView.getShape().size()==0);  
     assert(myDataView()==10);  
   
3466    }    }
3467    
3468    {    {
3469    
3470      cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;      cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
3471    
3472      DataArrayView::ShapeType viewShape;      DataTypes::ShapeType viewShape;
3473      viewShape.push_back(3);      viewShape.push_back(3);
3474      viewShape.push_back(3);      viewShape.push_back(3);
3475      viewShape.push_back(3);      viewShape.push_back(3);
# Line 3720  void DataTaggedTestCase::testGetSlice() Line 3479  void DataTaggedTestCase::testGetSlice()
3479      keys.push_back(2);      keys.push_back(2);
3480      keys.push_back(3);      keys.push_back(3);
3481    
3482      DataTagged::ValueListType values;      DataTagged::ValueBatchType values;
3483    
3484        int nvals=27;
3485      // default value      // default value
3486      DataArrayView::ValueType viewData(27);      DataTypes::ValueType viewData(27*4);
3487      for (int i=0;i<viewData.size();i++) {      for (int i=0;i<nvals;i++) {
3488        viewData[i]=i;        viewData[i]=i;
3489      }      }
3490      DataArrayView myView(viewData,viewShape);  //     DataArrayView myView(viewData,viewShape);
3491    
3492      // value for tag "1"      // value for tag "1"
3493      DataArrayView::ValueType viewData1(27);  //     DataTypes::ValueType viewData1(27);
3494      for (int i=0;i<viewData1.size();i++) {      for (int i=0;i<nvals;i++) {
3495        viewData1[i]=i+27.0;        viewData[nvals+i]=i+27.0;
3496      }      }
3497      DataArrayView myView1(viewData1,viewShape);  //     DataArrayView myView1(viewData1,viewShape);
3498      values.push_back(myView1);  //     values.push_back(myView1);
3499    
3500      // value for tag "2"      // value for tag "2"
3501      DataArrayView::ValueType viewData2(27);  //     DataTypes::ValueType viewData2(27);
3502      for (int i=0;i<viewData2.size();i++) {      for (int i=0;i<nvals;i++) {
3503        viewData2[i]=i+54.0;        viewData[2*nvals+i]=i+54.0;
3504      }      }
3505      DataArrayView myView2(viewData2,viewShape);  //     DataArrayView myView2(viewData2,viewShape);
3506      values.push_back(myView2);  //     values.push_back(myView2);
3507    
3508      // value for tag "3"      // value for tag "3"
3509      DataArrayView::ValueType viewData3(27);  //     DataTypes::ValueType viewData3(27);
3510      for (int i=0;i<viewData3.size();i++) {      for (int i=0;i<nvals;i++) {
3511        viewData3[i]=i+81.0;        viewData[3*nvals+i]=i+81.0;
3512      }      }
3513      DataArrayView myView3(viewData3,viewShape);  //     DataArrayView myView3(viewData3,viewShape);
3514      values.push_back(myView3);  //     values.push_back(myView3);
3515    
3516      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(FunctionSpace(),viewShape,keys,viewData);
3517    
3518      //cout << myData.toString() << endl;      //cout << myData.toString() << endl;
3519    
# Line 3762  void DataTaggedTestCase::testGetSlice() Line 3522  void DataTaggedTestCase::testGetSlice()
3522      std::pair<int, int> region_element;      std::pair<int, int> region_element;
3523      region_element.first=0;      region_element.first=0;
3524      region_element.second=3;      region_element.second=3;
3525      DataArrayView::RegionType region;      DataTypes::RegionType region;
3526      region.push_back(region_element);      region.push_back(region_element);
3527      region.push_back(region_element);      region.push_back(region_element);
3528      region.push_back(region_element);      region.push_back(region_element);
# Line 3777  void DataTaggedTestCase::testGetSlice() Line 3537  void DataTaggedTestCase::testGetSlice()
3537    
3538      assert(myDataSliced->getLength()==108);      assert(myDataSliced->getLength()==108);
3539    
3540      DataArrayView myDataView = myDataSliced->getDefaultValue();      assert(myDataSliced->getRank()==3);
3541      assert(!myDataView.isEmpty());      assert(myDataSliced->getNoValues()==27);
3542      assert(myDataView.getOffset()==0);      assert(myDataSliced->getShape().size()==3);
3543      assert(myDataView.getRank()==3);  
3544      assert(myDataView.noValues()==27);  //     DataArrayView myDataView = myDataSliced->getDefaultValue();
3545      assert(myDataView.getShape().size()==3);      int offset=myDataSliced->getDefaultOffset();
3546        assert(offset==0);
3547      myDataView = myDataSliced->getDataPointByTag(1);  
3548      assert(!myDataView.isEmpty());  //     myDataView = myDataSliced->getDataPointByTag(1);
3549      assert(myDataView.getOffset()==27);      offset=myDataSliced->getOffsetForTag(1);
3550      assert(myDataView.getRank()==3);      assert(offset==27);
3551      assert(myDataView.noValues()==27);  
3552      assert(myDataView.getShape().size()==3);  //     myDataView = myDataSliced->getDataPointByTag(2);