/[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

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