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

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

Parent Directory | Revision Log | View Patch Patch

-trunk/escript/test/DataTagged/DataTaggedTestCase.cpp
revision 504 by jgs,
Wed Feb  8 05:51:27 2006 UTC
+branches/ROBW_XPLATFORM/escript/test/DataTagged/DataTaggedTestCase.cpp
revision 622 by robwdcock,
Wed Mar 22 14:00:08 2006 UTC
 Line 1
  // $Id$
  /*
   *****************************************************************************
   *                                                                           *
-Line 51 
 void DataTaggedTestCase::testReshape() {
+Line 52 
 void DataTaggedTestCase::testReshape() {
    cout << endl;
    {
-     cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;
-     DataTagged value;
+     cout << "\tTest rank 1 reshape of default DataTagged." << endl;
-     value.getPointDataView()()=1.0;
+     DataTagged myData;
+     myData.getPointDataView()()=1.0;
      DataArrayView::ShapeType shape;
      shape.push_back(2);
-     value.reshapeDataPoint(shape);
-     for (int i=0;i<shape[0];++i) {
+     myData.reshapeDataPoint(shape);
-       assert(value.getDefaultValue()(i)==1);
+     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 reshape of default constructed DataTagged to rank 2." << endl;
-     DataTagged value;
+     cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;
-     value.getPointDataView()()=0.0;
-     DataArray vOne(1.0);
+     DataTagged::TagListType keys;
-     DataArray vTwo(2.0);
+     keys.push_back(1);
-     value.addTaggedValue(1,vOne.getView());
-     value.addTaggedValue(2,vTwo.getView());
+     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);
-     value.reshapeDataPoint(shape);
-     for (int j=0;j<shape[1];++j) {
+     myData.reshapeDataPoint(shape);
-       for (int i=0;i<shape[0];++i) {
-     assert(value.getDefaultValue()(i,j)==0.0);
+     //cout << myData.toString() << endl;
-     assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());
-     assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());
+     assert(myData.getNumSamples()==1);
+     assert(myData.getNumDPPSample()==1);
+     assert(myData.validSamplePointNo(0));
+     assert(myData.validSampleNo(0));
+     assert(!myData.validSamplePointNo(1));
+     assert(!myData.validSampleNo(1));
+     // data-point 0 has tag number 1 by default
+     assert(myData.getTagNumber(0)==1);
+     assert(myData.isCurrentTag(1));
+     assert(myData.getTagLookup().size()==1);
+     assert(myData.getLength()==20);
+     assert(myData.getPointOffset(0,0)==10);
+     DataArrayView myDataView = myData.getDataPoint(0,0);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==10);
+     assert(myDataView.getRank()==2);
+     assert(myDataView.noValues()==10);
+     assert(myDataView.getShape().size()==2);
+     for (int j=0;j<shape[1];j++) {
+       for (int i=0;i<shape[0];i++) {
+         assert(myDataView(i,j)==2.0);
+       }
+     }
+     myDataView = myData.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==10);
+     assert(myDataView.getRank()==2);
+     assert(myDataView.noValues()==10);
+     assert(myDataView.getShape().size()==2);
+     for (int j=0;j<shape[1];j++) {
+       for (int i=0;i<shape[0];i++) {
+         assert(myDataView(i,j)==2.0);
        }
      }
+     myDataView = myData.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==2);
+     assert(myDataView.noValues()==10);
+     assert(myDataView.getShape().size()==2);
+     for (int j=0;j<shape[1];j++) {
+       for (int i=0;i<shape[0];i++) {
+         assert(myDataView(i,j)==1.0);
+       }
+     }
+     // use a non-existent tag so we get a pointer to
+     // the first element of the data array
+     double* sampleData=myData.getSampleDataByTag(9);
+     for (int i=0; i<myData.getLength(); i++) {
+       if (i<10) {
+         assert(sampleData[i]==1.0);
+       } else {
+         assert(sampleData[i]==2.0);
+       }
+     }
    }
+   {
+     cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     keys.push_back(2);
+     keys.push_back(3);
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     // default value
+     DataArrayView::ValueType viewData(1);
+     viewData[0]=0.0;
+     DataArrayView myView(viewData,viewShape);
+     // value for tag "1"
+     DataArray eOne(myView);
+     eOne.getView()()=1.0;
+     values.push_back(eOne.getView());
+     // value for tag "2"
+     DataArray eTwo(myView);
+     eTwo.getView()()=2.0;
+     values.push_back(eTwo.getView());
+     // value for tag "3"
+     DataArray eThree(myView);
+     eThree.getView()()=3.0;
+     values.push_back(eThree.getView());
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     DataArrayView::ShapeType shape;
+     shape.push_back(2);
+     shape.push_back(2);
+     shape.push_back(2);
+     myData.reshapeDataPoint(shape);
+     //cout << myData.toString() << endl;
+     assert(myData.getNumSamples()==1);
+     assert(myData.getNumDPPSample()==1);
+     assert(myData.validSamplePointNo(0));
+     assert(myData.validSampleNo(0));
+     assert(!myData.validSamplePointNo(1));
+     assert(!myData.validSampleNo(1));
+     // data-point 0 has tag number 1 by default
+     assert(myData.getTagNumber(0)==1);
+     assert(myData.isCurrentTag(1));
+     assert(myData.isCurrentTag(2));
+     assert(myData.isCurrentTag(3));
+     assert(myData.getTagLookup().size()==3);
+     assert(myData.getLength()==32);
+     assert(myData.getPointOffset(0,0)==8);
+     DataArrayView myDataView = myData.getDataPoint(0,0);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==8);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==8);
+     assert(myDataView.getShape().size()==3);
+     for (int k=0;k<shape[2];k++) {
+       for (int j=0;j<shape[1];j++) {
+         for (int i=0;i<shape[0];i++) {
+           assert(myDataView(i,j,k)==1.0);
+         }
+       }
+     }
+     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);
+         }
+       }
+     }
+     myDataView = myData.getDataPointByTag(2);
+     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);
+         }
+       }
+     }
+     myDataView = myData.getDataPointByTag(3);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==24);
+     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)==3.0);
+         }
+       }
+     }
+     myDataView = myData.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     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)==0.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<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);
+       }
+     }
+   }
  }
  void DataTaggedTestCase::testOperations() {
-Line 88 
 void DataTaggedTestCase::testOperations(
+Line 383 
 void DataTaggedTestCase::testOperations(
    cout << endl;
    {
+     cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
      DataTagged myData;
      DataTagged right;
-     cout << "\tTest addition of two default DataTagged objects." << endl;
      binaryOp(myData,right,plus<double>());
      //cout << myData.toString() << endl;
-Line 140 
 void DataTaggedTestCase::testOperations(
+Line 435 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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]==i);
+     }
+   }
+   {
+     cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ValueType viewData(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     DataTagged right(keys,values,myView,FunctionSpace());
+     binaryOp(myData,right,plus<double>());
+     //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()==3);
+     assert(myData.getPointOffset(0,0)==0);
+     DataArrayView myDataView = myData.getDefaultValue();
+     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)==2);
+     assert(myDataView(2)==4);
+     // 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]==i*2);
+     }
    }
    {
+     cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
      DataTagged myData;
      DataTagged right;
-     cout << "\tTest addition of two DataTagged objects with one identical tag each." << endl;
      DataArray vOne(1.0);
      myData.addTaggedValue(1,vOne.getView());
      right.addTaggedValue(1,vOne.getView());
      binaryOp(myData,right,plus<double>());
+     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()==2);
+     assert(myData.getPointOffset(0,0)==1);
      // check result value for tag "1"
      DataArrayView myDataView = myData.getDataPointByTag(1);
      assert(!myDataView.isEmpty());
-Line 171 
 void DataTaggedTestCase::testOperations(
+Line 554 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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]==i*2);
+     }
    }
    {
+     cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
      DataTagged myData;
      DataTagged right;
-     cout << "\tTest addition of two DataTagged objects with one different tag each." << endl;
+     // it's important that default values are different, as we need to be able to
+     // verify that the tag values in each object are being added to the correct
+     // default values - since the tag lists don't match, the default values will
+     // be used for missing tags in each object
+     myData.getDefaultValue()()=1.0;
+     right.getDefaultValue()()=2.0;
-     DataArray vOne(1.0);
+     DataArray vOne(3.0);
+     DataArray vTwo(4.0);
      myData.addTaggedValue(1,vOne.getView());
-     right.addTaggedValue(2,vOne.getView());
+     right.addTaggedValue(2,vTwo.getView());
+     //cout << myData.toString() << endl;
+     //cout << right.toString() << endl;
      binaryOp(myData,right,plus<double>());
+     //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.getTagLookup().size()==2);
+     assert(myData.getLength()==3);
+     assert(myData.getPointOffset(0,0)==1);
      // check result value for tag "1"
      DataArrayView myDataView = myData.getDataPointByTag(1);
      assert(!myDataView.isEmpty());
-Line 192 
 void DataTaggedTestCase::testOperations(
+Line 616 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.getRank()==0);
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
-     assert(myDataView()==1.0);
+     assert(myDataView()==5.0);
      // check result value for tag "2"
      myDataView = myData.getDataPointByTag(2);
-Line 201 
 void DataTaggedTestCase::testOperations(
+Line 625 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.getRank()==0);
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
-     assert(myDataView()==1.0);
+     assert(myDataView()==5.0);
      // check result for default value
      myDataView = myData.getDefaultValue();
-Line 210 
 void DataTaggedTestCase::testOperations(
+Line 634 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.getRank()==0);
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
-     assert(myDataView()==0.0);
+     assert(myDataView()==3.0);
+     // use a non-existent tag so we get a pointer to
+     // the first element of the data array
+     double* sampleData=myData.getSampleDataByTag(9);
+     assert(sampleData[0]==3);
+     assert(sampleData[1]==5);
+     assert(sampleData[2]==5);
    }
    {
+     cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
      DataTagged myData;
      DataTagged right;
-     cout << "\tTest addition of two DataTagged objects with overlapping tag sets." << endl;
+     // it's important that default values are different, as we need to be able to
+     // verify that the tag values in each object are being added to the correct
+     // default values - since the tag lists don't match, the default values will
+     // be used for missing tags in each object
+     myData.getDefaultValue()()=2.0;
+     right.getDefaultValue()()=3.0;
      DataArray vOne(1.0);
      myData.addTaggedValue(1,vOne.getView());
-Line 225 
 void DataTaggedTestCase::testOperations(
+Line 664 
 void DataTaggedTestCase::testOperations(
      right.addTaggedValue(2,vOne.getView());
      right.addTaggedValue(3,vOne.getView());
+     //cout << myData.toString() << endl;
+     //cout << right.toString() << endl;
      binaryOp(myData,right,plus<double>());
+     //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()==4);
+     assert(myData.getPointOffset(0,0)==1);
      // check result value for tag "1"
      DataArrayView myDataView = myData.getDataPointByTag(1);
      assert(!myDataView.isEmpty());
-Line 234 
 void DataTaggedTestCase::testOperations(
+Line 699 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.getRank()==0);
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
-     assert(myDataView()==1.0);
+     assert(myDataView()==4.0);
      // check result value for tag "2"
      myDataView = myData.getDataPointByTag(2);
-Line 252 
 void DataTaggedTestCase::testOperations(
+Line 717 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.getRank()==0);
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
-     assert(myDataView()==1.0);
+     assert(myDataView()==3.0);
+     // check result for default value
+     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()==5.0);
+     // use a non-existent tag so we get a pointer to
+     // the first element of the data array
+     double* sampleData=myData.getSampleDataByTag(9);
+     assert(sampleData[0]==5);
+     assert(sampleData[1]==4);
+     assert(sampleData[2]==2);
+     assert(sampleData[3]==3);
+   }
+   {
+     cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ValueType viewData(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     DataTagged right(keys,values,myView,FunctionSpace());
+     binaryOp(myData,right,multiplies<double>());
+     //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()==3);
+     assert(myData.getPointOffset(0,0)==0);
+     DataArrayView myDataView = myData.getDefaultValue();
+     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)==4);
+     // 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]==i*i);
+     }
+   }
+   {
+     cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
+     DataTagged myData;
+     DataArray vOne(1.0);
+     DataArray vTwo(2.0);
+     myData.addTaggedValue(1,vOne.getView());
+     myData.addTaggedValue(2,vTwo.getView());
+     DataArray vThree(3.0);
+     DataArrayView right=vThree.getView();
+     //cout << myData.toString() << endl;
+     //cout << right.toString() << endl;
+     binaryOp(myData,right,multiplies<double>());
+     //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.getTagLookup().size()==2);
+     assert(myData.getLength()==3);
+     assert(myData.getPointOffset(0,0)==1);
+     // check result value for tag "1"
+     DataArrayView myDataView = myData.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==3.0);
+     // check result value for tag "2"
+     myDataView = myData.getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==2);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==6.0);
      // check result for default value
      myDataView = myData.getDefaultValue();
-Line 262 
 void DataTaggedTestCase::testOperations(
+Line 866 
 void DataTaggedTestCase::testOperations(
      assert(myDataView.noValues()==1);
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.0);
+     // use a non-existent tag so we get a pointer to
+     // the first element of the data array
+     double* sampleData=myData.getSampleDataByTag(9);
+     assert(sampleData[0]==0);
+     assert(sampleData[1]==3);
+     assert(sampleData[2]==6);
    }
    {
-     //cout << "\tTest binaryOp(multiplies)." << endl;
+     cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
-     //DataArray vZero(0.0);
-     //right.setTaggedValue(1,vZero.getView());
+     DataTagged myData;
-     //right.setTaggedValue(2,vZero.getView());
+     DataTagged right;
-     //binaryOp(left,right,multiplies<double>());
+     // it's important that default values are different, as we need to be able to
-     //assert(left.getPointDataView()()==0);
+     // verify that the tag values in each object are being added to the correct
-     //assert(left.getDataPointByTag(1)==vZero.getView());
+     // default values - since the tag lists don't match, the default values will
-     //assert(left.getDataPointByTag(2)==vZero.getView());
+     // be used for missing tags in each object
-   }
+     myData.getDefaultValue()()=2.0;
+     right.getDefaultValue()()=3.0;
-   {
-     //DataArrayView::ShapeType viewShape;
+     DataArray vOne(1.0);
-     //viewShape.push_back(3);
+     DataArray vTwo(2.0);
-     //DataArrayView::ValueType viewData(3);
+     myData.addTaggedValue(1,vOne.getView());
-     //DataTagged::TagListType keys;
+     myData.addTaggedValue(2,vOne.getView());
-     //DataTagged::ValueListType values;
+     right.addTaggedValue(2,vTwo.getView());
-     //for (int i=0;i<viewShape[0];++i) {
+     right.addTaggedValue(3,vTwo.getView());
-     //  viewData[i]=i;
-     //}
+     //cout << myData.toString() << endl;
-     //DataArrayView myView(viewData,viewShape);
+     //cout << right.toString() << endl;
-     //cout << "\tCreate tagged data with no tag values just a default." << endl;
-     //DataTagged left(keys,values,myView,FunctionSpace());
+     binaryOp(myData,right,multiplies<double>());
-     //DataTagged right(keys,values,myView,FunctionSpace());
-     //binaryOp(left,right,minus<double>());
+     //cout << myData.toString() << endl;
-     //for (int i=0;i<viewShape[0];++i) {
-     //  assert(left.getDefaultValue()(i)==0);
+     assert(myData.getNumSamples()==1);
-     //}
+     assert(myData.getNumDPPSample()==1);
-     //double mVal=10.0;
-     //for (int i=0;i<viewShape[0];++i) {
+     assert(myData.validSamplePointNo(0));
-     //  viewData[i]=i*mVal;
+     assert(myData.validSampleNo(0));
-     //}
+     assert(!myData.validSamplePointNo(1));
-     //cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;
+     assert(!myData.validSampleNo(1));
-     //binaryOp(left,myView,minus<double>());
-     //for (int i=0;i<viewShape[0];++i) {
+     // data-point 0 has tag number 1 by default
-     //  assert(left.getDefaultValue()(i)==-(i*mVal));
+     assert(myData.getTagNumber(0)==1);
-     //}
-   }
+     assert(myData.isCurrentTag(1));
+     assert(myData.isCurrentTag(2));
-   {
+     assert(myData.isCurrentTag(3));
-     //cout << "\tTest unaryOp(negate) on default DataTagged." << endl;
-     //DataTagged data;
+     assert(myData.getTagLookup().size()==3);
-     //unaryOp(data,negate<double>());
-     //assert(data.getDefaultValue()()==0);
+     assert(myData.getLength()==4);
-     //DataArray vOne(1);
-     //binaryOp(data,vOne.getView(),plus<double>());
+     assert(myData.getPointOffset(0,0)==1);
-     //assert(data.getDefaultValue()()==1);
-     //unaryOp(data,negate<double>());
+     // check result value for tag "1"
-     //assert(data.getDefaultValue()()==-1);
+     DataArrayView myDataView = myData.getDataPointByTag(1);
-   }
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
-   {
+     assert(myDataView.getRank()==0);
-     //cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;
+     assert(myDataView.noValues()==1);
-     //DataArrayView::ShapeType vShape;
+     assert(myDataView.getShape().size()==0);
-     //vShape.push_back(3);
+     assert(myDataView()==3.0);
-     //vShape.push_back(2);
-     //vShape.push_back(1);
+     // check result value for tag "2"
-     //DataArray defData(vShape,0.0);
+     myDataView = myData.getDataPointByTag(2);
-     //DataArrayView& defView=defData.getView();
+     assert(!myDataView.isEmpty());
-     //DataArray tOneData(vShape,1.0);
+     assert(myDataView.getOffset()==2);
-     //DataArrayView& tOneView=tOneData.getView();
+     assert(myDataView.getRank()==0);
-     //DataArray tTwoData(vShape,2.0);
+     assert(myDataView.noValues()==1);
-     //DataArrayView& tTwoView=tTwoData.getView();
+     assert(myDataView.getShape().size()==0);
-     //DataArray tThreeData(vShape,3.0);
+     assert(myDataView()==2.0);
-     //DataArrayView& tThreeView=tThreeData.getView();
-     //DataTagged::TagListType keys;
+     // check result value for tag "3"
-     //DataTagged::ValueListType values;
+     myDataView = myData.getDataPointByTag(3);
-     //keys.push_back(1);
+     assert(!myDataView.isEmpty());
-     //keys.push_back(2);
+     assert(myDataView.getOffset()==3);
-     //keys.push_back(3);
+     assert(myDataView.getRank()==0);
-     //values.push_back(tOneView);
+     assert(myDataView.noValues()==1);
-     //values.push_back(tTwoView);
+     assert(myDataView.getShape().size()==0);
-     //values.push_back(tThreeView);
+     assert(myDataView()==4.0);
-     //DataTagged tData(keys,values,defView,FunctionSpace());
-     //unaryOp(tData,negate<double>());
+     // check result for default value
-     //unaryOp(tData,negate<double>());
+     myDataView = myData.getDefaultValue();
-     //assert(tData.getDataPointByTag(1)==tOneView);
+     assert(!myDataView.isEmpty());
-     //assert(tData.getDataPointByTag(2)==tTwoView);
+     assert(myDataView.getOffset()==0);
-     //assert(tData.getDataPointByTag(3)==tThreeView);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==6.0);
+     // use a non-existent tag so we get a pointer to
+     // the first element of the data array
+     double* sampleData=myData.getSampleDataByTag(9);
+     assert(sampleData[0]==6);
+     assert(sampleData[1]==3);
+     assert(sampleData[2]==2);
+     assert(sampleData[3]==4);
+   }
+   {
+     cout << "\tTest unaryOp negate on default DataTagged object." << endl;
+     DataTagged myData;
+     unaryOp(myData,negate<double>());
+     //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()==1);
+     assert(myData.getPointOffset(0,0)==0);
+     DataArrayView myDataView = myData.getDataPoint(0,0);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==0.0);
+     // 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);
+     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);
+     // 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]==i);
+     }
+   }
+   {
+     cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ValueType viewData(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     unaryOp(myData,negate<double>());
+     //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()==3);
+     assert(myData.getPointOffset(0,0)==0);
+     DataArrayView myDataView = myData.getDefaultValue();
+     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);
+     // 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]==0-i);
+     }
+   }
+   {
+     cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;
+     DataTagged myData;
+     DataArray vOne(1.0);
+     DataArray vTwo(2.0);
+     myData.addTaggedValue(1,vOne.getView());
+     myData.addTaggedValue(2,vTwo.getView());
+     unaryOp(myData,negate<double>());
+     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.getTagLookup().size()==2);
+     assert(myData.getLength()==3);
+     assert(myData.getPointOffset(0,0)==1);
+     // check result value for tag "1"
+     DataArrayView myDataView = myData.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==-1.0);
+     // check result value for tag "2"
+     myDataView = myData.getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==2);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==-2.0);
+     // check result for default value
+     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);
+     // 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]==0-i);
+     }
    }
  }
-Line 399 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1213 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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]==0);
+     }
    }
    {
-Line 454 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1275 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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]==i);
+     }
    }
    {
-Line 529 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1357 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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==0) {
+         assert(sampleData[i]==0);
+       } else {
+         assert(sampleData[i]==1);
+       }
+     }
    }
    {
-Line 612 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1451 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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]==i);
+     }
    }
    {
-Line 682 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1528 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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]==i%3);
+     }
    }
    {
-Line 707 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1560 
 void DataTaggedTestCase::testAddTaggedVa
      DataArrayView::ValueType viewData1(3);
      for (int i=0;i<viewShape[0];i++) {
-       viewData1[i]=i+1;
+       viewData1[i]=i+3;
      }
      DataArrayView myView1(viewData1,viewShape);
      values.push_back(myView1);
-Line 732 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1585 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getRank()==1);
      assert(myDataView.noValues()==3);
      assert(myDataView.getShape().size()==1);
-     assert(myDataView(0)==1);
+     assert(myDataView(0)==3);
-     assert(myDataView(1)==2);
+     assert(myDataView(1)==4);
-     assert(myDataView(2)==3);
+     assert(myDataView(2)==5);
      myDataView = myData.getDataPointByTag(1);
      assert(myDataView==myView1);
-Line 743 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1596 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getRank()==1);
      assert(myDataView.noValues()==3);
      assert(myDataView.getShape().size()==1);
-     assert(myDataView(0)==1);
+     assert(myDataView(0)==3);
-     assert(myDataView(1)==2);
+     assert(myDataView(1)==4);
-     assert(myDataView(2)==3);
+     assert(myDataView(2)==5);
      myDataView = myData.getDefaultValue();
      assert(myDataView==myView);
-Line 758 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1611 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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]==i);
+     }
    }
    {
-Line 785 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1645 
 void DataTaggedTestCase::testAddTaggedVa
      DataArrayView::ValueType viewData1(3);
      for (int i=0;i<viewShape[0];i++) {
-       viewData1[i]=i+1;
+       viewData1[i]=3;
      }
      DataArrayView myView1(viewData1,viewShape);
      values.push_back(myView1);
-Line 812 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1672 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getRank()==1);
      assert(myDataView.noValues()==3);
      assert(myDataView.getShape().size()==1);
-     assert(myDataView(0)==1);
+     assert(myDataView(0)==3);
-     assert(myDataView(1)==2);
+     assert(myDataView(1)==3);
      assert(myDataView(2)==3);
      myDataView = myData.getDataPointByTag(1);
-Line 823 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1683 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getRank()==1);
      assert(myDataView.noValues()==3);
      assert(myDataView.getShape().size()==1);
-     assert(myDataView(0)==1);
+     assert(myDataView(0)==3);
-     assert(myDataView(1)==2);
+     assert(myDataView(1)==3);
      assert(myDataView(2)==3);
      myDataView = myData.getDataPointByTag(2);
-Line 834 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1694 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getRank()==1);
      assert(myDataView.noValues()==3);
      assert(myDataView.getShape().size()==1);
-     assert(myDataView(0)==1);
+     assert(myDataView(0)==3);
-     assert(myDataView(1)==2);
+     assert(myDataView(1)==3);
      assert(myDataView(2)==3);
      myDataView = myData.getDataPointByTag(3);
-Line 845 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1705 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView.getRank()==1);
      assert(myDataView.noValues()==3);
      assert(myDataView.getShape().size()==1);
-     assert(myDataView(0)==1);
+     assert(myDataView(0)==3);
-     assert(myDataView(1)==2);
+     assert(myDataView(1)==3);
      assert(myDataView(2)==3);
      myDataView = myData.getDefaultValue();
-Line 860 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1720 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else {
+         assert(sampleData[i]==3);
+       }
+     }
    }
    {
-Line 976 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1847 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else  {
+         assert(sampleData[i]==i-6);
+       }
+     }
    }
    {
-Line 1045 
 void DataTaggedTestCase::testAddTaggedVa
+Line 1931 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else if ((i>=9) && (i<12)) {
+         assert(sampleData[i]==i-6);
+       } else {
+         assert(sampleData[i]==i-12);
+       }
+     }
    }
    {
-Line 1121 
 void DataTaggedTestCase::testAddTaggedVa
+Line 2024 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==5);
      assert(myDataView(2)==6);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else if ((i>=9) && (i<12)) {
+         assert(sampleData[i]==i-6);
+       } else {
+         assert(sampleData[i]==i-8);
+       }
+     }
    }
    {
-Line 1223 
 void DataTaggedTestCase::testAddTaggedVa
+Line 2143 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==5);
      assert(myDataView(2)==6);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else if ((i>=9) && (i<12)) {
+         assert(sampleData[i]==i-6);
+       } else if ((i>=12) && (i<15)) {
+         assert(sampleData[i]==i-8);
+       } else if ((i>=15) && (i<18)) {
+         assert(sampleData[i]==i-11);
+       } else {
+         assert(sampleData[i]==i-14);
+       }
+     }
    }
    {
-Line 1340 
 void DataTaggedTestCase::testAddTaggedVa
+Line 2281 
 void DataTaggedTestCase::testAddTaggedVa
      assert(myDataView(1)==7);
      assert(myDataView(2)==8);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else if ((i>=9) && (i<12)) {
+         assert(sampleData[i]==i-6);
+       } else if ((i>=12) && (i<15)) {
+         assert(sampleData[i]==i-8);
+       } else if ((i>=15) && (i<18)) {
+         assert(sampleData[i]==i-10);
+       } else {
+         assert(sampleData[i]==i-12);
+       }
+     }
    }
  }
-Line 1416 
 void DataTaggedTestCase::testSetTaggedVa
+Line 2378 
 void DataTaggedTestCase::testSetTaggedVa
      assert(myDataView(1)==6);
      assert(myDataView(2)==7);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-1);
+       } else {
+         assert(sampleData[i]==i-6);
+       }
+     }
    }
  }
-Line 1475 
 void DataTaggedTestCase::testAll() {
+Line 2452 
 void DataTaggedTestCase::testAll() {
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==0.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]==i);
+     }
+     sampleData=myData.getSampleData(0);
+     for (int i=0; i<myDataView.noValues(); i++) {
+       assert(sampleData[i]==i);
+     }
    }
    {
-Line 1551 
 void DataTaggedTestCase::testAll() {
+Line 2539 
 void DataTaggedTestCase::testAll() {
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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]==i);
+     }
+     sampleData=myData.getSampleDataByTag(0);
+     for (int i=0; i<myDataView.noValues(); i++) {
+       assert(sampleData[i]==i);
+     }
    }
    {
-Line 1628 
 void DataTaggedTestCase::testAll() {
+Line 2627 
 void DataTaggedTestCase::testAll() {
      assert(myDataView(2)==3);
      // Test non-existent tag returns the default value.
-     myDataView = myData.getDataPointByTag(0);
+     myDataView = myData.getDataPointByTag(9);
      assert(myDataView==myView);
      assert(!myDataView.isEmpty());
      assert(myDataView.getOffset()==0);
-Line 1650 
 void DataTaggedTestCase::testAll() {
+Line 2649 
 void DataTaggedTestCase::testAll() {
      assert(myDataView(1)==1);
      assert(myDataView(2)==2);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else {
+         assert(sampleData[i]==i-2);
+       }
+     }
+     sampleData=myData.getSampleData(0);
+     for (int i=0; i<myDataView.noValues(); i++) {
+       assert(sampleData[i]==i+1);
+     }
    }
    {
-Line 1790 
 void DataTaggedTestCase::testAll() {
+Line 2804 
 void DataTaggedTestCase::testAll() {
      assert(myDataView(1)==4);
      assert(myDataView(2)==5);
+     // 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<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else {
+         assert(sampleData[i]==i-6);
+       }
+     }
+     sampleData=myData.getSampleData(0);
+     for (int i=0; i<myDataView.noValues(); i++) {
+       assert(sampleData[i]==i+1);
+     }
    }
  }
-Line 1938 
 void DataTaggedTestCase::testCopyConstru
+Line 2971 
 void DataTaggedTestCase::testCopyConstru
      assert(myDataView(1)==4);
      assert(myDataView(2)==5);
+     // use a non-existent tag so we get a pointer to
+     // the first element of the data array
+     double* sampleData=myDataCopy.getSampleDataByTag(9);
+     for (int i=0; i<myData.getLength(); i++) {
+       if (i<3) {
+         assert(sampleData[i]==i);
+       } else if ((i>=3) && (i<6)) {
+         assert(sampleData[i]==i-2);
+       } else if ((i>=6) && (i<9)) {
+         assert(sampleData[i]==i-4);
+       } else {
+         assert(sampleData[i]==i-6);
+       }
+     }
    }
    {
-Line 2000 
 void DataTaggedTestCase::testCopyConstru
+Line 3048 
 void DataTaggedTestCase::testCopyConstru
      assert(myDataView.getShape().size()==0);
      assert(myDataView()==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]==i+1);
+     }
+   }
+ }
+ void DataTaggedTestCase::testGetSlice() {
+   cout << endl;
+   {
+     cout << "\tTest slicing default DataTagged." << endl;
+     DataTagged myData;
+     DataArrayView::RegionType region;
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     // cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==0);
+     assert(myDataSliced->getLength()==1);
+     DataArrayView myDataView = myDataSliced->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);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ValueType viewData(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==0);
+     assert(myDataSliced->getLength()==3);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==0.0);
+     assert(myDataView(1)==1.0);
+     assert(myDataView(2)==2.0);
+     // scalar slice
+     region.clear();
+     region_element.first=0;
+     region_element.second=0;
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==0);
+     assert(myDataSliced->getLength()==1);
+     myDataView = myDataSliced->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);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ValueType viewData(27);
+     for (int i=0;i<viewData.size();i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     //cout << myData.toString() << endl;
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==0);
+     assert(myDataSliced->getLength()==27);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     // rank 1 slice
+     region.clear();
+     region.push_back(region_element);
+     region_element.second=0;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==0);
+     assert(myDataSliced->getLength()==3);
+     myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==0.0);
+     assert(myDataView(1)==1.0);
+     assert(myDataView(2)==2.0);
+     // scalar slice
+     region.clear();
+     region_element.first=2;
+     region_element.second=2;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==0);
+     assert(myDataSliced->getLength()==1);
+     myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==26);
+   }
+   {
+     cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     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());
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     //cout << myData.toString() << endl;
+     // full slice
+     DataArrayView::RegionType region;
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==1);
+     assert(myDataSliced->getLength()==2);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==0);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==1);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     DataTagged::ValueListType values;
+     // default value
+     DataArrayView::ValueType viewData(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     // value for tag "1"
+     DataArray eOne(myView);
+     for (int i=0;i<eOne.getView().getShape()[0];i++) {
+       eOne.getView()(i)=i+3.0;
+     }
+     values.push_back(eOne.getView());
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     //cout << myData.toString() << endl;
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==1);
+     assert(myDataSliced->getLength()==6);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     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);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     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);
+     // scalar slice
+     region_element.first=1;
+     region_element.second=1;
+     region.clear();
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==1);
+     assert(myDataSliced->getLength()==2);
+     myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==1);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==4);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     DataTagged::ValueListType values;
+     // default value
+     DataArrayView::ValueType viewData(27);
+     for (int i=0;i<viewData.size();i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     // value for tag "1"
+     DataArrayView::ValueType viewData1(27);
+     for (int i=0;i<viewData1.size();i++) {
+       viewData1[i]=i+27.0;
+     }
+     DataArrayView myView1(viewData1,viewShape);
+     values.push_back(myView1);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     //cout << myData.toString() << endl;
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==1);
+     assert(myDataSliced->getLength()==54);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==27);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     // rank 1 slice
+     region.clear();
+     region.push_back(region_element);
+     region_element.second=0;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==1);
+     assert(myDataSliced->getLength()==6);
+     myDataView = myDataSliced->getDefaultValue();
+     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);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==27);
+     assert(myDataView(1)==28);
+     assert(myDataView(2)==29);
+     // scalar slice
+     region_element.first=1;
+     region_element.second=1;
+     region.clear();
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==1);
+     assert(myDataSliced->getLength()==2);
+     myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==13);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==40);
+   }
+   {
+     cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     keys.push_back(2);
+     keys.push_back(3);
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     // default value
+     DataArrayView::ValueType viewData(1);
+     viewData[0]=0.0;
+     DataArrayView myView(viewData,viewShape);
+     // value for tag "1"
+     DataArray eOne(myView);
+     eOne.getView()()=1.0;
+     values.push_back(eOne.getView());
+     // value for tag "2"
+     DataArray eTwo(myView);
+     eTwo.getView()()=2.0;
+     values.push_back(eTwo.getView());
+     // value for tag "3"
+     DataArray eThree(myView);
+     eThree.getView()()=3.0;
+     values.push_back(eThree.getView());
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     // cout << myData.toString() << endl;
+     // full slice
+     DataArrayView::RegionType region;
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==3);
+     assert(myDataSliced->getLength()==4);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==0);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==1);
+     myDataView = myDataSliced->getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==2);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==2);
+     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);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     keys.push_back(2);
+     keys.push_back(3);
+     DataTagged::ValueListType values;
+     // default value
+     DataArrayView::ValueType viewData(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     // value for tag "1"
+     DataArray eOne(myView);
+     for (int i=0;i<eOne.getView().getShape()[0];i++) {
+       eOne.getView()(i)=i+3.0;
+     }
+     values.push_back(eOne.getView());
+     // value for tag "2"
+     DataArray eTwo(myView);
+     for (int i=0;i<eTwo.getView().getShape()[0];i++) {
+       eTwo.getView()(i)=i+6.0;
+     }
+     values.push_back(eTwo.getView());
+     // value for tag "3"
+     DataArray eThree(myView);
+     for (int i=0;i<eThree.getView().getShape()[0];i++) {
+       eThree.getView()(i)=i+9.0;
+     }
+     values.push_back(eThree.getView());
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     //cout << myData.toString() << endl;
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==3);
+     assert(myDataSliced->getLength()==12);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     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);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     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);
+     myDataView = myDataSliced->getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==6);
+     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);
+     myDataView = myDataSliced->getDataPointByTag(3);
+     assert(!myDataView.isEmpty());
+     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);
+     // scalar slice
+     region.clear();
+     region_element.first=1;
+     region_element.second=1;
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==3);
+     assert(myDataSliced->getLength()==4);
+     myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==1);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==4);
+     myDataView = myDataSliced->getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==2);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==7);
+     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()==10);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     keys.push_back(2);
+     keys.push_back(3);
+     DataTagged::ValueListType values;
+     // default value
+     DataArrayView::ValueType viewData(27);
+     for (int i=0;i<viewData.size();i++) {
+       viewData[i]=i;
+     }
+     DataArrayView myView(viewData,viewShape);
+     // value for tag "1"
+     DataArrayView::ValueType viewData1(27);
+     for (int i=0;i<viewData1.size();i++) {
+       viewData1[i]=i+27.0;
+     }
+     DataArrayView myView1(viewData1,viewShape);
+     values.push_back(myView1);
+     // value for tag "2"
+     DataArrayView::ValueType viewData2(27);
+     for (int i=0;i<viewData2.size();i++) {
+       viewData2[i]=i+54.0;
+     }
+     DataArrayView myView2(viewData2,viewShape);
+     values.push_back(myView2);
+     // value for tag "3"
+     DataArrayView::ValueType viewData3(27);
+     for (int i=0;i<viewData3.size();i++) {
+       viewData3[i]=i+81.0;
+     }
+     DataArrayView myView3(viewData3,viewShape);
+     values.push_back(myView3);
+     DataTagged myData(keys,values,myView,FunctionSpace());
+     //cout << myData.toString() << endl;
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     DataAbstract* slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==3);
+     assert(myDataSliced->getLength()==108);
+     DataArrayView myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==27);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     myDataView = myDataSliced->getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==54);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     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);
+     // rank 1 slice
+     region.clear();
+     region.push_back(region_element);
+     region_element.second=0;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     // cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==3);
+     assert(myDataSliced->getLength()==12);
+     myDataView = myDataSliced->getDefaultValue();
+     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);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==27);
+     assert(myDataView(1)==28);
+     assert(myDataView(2)==29);
+     myDataView = myDataSliced->getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==6);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==54);
+     assert(myDataView(1)==55);
+     assert(myDataView(2)==56);
+     myDataView = myDataSliced->getDataPointByTag(3);
+     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);
+     // scalar slice
+     region_element.first=1;
+     region_element.second=1;
+     region.clear();
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     slicedDefault = myData.getSlice(region);
+     //cout << slicedDefault->toString() << endl;
+     myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
+     assert(myDataSliced->getTagLookup().size()==3);
+     assert(myDataSliced->getLength()==4);
+     myDataView = myDataSliced->getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==13);
+     myDataView = myDataSliced->getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==40);
+     myDataView = myDataSliced->getDataPointByTag(2);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==2);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==67);
+     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()==94);
+   }
+ }
+ void DataTaggedTestCase::testSetSlice() {
+   cout << endl;
+   {
+     cout << "\tTest slicing default DataTagged." << endl;
+     DataTagged myData1;
+     DataTagged myData2;
+     DataArrayView::RegionType region;
+     myData2.getDefaultValue()()=1.0;
+     myData1.setSlice(&myData2, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==1);
+     DataArrayView myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==1.0);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     DataArrayView::ValueType viewData1(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData1[i]=i;
+     }
+     DataArrayView myView1(viewData1,viewShape);
+     DataTagged myData1(keys,values,myView1,FunctionSpace());
+     DataArrayView::ValueType viewData2(3);
+     for (int i=0;i<viewShape[0];i++) {
+       viewData2[i]=i+3;
+     }
+     DataArrayView myView2(viewData2,viewShape);
+     DataTagged myData2(keys,values,myView2,FunctionSpace());
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     myData1.setSlice(&myData2, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==3);
+     DataArrayView myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==3.0);
+     assert(myDataView(1)==4.0);
+     assert(myDataView(2)==5.0);
+     // rank 1 slice
+     viewShape.clear();
+     viewShape.push_back(1);
+     DataArrayView::ValueType viewData3(1);
+     viewData3[0]=6.0;
+     DataArrayView myView3(viewData3,viewShape);
+     DataTagged myData3(keys,values,myView3,FunctionSpace());
+     region.clear();
+     region_element.first=1;
+     region_element.second=2;
+     region.push_back(region_element);
+     myData1.setSlice(&myData3, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==3);
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==3.0);
+     assert(myDataView(1)==6.0);
+     assert(myDataView(2)==5.0);
+     // scalar slice
+     region.clear();
+     region_element.first=0;
+     region_element.second=0;
+     region.push_back(region_element);
+     DataTagged myData4;
+     myData4.getDefaultValue()()=7.0;
+     myData1.setSlice(&myData4, region);
+     //cout << myData3.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==3);
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==7.0);
+     assert(myDataView(1)==6.0);
+     assert(myDataView(2)==5.0);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
+     DataTagged::TagListType keys;
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     DataArrayView::ValueType viewData1(27);
+     for (int i=0;i<viewData1.size();i++) {
+       viewData1[i]=i;
+     }
+     DataArrayView myView1(viewData1,viewShape);
+     DataTagged myData1(keys,values,myView1,FunctionSpace());
+     DataArrayView::ValueType viewData2(27);
+     for (int i=0;i<viewData2.size();i++) {
+       viewData2[i]=i+27;
+     }
+     DataArrayView myView2(viewData2,viewShape);
+     DataTagged myData2(keys,values,myView2,FunctionSpace());
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     myData1.setSlice(&myData2, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==27);
+     DataArrayView myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     // rank 1 slice
+     viewShape.clear();
+     viewShape.push_back(3);
+     DataArrayView::ValueType viewData3(3);
+     for (int i=0;i<viewData3.size();i++) {
+       viewData3[i]=i+60;
+     }
+     DataArrayView myView3(viewData3,viewShape);
+     DataTagged myData3(keys,values,myView3,FunctionSpace());
+     region.clear();
+     region.push_back(region_element);
+     region_element.first=0;
+     region_element.second=0;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     myData1.setSlice(&myData3, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==27);
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     assert(myDataView(0,0,0)==60.0);
+     assert(myDataView(1,0,0)==61.0);
+     assert(myDataView(2,0,0)==62.0);
+     // scalar slice
+     region.clear();
+     region_element.first=0;
+     region_element.second=0;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     DataTagged myData4;
+     myData4.getDefaultValue()()=70.0;
+     myData1.setSlice(&myData4, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==0);
+     assert(myData1.getLength()==27);
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     assert(myDataView(0,0,0)==70.0);
+   }
+   {
+     cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     // default value for Data1
+     DataArrayView::ValueType viewData1(1);
+     viewData1[0]=0.0;
+     DataArrayView myView1(viewData1,viewShape);
+     // value for tag "1" for Data1
+     DataArrayView::ValueType viewData2(1);
+     viewData2[0]=0.0;
+     DataArrayView myView2(viewData2,viewShape);
+     values.push_back(myView2);
+     DataTagged myData1(keys,values,myView1,FunctionSpace());
+     values.clear();
+     // default value for Data2
+     DataArrayView::ValueType viewData3(1);
+     viewData3[0]=1.0;
+     DataArrayView myView3(viewData3,viewShape);
+     // value for tag "1" for Data2
+     DataArrayView::ValueType viewData4(1);
+     viewData4[0]=2.0;
+     DataArrayView myView4(viewData4,viewShape);
+     values.push_back(myView4);
+     DataTagged myData2(keys,values,myView3,FunctionSpace());
+     // full slice
+     DataArrayView::RegionType region;
+     myData1.setSlice(&myData2, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==1);
+     assert(myData1.getLength()==2);
+     DataArrayView myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==1.0);
+     myDataView = myData1.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==1);
+     assert(myDataView.getRank()==0);
+     assert(myDataView.noValues()==1);
+     assert(myDataView.getShape().size()==0);
+     assert(myDataView()==2.0);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     // default value for Data1
+     DataArrayView::ValueType viewData1(3);
+     for (int i=0;i<viewData1.size();i++) {
+       viewData1[i]=0.0;
+     }
+     DataArrayView myView1(viewData1,viewShape);
+     // value for tag "1" for Data1
+     DataArrayView::ValueType viewData2(3);
+     for (int i=0;i<viewData2.size();i++) {
+       viewData2[i]=0.0;
+     }
+     DataArrayView myView2(viewData2,viewShape);
+     values.push_back(myView2);
+     DataTagged myData1(keys,values,myView1,FunctionSpace());
+     values.clear();
+     // default value for Data2
+     DataArrayView::ValueType viewData3(3);
+     for (int i=0;i<viewData3.size();i++) {
+       viewData3[i]=1.0;
+     }
+     DataArrayView myView3(viewData3,viewShape);
+     // value for tag "1" for Data2
+     DataArrayView::ValueType viewData4(3);
+     for (int i=0;i<viewData4.size();i++) {
+       viewData4[i]=2.0;
+     }
+     DataArrayView myView4(viewData4,viewShape);
+     values.push_back(myView4);
+     DataTagged myData2(keys,values,myView3,FunctionSpace());
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     myData1.setSlice(&myData2, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==1);
+     assert(myData1.getLength()==6);
+     DataArrayView myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==1.0);
+     assert(myDataView(1)==1.0);
+     assert(myDataView(2)==1.0);
+     myDataView = myData1.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==2.0);
+     assert(myDataView(1)==2.0);
+     assert(myDataView(2)==2.0);
+     // rank 1 slice
+     viewShape.clear();
+     viewShape.push_back(1);
+     DataArrayView::ValueType viewData5(1);
+     viewData5[0]=3.0;
+     DataArrayView myView5(viewData5,viewShape);
+     values.clear();
+     DataArrayView::ValueType viewData6(1);
+     viewData6[0]=4.0;
+     DataArrayView myView6(viewData6,viewShape);
+     values.push_back(myView6);
+     DataTagged myData3(keys,values,myView5,FunctionSpace());
+     region.clear();
+     region_element.first=1;
+     region_element.second=2;
+     region.push_back(region_element);
+     myData1.setSlice(&myData3, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==1);
+     assert(myData1.getLength()==6);
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==1.0);
+     assert(myDataView(1)==3.0);
+     assert(myDataView(2)==1.0);
+     myDataView = myData1.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==2.0);
+     assert(myDataView(1)==4.0);
+     assert(myDataView(2)==2.0);
+     // scalar slice
+     viewShape.clear();
+     DataArrayView::ValueType viewData7(1);
+     viewData7[0]=5.0;
+     DataArrayView myView7(viewData7,viewShape);
+     values.clear();
+     DataArrayView::ValueType viewData8(1);
+     viewData8[0]=6.0;
+     DataArrayView myView8(viewData8,viewShape);
+     values.push_back(myView8);
+     DataTagged myData4(keys,values,myView7,FunctionSpace());
+     region.clear();
+     region_element.first=0;
+     region_element.second=0;
+     region.push_back(region_element);
+     myData1.setSlice(&myData4, region);
+     //cout << myData1.toString() << endl;
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==5.0);
+     assert(myDataView(1)==3.0);
+     assert(myDataView(2)==1.0);
+     myDataView = myData1.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==3);
+     assert(myDataView.getRank()==1);
+     assert(myDataView.noValues()==3);
+     assert(myDataView.getShape().size()==1);
+     assert(myDataView(0)==6.0);
+     assert(myDataView(1)==4.0);
+     assert(myDataView(2)==2.0);
+   }
+   {
+     cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
+     DataTagged::TagListType keys;
+     keys.push_back(1);
+     DataTagged::ValueListType values;
+     DataArrayView::ShapeType viewShape;
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     viewShape.push_back(3);
+     // default value for Data1
+     DataArrayView::ValueType viewData1(27);
+     for (int i=0;i<viewData1.size();i++) {
+       viewData1[i]=0.0;
+     }
+     DataArrayView myView1(viewData1,viewShape);
+     // value for tag "1" for Data1
+     DataArrayView::ValueType viewData2(27);
+     for (int i=0;i<viewData2.size();i++) {
+       viewData2[i]=0.0;
+     }
+     DataArrayView myView2(viewData2,viewShape);
+     values.push_back(myView2);
+     DataTagged myData1(keys,values,myView1,FunctionSpace());
+     values.clear();
+     // default value for Data2
+     DataArrayView::ValueType viewData3(27);
+     for (int i=0;i<viewData3.size();i++) {
+       viewData3[i]=1.0;
+     }
+     DataArrayView myView3(viewData3,viewShape);
+     // value for tag "1" for Data2
+     DataArrayView::ValueType viewData4(27);
+     for (int i=0;i<viewData4.size();i++) {
+       viewData4[i]=2.0;
+     }
+     DataArrayView myView4(viewData4,viewShape);
+     values.push_back(myView4);
+     DataTagged myData2(keys,values,myView3,FunctionSpace());
+     // full slice
+     std::pair<int, int> region_element;
+     region_element.first=0;
+     region_element.second=3;
+     DataArrayView::RegionType region;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     region.push_back(region_element);
+     myData1.setSlice(&myData2, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==1);
+     assert(myData1.getLength()==54);
+     DataArrayView myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     assert(myDataView(0,0,0)==1.0);
+     assert(myDataView(1,1,1)==1.0);
+     assert(myDataView(2,2,2)==1.0);
+     myDataView = myData1.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==27);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     assert(myDataView(0,0,0)==2.0);
+     assert(myDataView(1,1,1)==2.0);
+     assert(myDataView(2,2,2)==2.0);
+     // rank 1 slice
+     viewShape.clear();
+     viewShape.push_back(3);
+     DataArrayView::ValueType viewData5(3);
+     for (int i=0;i<viewData5.size();i++) {
+       viewData5[i]=3.0;
+     }
+     DataArrayView myView5(viewData5,viewShape);
+     values.clear();
+     DataArrayView::ValueType viewData6(3);
+     for (int i=0;i<viewData6.size();i++) {
+       viewData6[i]=4.0;
+     }
+     DataArrayView myView6(viewData6,viewShape);
+     values.push_back(myView6);
+     DataTagged myData3(keys,values,myView5,FunctionSpace());
+     region.clear();
+     region.push_back(region_element);
+     region_element.first=0;
+     region_element.second=0;
+     region.push_back(region_element);
+     region.push_back(region_element);
+     myData1.setSlice(&myData3, region);
+     //cout << myData1.toString() << endl;
+     assert(myData1.getTagLookup().size()==1);
+     assert(myData1.getLength()==54);
+     myDataView = myData1.getDefaultValue();
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==0);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     assert(myDataView(0,0,0)==3.0);
+     assert(myDataView(1,0,0)==3.0);
+     assert(myDataView(2,0,0)==3.0);
+     myDataView = myData1.getDataPointByTag(1);
+     assert(!myDataView.isEmpty());
+     assert(myDataView.getOffset()==27);
+     assert(myDataView.getRank()==3);
+     assert(myDataView.noValues()==27);
+     assert(myDataView.getShape().size()==3);
+     assert(myDataView(0,0,0)==4.0);
+     assert(myDataView(1,0,0)==4.0);
+     assert(myDataView(2,0,0)==4.0);
+     // scalar slice