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

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

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

trunk/escript/test/DataTagged/DataTaggedTestCase.cpp revision 515 by jgs, Mon Feb 13 05:59:51 2006 UTC temp/escript/test/DataTaggedTestCase.cpp revision 1387 by trankine, Fri Jan 11 07:45:26 2008 UTC
# Line 1  Line 1 
 // $Id$  
 /*  
  *****************************************************************************  
  *                                                                           *  
  *       COPYRIGHT  ACcESS  -  All Rights Reserved                           *  
  *                                                                           *  
  * This software is the property of ACcESS. No part of this code             *  
  * may be copied in any form or by any means without the expressed written   *  
  * consent of ACcESS.  Copying, use or modification of this software         *  
  * by any unauthorised person is illegal unless that person has a software   *  
  * license agreement with ACcESS.                                            *  
  *                                                                           *  
  *****************************************************************************  
 */  
1    
2  #include "EsysException.h"  /* $Id$ */
3    
4  #include "DataTagged.h"  /*******************************************************
5  #include "DataConstant.h"   *
6     *           Copyright 2003-2007 by ACceSS MNRF
7     *       Copyright 2007 by University of Queensland
8     *
9     *                http://esscc.uq.edu.au
10     *        Primary Business: Queensland, Australia
11     *  Licensed under the Open Software License version 3.0
12     *     http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16    #include "esysUtils/EsysException.h"
17    
18    #include "escript/DataVector.h"
19    #include "escript/DataTagged.h"
20    #include "escript/DataConstant.h"
21    
22  #include "DataTaggedTestCase.h"  #include "DataTaggedTestCase.h"
23    
24  #include "BinaryOp.h"  #include "escript/BinaryOp.h"
25  #include "UnaryOp.h"  #include "escript/UnaryOp.h"
26  #include "FunctionSpaceFactory.h"  #include "escript/FunctionSpaceFactory.h"
27  #include "DataFactory.h"  #include "escript/DataFactory.h"
28    
29  #include <iostream>  #include <iostream>
30  #include <functional>  #include <functional>
# Line 37  using namespace std; Line 38  using namespace std;
38  void DataTaggedTestCase::setUp() {  void DataTaggedTestCase::setUp() {
39    //    //
40    // This is called before each test is run    // This is called before each test is run
41    
42  }  }
43    
44  void DataTaggedTestCase::tearDown() {  void DataTaggedTestCase::tearDown() {
45    //    //
46    // This is called after each test has been run    // This is called after each test has been run
   
 }  
   
 void DataTaggedTestCase::testReshape() {  
   
   cout << endl;  
   
   {  
   
     cout << "\tTest rank 1 reshape of default DataTagged." << endl;  
   
     DataTagged myData;  
     myData.getPointDataView()()=1.0;  
   
     DataArrayView::ShapeType shape;  
     shape.push_back(2);  
   
     myData.reshapeDataPoint(shape);  
   
     for (int i=0;i<shape[0];i++) {  
       assert(myData.getDefaultValue()(i)==1);  
     }  
   
     //cout << myData.toString() << endl;  
   
     assert(myData.getNumSamples()==1);  
     assert(myData.getNumDPPSample()==1);  
   
     assert(myData.validSamplePointNo(0));  
     assert(myData.validSampleNo(0));  
     assert(!myData.validSamplePointNo(1));  
     assert(!myData.validSampleNo(1));  
   
     // data-point 0 has tag number 1 by default  
     assert(myData.getTagNumber(0)==1);  
   
     assert(!myData.isCurrentTag(1));  
   
     assert(myData.getTagLookup().size()==0);  
   
     assert(myData.getLength()==2);  
   
     assert(myData.getPointOffset(0,0)==0);  
   
     DataArrayView myDataView = myData.getDataPoint(0,0);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==2);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1.0);  
     assert(myDataView(1)==1.0);  
   
     // Test non-existent tag returns the default value.  
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==2);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1.0);  
     assert(myDataView(1)==1.0);  
   
     myDataView = myData.getDefaultValue();  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==1);  
     assert(myDataView.noValues()==2);  
     assert(myDataView.getShape().size()==1);  
     assert(myDataView(0)==1.0);  
     assert(myDataView(1)==1.0);  
   
     // use a non-existent tag so we get a pointer to  
     // the first element of the data array  
     double* sampleData=myData.getSampleDataByTag(9);  
     for (int i=0; i<myData.getLength(); i++) {  
       assert(sampleData[i]==1.0);  
     }  
   
   }  
   
   {  
   
     cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;  
   
     DataTagged::TagListType keys;  
     keys.push_back(1);  
   
     DataTagged::ValueListType values;  
   
     DataArrayView::ShapeType viewShape;  
   
     // default value  
     DataArrayView::ValueType viewData(1);  
     viewData[0]=1.0;  
     DataArrayView myView(viewData,viewShape);  
   
     // value for tag "1"  
     DataArray eOne(myView);  
     eOne.getView()()=2.0;  
     values.push_back(eOne.getView());  
   
     DataTagged myData(keys,values,myView,FunctionSpace());  
   
     DataArrayView::ShapeType shape;  
     shape.push_back(2);  
     shape.push_back(5);  
   
     myData.reshapeDataPoint(shape);  
   
     //cout << myData.toString() << endl;  
   
     assert(myData.getNumSamples()==1);  
     assert(myData.getNumDPPSample()==1);  
   
     assert(myData.validSamplePointNo(0));  
     assert(myData.validSampleNo(0));  
     assert(!myData.validSamplePointNo(1));  
     assert(!myData.validSampleNo(1));  
   
     // data-point 0 has tag number 1 by default  
     assert(myData.getTagNumber(0)==1);  
   
     assert(myData.isCurrentTag(1));  
   
     assert(myData.getTagLookup().size()==1);  
   
     assert(myData.getLength()==20);  
   
     assert(myData.getPointOffset(0,0)==10);  
   
     DataArrayView myDataView = myData.getDataPoint(0,0);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==10);  
     assert(myDataView.getRank()==2);  
     assert(myDataView.noValues()==10);  
     assert(myDataView.getShape().size()==2);  
     for (int j=0;j<shape[1];j++) {  
       for (int i=0;i<shape[0];i++) {  
         assert(myDataView(i,j)==2.0);  
       }  
     }  
   
     myDataView = myData.getDataPointByTag(1);  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==10);  
     assert(myDataView.getRank()==2);  
     assert(myDataView.noValues()==10);  
     assert(myDataView.getShape().size()==2);  
     for (int j=0;j<shape[1];j++) {  
       for (int i=0;i<shape[0];i++) {  
         assert(myDataView(i,j)==2.0);  
       }  
     }  
   
     myDataView = myData.getDefaultValue();  
     assert(!myDataView.isEmpty());  
     assert(myDataView.getOffset()==0);  
     assert(myDataView.getRank()==2);  
     assert(myDataView.noValues()==10);  
     assert(myDataView.getShape().size()==2);  
     for (int j=0;j<shape[1];j++) {  
       for (int i=0;i<shape[0];i++) {  
         assert(myDataView(i,j)==1.0);  
       }  
     }  
   
     // use a non-existent tag so we get a pointer to  
     // the first element of the data array  
     double* sampleData=myData.getSampleDataByTag(9);  
     for (int i=0; i<myData.getLength(); i++) {  
       if (i<10) {  
         assert(sampleData[i]==1.0);  
       } else {  
         assert(sampleData[i]==2.0);  
       }  
     }  
   
   }  
   
   {  
   
     cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;  
   
     DataTagged::TagListType keys;  
     keys.push_back(1);  
     keys.push_back(2);  
     keys.push_back(3);  
   
     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);  
       }  
     }  
   
   }  
47    
48  }  }
49    
50    
51  void DataTaggedTestCase::testOperations() {  void DataTaggedTestCase::testOperations() {
52    
53    cout << endl;    cout << endl;
# Line 511  void DataTaggedTestCase::testOperations( Line 182  void DataTaggedTestCase::testOperations(
182      DataTagged myData;      DataTagged myData;
183      DataTagged right;      DataTagged right;
184    
185      DataArray vOne(1.0);      DataVector vOneData(1, 1.0 ,1);
186      myData.addTaggedValue(1,vOne.getView());      // create a view with an empty shape, a scalar.
187      right.addTaggedValue(1,vOne.getView());      DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
188    
189        myData.addTaggedValue(1,vOneView);
190        right.addTaggedValue(1,vOneView);
191    
192      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
193    
# Line 569  void DataTaggedTestCase::testOperations( Line 243  void DataTaggedTestCase::testOperations(
243      DataTagged myData;      DataTagged myData;
244      DataTagged right;      DataTagged right;
245    
246      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
247      DataArray vTwo(2.0);      // verify that the tag values in each object are being added to the correct
248      myData.addTaggedValue(1,vOne.getView());      // default values - since the tag lists don't match, the default values will
249      right.addTaggedValue(2,vTwo.getView());      // be used for missing tags in each object
250        myData.getDefaultValue()()=1.0;
251        right.getDefaultValue()()=2.0;
252    
253        DataVector vOneData(1, 3.0 ,1);
254        // create a view with an empty shape, a scalar.
255        DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
256    
257        DataVector vTwoData(1, 4.0 ,1);
258        // create a view with an empty shape, a scalar.
259        DataArrayView vTwoView(vTwoData,DataArrayView::ShapeType());
260    
261        myData.addTaggedValue(1,vOneView);
262        right.addTaggedValue(2,vTwoView);
263    
264        //cout << myData.toString() << endl;
265        //cout << right.toString() << endl;
266    
267      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
268    
269        //cout << myData.toString() << endl;
270    
271      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
272      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
273    
# Line 603  void DataTaggedTestCase::testOperations( Line 295  void DataTaggedTestCase::testOperations(
295      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
296      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
297      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
298      assert(myDataView()==1.0);      assert(myDataView()==5.0);
299    
300      // check result value for tag "2"      // check result value for tag "2"
301      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 612  void DataTaggedTestCase::testOperations( Line 304  void DataTaggedTestCase::testOperations(
304      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
305      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
306      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
307      assert(myDataView()==2.0);      assert(myDataView()==5.0);
308    
309      // check result for default value      // check result for default value
310      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 621  void DataTaggedTestCase::testOperations( Line 313  void DataTaggedTestCase::testOperations(
313      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
314      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
315      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
316      assert(myDataView()==0.0);      assert(myDataView()==3.0);
317    
318      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
319      // the first element of the data array      // the first element of the data array
320      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
321      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==3);
322        assert(sampleData[i]==i);      assert(sampleData[1]==5);
323      }      assert(sampleData[2]==5);
324    
325    }    }
326    
# Line 638  void DataTaggedTestCase::testOperations( Line 330  void DataTaggedTestCase::testOperations(
330      DataTagged myData;      DataTagged myData;
331      DataTagged right;      DataTagged right;
332    
333      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
334      myData.addTaggedValue(1,vOne.getView());      // verify that the tag values in each object are being added to the correct
335      myData.addTaggedValue(2,vOne.getView());      // default values - since the tag lists don't match, the default values will
336      right.addTaggedValue(2,vOne.getView());      // be used for missing tags in each object
337      right.addTaggedValue(3,vOne.getView());      myData.getDefaultValue()()=2.0;
338        right.getDefaultValue()()=3.0;
339    
340        DataVector vOneData(1, 1.0 ,1);
341        // create a view with an empty shape, a scalar.
342        DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
343    
344        myData.addTaggedValue(1,vOneView);
345        myData.addTaggedValue(2,vOneView);
346        right.addTaggedValue(2,vOneView);
347        right.addTaggedValue(3,vOneView);
348    
349        //cout << myData.toString() << endl;
350        //cout << right.toString() << endl;
351    
352      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
353    
354        //cout << myData.toString() << endl;
355    
356      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
357      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
358    
# Line 674  void DataTaggedTestCase::testOperations( Line 381  void DataTaggedTestCase::testOperations(
381      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
382      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
383      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
384      assert(myDataView()==1.0);      assert(myDataView()==4.0);
385    
386      // check result value for tag "2"      // check result value for tag "2"
387      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 692  void DataTaggedTestCase::testOperations( Line 399  void DataTaggedTestCase::testOperations(
399      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
400      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
401      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
402      assert(myDataView()==1.0);      assert(myDataView()==3.0);
403    
404      // check result for default value      // check result for default value
405      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 701  void DataTaggedTestCase::testOperations( Line 408  void DataTaggedTestCase::testOperations(
408      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
409      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
410      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
411      assert(myDataView()==0.0);      assert(myDataView()==5.0);
412    
413      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
414      // the first element of the data array      // the first element of the data array
415      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
416      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==5);
417        if (i<3) {      assert(sampleData[1]==4);
418          assert(sampleData[i]==i);      assert(sampleData[2]==2);
419        } else {      assert(sampleData[3]==3);
         assert(sampleData[i]==i-2);  
       }  
     }  
420    
421    }    }
422    
# Line 778  void DataTaggedTestCase::testOperations( Line 482  void DataTaggedTestCase::testOperations(
482    }    }
483    
484    {    {
485    
486        cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
487    
488        DataTagged myData;
489    
490        DataVector vOneData(1, 1.0 ,1);
491        // create a view with an empty shape, a scalar.
492        DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
493    
494        DataVector vTwoData(1, 2.0 ,1);
495        // create a view with an empty shape, a scalar.
496        DataArrayView vTwoView(vTwoData,DataArrayView::ShapeType());
497    
498        myData.addTaggedValue(1,vOneView);
499        myData.addTaggedValue(2,vTwoView);
500    
501        DataVector vThreeData(1, 3.0 ,1);
502        // create a view with an empty shape, a scalar.
503        DataArrayView vThreeView(vThreeData,DataArrayView::ShapeType());
504    
505        DataArrayView right=vThreeView;
506    
507        //cout << myData.toString() << endl;
508        //cout << right.toString() << endl;
509    
510        binaryOp(myData,right,multiplies<double>());
511    
512        //cout << myData.toString() << endl;
513    
514        assert(myData.getNumSamples()==1);
515        assert(myData.getNumDPPSample()==1);
516    
517        assert(myData.validSamplePointNo(0));
518        assert(myData.validSampleNo(0));
519        assert(!myData.validSamplePointNo(1));
520        assert(!myData.validSampleNo(1));
521    
522        // data-point 0 has tag number 1 by default
523        assert(myData.getTagNumber(0)==1);
524    
525        assert(myData.isCurrentTag(1));
526        assert(myData.isCurrentTag(2));
527    
528        assert(myData.getTagLookup().size()==2);
529    
530        assert(myData.getLength()==3);
531    
532        assert(myData.getPointOffset(0,0)==1);
533    
534        // check result value for tag "1"
535        DataArrayView myDataView = myData.getDataPointByTag(1);
536        assert(!myDataView.isEmpty());
537        assert(myDataView.getOffset()==1);
538        assert(myDataView.getRank()==0);
539        assert(myDataView.noValues()==1);
540        assert(myDataView.getShape().size()==0);
541        assert(myDataView()==3.0);
542    
543        // check result value for tag "2"
544        myDataView = myData.getDataPointByTag(2);
545        assert(!myDataView.isEmpty());
546        assert(myDataView.getOffset()==2);
547        assert(myDataView.getRank()==0);
548        assert(myDataView.noValues()==1);
549        assert(myDataView.getShape().size()==0);
550        assert(myDataView()==6.0);
551    
552        // check result for default value
553        myDataView = myData.getDefaultValue();
554        assert(!myDataView.isEmpty());
555        assert(myDataView.getOffset()==0);
556        assert(myDataView.getRank()==0);
557        assert(myDataView.noValues()==1);
558        assert(myDataView.getShape().size()==0);
559        assert(myDataView()==0.0);
560    
561        // use a non-existent tag so we get a pointer to
562        // the first element of the data array
563        double* sampleData=myData.getSampleDataByTag(9);
564        assert(sampleData[0]==0);
565        assert(sampleData[1]==3);
566        assert(sampleData[2]==6);
567    
568      }
569    
570      {
571      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
572    
573      DataTagged myData;      DataTagged myData;
574      DataTagged right;      DataTagged right;
575    
576      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
577      DataArray vTwo(2.0);      // verify that the tag values in each object are being added to the correct
578      myData.addTaggedValue(1,vOne.getView());      // default values - since the tag lists don't match, the default values will
579      myData.addTaggedValue(2,vOne.getView());      // be used for missing tags in each object
580      right.addTaggedValue(2,vTwo.getView());      myData.getDefaultValue()()=2.0;
581      right.addTaggedValue(3,vTwo.getView());      right.getDefaultValue()()=3.0;
582    
583        DataVector vOneData(1, 1.0 ,1);
584        // create a view with an empty shape, a scalar.
585        DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
586    
587        DataVector vTwoData(1, 2.0 ,1);
588        // create a view with an empty shape, a scalar.
589        DataArrayView vTwoView(vTwoData,DataArrayView::ShapeType());
590    
591        myData.addTaggedValue(1,vOneView);
592        myData.addTaggedValue(2,vOneView);
593        right.addTaggedValue(2,vTwoView);
594        right.addTaggedValue(3,vTwoView);
595    
596        //cout << myData.toString() << endl;
597        //cout << right.toString() << endl;
598    
599      binaryOp(myData,right,multiplies<double>());      binaryOp(myData,right,multiplies<double>());
600    
601        //cout << myData.toString() << endl;
602    
603      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
604      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
605    
# Line 820  void DataTaggedTestCase::testOperations( Line 628  void DataTaggedTestCase::testOperations(
628      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
629      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
630      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
631      assert(myDataView()==0.0);      assert(myDataView()==3.0);
632    
633      // check result value for tag "2"      // check result value for tag "2"
634      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 838  void DataTaggedTestCase::testOperations( Line 646  void DataTaggedTestCase::testOperations(
646      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
647      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
648      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
649      assert(myDataView()==0.0);      assert(myDataView()==4.0);
650    
651      // check result for default value      // check result for default value
652      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 847  void DataTaggedTestCase::testOperations( Line 655  void DataTaggedTestCase::testOperations(
655      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
656      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
657      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
658      assert(myDataView()==0.0);      assert(myDataView()==6.0);
659    
660      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
661      // the first element of the data array      // the first element of the data array
662      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
663      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==6);
664        if (i==2) {      assert(sampleData[1]==3);
665          assert(sampleData[i]==2);      assert(sampleData[2]==2);
666        } else {      assert(sampleData[3]==4);
         assert(sampleData[i]==0);  
       }  
     }  
667    
668    }    }
669    
# Line 985  void DataTaggedTestCase::testOperations( Line 790  void DataTaggedTestCase::testOperations(
790    }    }
791    
792    {    {
793      cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;      cout << "\tTest unnaryOp negate on DataTagged object with two tags." << endl;
794    
795      DataTagged myData;      DataTagged myData;
796    
797      DataArray vOne(1.0);      DataVector vOneData(1, 1.0 ,1);
798      DataArray vTwo(2.0);      // create a view with an empty shape, a scalar.
799      myData.addTaggedValue(1,vOne.getView());      DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
800      myData.addTaggedValue(2,vTwo.getView());  
801        DataVector vTwoData(1, 2.0 ,1);
802        // create a view with an empty shape, a scalar.
803        DataArrayView vTwoView(vTwoData,DataArrayView::ShapeType());
804    
805        myData.addTaggedValue(1,vOneView);
806        myData.addTaggedValue(2,vTwoView);
807    
808      unaryOp(myData,negate<double>());      unaryOp(myData,negate<double>());
809    
# Line 1778  void DataTaggedTestCase::testAddTaggedVa Line 1589  void DataTaggedTestCase::testAddTaggedVa
1589      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
1590    
1591      // value for tag "1"      // value for tag "1"
1592      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
1593      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
1594        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
1595          eOneView(i)=i+1.0;
1596      }      }
1597      values.push_back(eOne.getView());      values.push_back(eOneView);
1598    
1599      // value for tag "2"      // value for tag "2"
1600      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
1601      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
1602        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
1603          eTwoView(i)=i+2.0;
1604      }      }
1605      values.push_back(eTwo.getView());      values.push_back(eTwoView);
1606    
1607      // value for tag "3"      // value for tag "3"
1608      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
1609      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
1610        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
1611          eThreeView(i)=i+3.0;
1612      }      }
1613      values.push_back(eThree.getView());      values.push_back(eThreeView);
1614    
1615      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
1616    
# Line 1864  void DataTaggedTestCase::testAddTaggedVa Line 1678  void DataTaggedTestCase::testAddTaggedVa
1678      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
1679    
1680      // value for tag "1"      // value for tag "1"
1681      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
1682      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
1683        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
1684          eOneView(i)=i+1.0;
1685      }      }
1686      values.push_back(eOne.getView());      values.push_back(eOneView);
1687    
1688      // value for tag "2"      // value for tag "2"
1689      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
1690      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
1691        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
1692          eTwoView(i)=i+2.0;
1693      }      }
1694      values.push_back(eTwo.getView());      values.push_back(eTwoView);
1695    
1696      // value for tag "3"      // value for tag "3"
1697      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
1698      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
1699        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
1700          eThreeView(i)=i+3.0;
1701      }      }
1702      values.push_back(eThree.getView());      values.push_back(eThreeView);
1703    
1704      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
1705    
# Line 1891  void DataTaggedTestCase::testAddTaggedVa Line 1708  void DataTaggedTestCase::testAddTaggedVa
1708    
1709      values.clear();      values.clear();
1710      // value for tag "4"      // value for tag "4"
1711      DataArray eFour(myView);      DataArrayView::ValueType eFourData(viewData);
1712      for (int i=0;i<eFour.getView().getShape()[0];i++) {      DataArrayView eFourView(eFourData, viewShape);
1713        eFour.getView()(i)=i+4.0;      for (int i=0;i<eFourView.getShape()[0];i++) {
1714          eFourView(i)=i+4.0;
1715      }      }
1716      values.push_back(eFour.getView());      values.push_back(eFourView);
1717    
1718      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values);
1719    
# Line 1906  void DataTaggedTestCase::testAddTaggedVa Line 1724  void DataTaggedTestCase::testAddTaggedVa
1724      assert(myData.getLength()==15);      assert(myData.getLength()==15);
1725    
1726      DataArrayView myDataView = myData.getDataPointByTag(4);      DataArrayView myDataView = myData.getDataPointByTag(4);
1727      assert(myDataView==eFour.getView());      assert(myDataView==eFourView);
1728      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1729      assert(myDataView.getOffset()==12);      assert(myDataView.getOffset()==12);
1730      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 1957  void DataTaggedTestCase::testAddTaggedVa Line 1775  void DataTaggedTestCase::testAddTaggedVa
1775      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
1776    
1777      // value for tag "1"      // value for tag "1"
1778      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
1779      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
1780        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
1781          eOneView(i)=i+1.0;
1782      }      }
1783      values.push_back(eOne.getView());      values.push_back(eOneView);
1784    
1785      // value for tag "2"      // value for tag "2"
1786      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
1787      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
1788        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
1789          eTwoView(i)=i+2.0;
1790      }      }
1791      values.push_back(eTwo.getView());      values.push_back(eTwoView);
1792    
1793      // value for tag "3"      // value for tag "3"
1794      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
1795      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
1796        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
1797          eThreeView(i)=i+3.0;
1798      }      }
1799      values.push_back(eThree.getView());      values.push_back(eThreeView);
1800    
1801      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
1802    
# Line 1986  void DataTaggedTestCase::testAddTaggedVa Line 1807  void DataTaggedTestCase::testAddTaggedVa
1807    
1808      values.clear();      values.clear();
1809      // value for tags "4", "5" and "6"      // value for tags "4", "5" and "6"
1810      DataArray eFour(myView);      DataArrayView::ValueType eFourData(viewData);
1811      for (int i=0;i<eFour.getView().getShape()[0];i++) {      DataArrayView eFourView(eFourData, viewShape);
1812        eFour.getView()(i)=i+4.0;      for (int i=0;i<eFourView.getShape()[0];i++) {
1813          eFourView(i)=i+4.0;
1814      }      }
1815      values.push_back(eFour.getView());      values.push_back(eFourView);
1816    
1817      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values);
1818    
# Line 2003  void DataTaggedTestCase::testAddTaggedVa Line 1825  void DataTaggedTestCase::testAddTaggedVa
1825      assert(myData.getLength()==21);      assert(myData.getLength()==21);
1826    
1827      DataArrayView myDataView = myData.getDataPointByTag(4);      DataArrayView myDataView = myData.getDataPointByTag(4);
1828      assert(myDataView==eFour.getView());      assert(myDataView==eFourView);
1829      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1830      assert(myDataView.getOffset()==12);      assert(myDataView.getOffset()==12);
1831      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2014  void DataTaggedTestCase::testAddTaggedVa Line 1836  void DataTaggedTestCase::testAddTaggedVa
1836      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1837    
1838      myDataView = myData.getDataPointByTag(5);      myDataView = myData.getDataPointByTag(5);
1839      assert(myDataView==eFour.getView());      assert(myDataView==eFourView);
1840      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1841      assert(myDataView.getOffset()==15);      assert(myDataView.getOffset()==15);
1842      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2025  void DataTaggedTestCase::testAddTaggedVa Line 1847  void DataTaggedTestCase::testAddTaggedVa
1847      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1848    
1849      myDataView = myData.getDataPointByTag(6);      myDataView = myData.getDataPointByTag(6);
1850      assert(myDataView==eFour.getView());      assert(myDataView==eFourView);
1851      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1852      assert(myDataView.getOffset()==18);      assert(myDataView.getOffset()==18);
1853      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2080  void DataTaggedTestCase::testAddTaggedVa Line 1902  void DataTaggedTestCase::testAddTaggedVa
1902      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
1903    
1904      // value for tag "1"      // value for tag "1"
1905      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
1906      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
1907        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
1908          eOneView(i)=i+1.0;
1909      }      }
1910      values.push_back(eOne.getView());      values.push_back(eOneView);
1911    
1912      // value for tag "2"      // value for tag "2"
1913      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
1914      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
1915        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
1916          eTwoView(i)=i+2.0;
1917      }      }
1918      values.push_back(eTwo.getView());      values.push_back(eTwoView);
1919    
1920      // value for tag "3"      // value for tag "3"
1921      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
1922      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
1923        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
1924          eThreeView(i)=i+3.0;
1925      }      }
1926      values.push_back(eThree.getView());      values.push_back(eThreeView);
1927    
1928      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
1929    
# Line 2110  void DataTaggedTestCase::testAddTaggedVa Line 1935  void DataTaggedTestCase::testAddTaggedVa
1935      values.clear();      values.clear();
1936    
1937      // value for tag "4"      // value for tag "4"
1938      DataArray eFour(myView);      DataArrayView::ValueType eFourData(viewData);
1939      for (int i=0;i<eFour.getView().getShape()[0];i++) {      DataArrayView eFourView(eFourData, viewShape);
1940        eFour.getView()(i)=i+4.0;      for (int i=0;i<eFourView.getShape()[0];i++) {
1941          eFourView(i)=i+4.0;
1942      }      }
1943      values.push_back(eFour.getView());      values.push_back(eFourView);
1944    
1945      // value for tag "5"      // value for tag "5"
1946      DataArray eFive(myView);      DataArrayView::ValueType eFiveData(viewData);
1947      for (int i=0;i<eFive.getView().getShape()[0];i++) {      DataArrayView eFiveView(eFiveData, viewShape);
1948        eFive.getView()(i)=i+5.0;      for (int i=0;i<eFiveView.getShape()[0];i++) {
1949          eFiveView(i)=i+5.0;
1950      }      }
1951      values.push_back(eFive.getView());      values.push_back(eFiveView);
1952    
1953      // value for tag "6"      // value for tag "6"
1954      DataArray eSix(myView);      DataArrayView::ValueType eSixData(viewData);
1955      for (int i=0;i<eSix.getView().getShape()[0];i++) {      DataArrayView eSixView(eSixData, viewShape);
1956        eSix.getView()(i)=i+6.0;      for (int i=0;i<eSixView.getShape()[0];i++) {
1957          eSixView(i)=i+6.0;
1958      }      }
1959      values.push_back(eSix.getView());      values.push_back(eSixView);
1960    
1961      myData.addTaggedValues(keys,values);      myData.addTaggedValues(keys,values);
1962    
# Line 2141  void DataTaggedTestCase::testAddTaggedVa Line 1969  void DataTaggedTestCase::testAddTaggedVa
1969      assert(myData.getLength()==21);      assert(myData.getLength()==21);
1970    
1971      DataArrayView myDataView = myData.getDataPointByTag(4);      DataArrayView myDataView = myData.getDataPointByTag(4);
1972      assert(myDataView==eFour.getView());      assert(myDataView==eFourView);
1973      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1974      assert(myDataView.getOffset()==12);      assert(myDataView.getOffset()==12);
1975      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2152  void DataTaggedTestCase::testAddTaggedVa Line 1980  void DataTaggedTestCase::testAddTaggedVa
1980      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1981    
1982      myDataView = myData.getDataPointByTag(5);      myDataView = myData.getDataPointByTag(5);
1983      assert(myDataView==eFive.getView());      assert(myDataView==eFiveView);
1984      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1985      assert(myDataView.getOffset()==15);      assert(myDataView.getOffset()==15);
1986      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2163  void DataTaggedTestCase::testAddTaggedVa Line 1991  void DataTaggedTestCase::testAddTaggedVa
1991      assert(myDataView(2)==7);      assert(myDataView(2)==7);
1992    
1993      myDataView = myData.getDataPointByTag(6);      myDataView = myData.getDataPointByTag(6);
1994      assert(myDataView==eSix.getView());      assert(myDataView==eSixView);
1995      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
1996      assert(myDataView.getOffset()==18);      assert(myDataView.getOffset()==18);
1997      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2224  void DataTaggedTestCase::testSetTaggedVa Line 2052  void DataTaggedTestCase::testSetTaggedVa
2052      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
2053    
2054      // value for tag "1"      // value for tag "1"
2055      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
2056      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
2057        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
2058          eOneView(i)=i+1.0;
2059      }      }
2060      values.push_back(eOne.getView());      values.push_back(eOneView);
2061    
2062      // value for tag "2"      // value for tag "2"
2063      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
2064      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
2065        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
2066          eTwoView(i)=i+2.0;
2067      }      }
2068      values.push_back(eTwo.getView());      values.push_back(eTwoView);
2069    
2070      // value for tag "3"      // value for tag "3"
2071      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
2072      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
2073        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
2074          eThreeView(i)=i+3.0;
2075      }      }
2076      values.push_back(eThree.getView());      values.push_back(eThreeView);
2077    
2078      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
2079    
2080      // new value for tag "2"      // new value for tag "2"
2081      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      for (int i=0;i<eTwoView.getShape()[0];i++) {
2082        eTwo.getView()(i)=i+5.0;        eTwoView(i)=i+5.0;
2083      }      }
2084    
2085      myData.setTaggedValue(2,eTwo.getView());      myData.setTaggedValue(2,eTwoView);
2086    
2087      assert(myData.isCurrentTag(2));      assert(myData.isCurrentTag(2));
2088    
# Line 2260  void DataTaggedTestCase::testSetTaggedVa Line 2091  void DataTaggedTestCase::testSetTaggedVa
2091      assert(myData.getLength()==12);      assert(myData.getLength()==12);
2092    
2093      DataArrayView myDataView = myData.getDataPointByTag(2);      DataArrayView myDataView = myData.getDataPointByTag(2);
2094      assert(myDataView==eTwo.getView());      assert(myDataView==eTwoView);
2095      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2096      assert(myDataView.getOffset()==6);      assert(myDataView.getOffset()==6);
2097      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2466  void DataTaggedTestCase::testAll() { Line 2297  void DataTaggedTestCase::testAll() {
2297      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
2298    
2299      // value for tag "1"      // value for tag "1"
2300      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
2301      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
2302        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
2303          eOneView(i)=i+1.0;
2304      }      }
2305      values.push_back(eOne.getView());      values.push_back(eOneView);
2306    
2307      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
2308    
# Line 2497  void DataTaggedTestCase::testAll() { Line 2329  void DataTaggedTestCase::testAll() {
2329      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
2330    
2331      DataArrayView myDataView = myData.getDataPoint(0,0);      DataArrayView myDataView = myData.getDataPoint(0,0);
2332      assert(myDataView==eOne.getView());      assert(myDataView==eOneView);
2333      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2334      assert(myDataView.getOffset()==3);      assert(myDataView.getOffset()==3);
2335      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2508  void DataTaggedTestCase::testAll() { Line 2340  void DataTaggedTestCase::testAll() {
2340      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2341    
2342      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
2343      assert(myDataView==eOne.getView());      assert(myDataView==eOneView);
2344      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2345      assert(myDataView.getOffset()==3);      assert(myDataView.getOffset()==3);
2346      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2582  void DataTaggedTestCase::testAll() { Line 2414  void DataTaggedTestCase::testAll() {
2414      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
2415    
2416      // value for tag "1"      // value for tag "1"
2417      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
2418      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
2419        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
2420          eOneView(i)=i+1.0;
2421      }      }
2422      values.push_back(eOne.getView());      values.push_back(eOneView);
2423    
2424      // value for tag "2"      // value for tag "2"
2425      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
2426      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
2427        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
2428          eTwoView(i)=i+2.0;
2429      }      }
2430      values.push_back(eTwo.getView());      values.push_back(eTwoView);
2431    
2432      // value for tag "3"      // value for tag "3"
2433      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
2434      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
2435        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
2436          eThreeView(i)=i+3.0;
2437      }      }
2438      values.push_back(eThree.getView());      values.push_back(eThreeView);
2439    
2440      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
2441    
# Line 2629  void DataTaggedTestCase::testAll() { Line 2464  void DataTaggedTestCase::testAll() {
2464      assert(myData.getPointOffset(0,0)==3);      assert(myData.getPointOffset(0,0)==3);
2465    
2466      DataArrayView myDataView = myData.getDataPoint(0,0);      DataArrayView myDataView = myData.getDataPoint(0,0);
2467      assert(myDataView==eOne.getView());      assert(myDataView==eOneView);
2468      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2469      assert(myDataView.getOffset()==3);      assert(myDataView.getOffset()==3);
2470      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2640  void DataTaggedTestCase::testAll() { Line 2475  void DataTaggedTestCase::testAll() {
2475      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2476    
2477      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
2478      assert(myDataView==eOne.getView());      assert(myDataView==eOneView);
2479      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2480      assert(myDataView.getOffset()==3);      assert(myDataView.getOffset()==3);
2481      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2675  void DataTaggedTestCase::testAll() { Line 2510  void DataTaggedTestCase::testAll() {
2510    
2511      // Test data-points held for remaining tags      // Test data-points held for remaining tags
2512      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
2513      assert(myDataView==eTwo.getView());      assert(myDataView==eTwoView);
2514      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2515      assert(myDataView.getOffset()==6);      assert(myDataView.getOffset()==6);
2516      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2686  void DataTaggedTestCase::testAll() { Line 2521  void DataTaggedTestCase::testAll() {
2521      assert(myDataView(2)==4);      assert(myDataView(2)==4);
2522    
2523      myDataView = myData.getDataPointByTag(3);      myDataView = myData.getDataPointByTag(3);
2524      assert(myDataView==eThree.getView());      assert(myDataView==eThreeView);
2525      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2526      assert(myDataView.getOffset()==9);      assert(myDataView.getOffset()==9);
2527      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2747  void DataTaggedTestCase::testCopyConstru Line 2582  void DataTaggedTestCase::testCopyConstru
2582      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
2583    
2584      // value for tag "1"      // value for tag "1"
2585      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
2586      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
2587        eOne.getView()(i)=i+1.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
2588          eOneView(i)=i+1.0;
2589      }      }
2590      values.push_back(eOne.getView());      values.push_back(eOneView);
2591    
2592      // value for tag "2"      // value for tag "2"
2593      DataArray eTwo(myView);      DataArrayView::ValueType eTwoData(viewData);
2594      for (int i=0;i<eTwo.getView().getShape()[0];i++) {      DataArrayView eTwoView(eTwoData, viewShape);
2595        eTwo.getView()(i)=i+2.0;      for (int i=0;i<eTwoView.getShape()[0];i++) {
2596          eTwoView(i)=i+2.0;
2597      }      }
2598      values.push_back(eTwo.getView());      values.push_back(eTwoView);
2599    
2600      // value for tag "3"      // value for tag "3"
2601      DataArray eThree(myView);      DataArrayView::ValueType eThreeData(viewData);
2602      for (int i=0;i<eThree.getView().getShape()[0];i++) {      DataArrayView eThreeView(eThreeData, viewShape);
2603        eThree.getView()(i)=i+3.0;      for (int i=0;i<eThreeView.getShape()[0];i++) {
2604          eThreeView(i)=i+3.0;
2605      }      }
2606      values.push_back(eThree.getView());      values.push_back(eThreeView);
2607    
2608      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
2609    
# Line 2796  void DataTaggedTestCase::testCopyConstru Line 2634  void DataTaggedTestCase::testCopyConstru
2634      assert(myDataCopy.getPointOffset(0,0)==3);      assert(myDataCopy.getPointOffset(0,0)==3);
2635    
2636      DataArrayView myDataView = myDataCopy.getDataPoint(0,0);      DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
2637      assert(myDataView==eOne.getView());      assert(myDataView==eOneView);
2638      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2639      assert(myDataView.getOffset()==3);      assert(myDataView.getOffset()==3);
2640      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2807  void DataTaggedTestCase::testCopyConstru Line 2645  void DataTaggedTestCase::testCopyConstru
2645      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2646    
2647      myDataView = myDataCopy.getDataPointByTag(1);      myDataView = myDataCopy.getDataPointByTag(1);
2648      assert(myDataView==eOne.getView());      assert(myDataView==eOneView);
2649      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2650      assert(myDataView.getOffset()==3);      assert(myDataView.getOffset()==3);
2651      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2842  void DataTaggedTestCase::testCopyConstru Line 2680  void DataTaggedTestCase::testCopyConstru
2680    
2681      // Test data-points held for remaining tags      // Test data-points held for remaining tags
2682      myDataView = myDataCopy.getDataPointByTag(2);      myDataView = myDataCopy.getDataPointByTag(2);
2683      assert(myDataView==eTwo.getView());      assert(myDataView==eTwoView);
2684      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2685      assert(myDataView.getOffset()==6);      assert(myDataView.getOffset()==6);
2686      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 2853  void DataTaggedTestCase::testCopyConstru Line 2691  void DataTaggedTestCase::testCopyConstru
2691      assert(myDataView(2)==4);      assert(myDataView(2)==4);
2692    
2693      myDataView = myDataCopy.getDataPointByTag(3);      myDataView = myDataCopy.getDataPointByTag(3);
2694      assert(myDataView==eThree.getView());      assert(myDataView==eThreeView);
2695      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2696      assert(myDataView.getOffset()==9);      assert(myDataView.getOffset()==9);
2697      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
# Line 3181  void DataTaggedTestCase::testGetSlice() Line 3019  void DataTaggedTestCase::testGetSlice()
3019      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
3020    
3021      // value for tag "1"      // value for tag "1"
3022      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
3023      eOne.getView()()=1.0;      DataArrayView eOneView(eOneData, viewShape);
3024      values.push_back(eOne.getView());      eOneView()=1.0;
3025        values.push_back(eOneView);
3026    
3027      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
3028    
# Line 3241  void DataTaggedTestCase::testGetSlice() Line 3080  void DataTaggedTestCase::testGetSlice()
3080      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
3081    
3082      // value for tag "1"      // value for tag "1"
3083      DataArray eOne(myView);      DataArrayView::ValueType eOneData(viewData);
3084      for (int i=0;i<eOne.getView().getShape()[0];i++) {      DataArrayView eOneView(eOneData, viewShape);
3085        eOne.getView()(i)=i+3.0;      for (int i=0;i<eOneView.getShape()[0];i++) {
3086          eOneView(i)=i+3.0;
3087      }      }
3088      values.push_back(eOne.getView());      values.push_back(eOneView);
3089    
3090      DataTagged myData(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
3091    
# Line 3324  void DataTaggedTestCase::testGetSlice() Line 3164  void DataTaggedTestCase::testGetSlice()
3164    
3165    }    }
3166    
3167      {
3168    
3169        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
3170    
3171        DataArrayView::ShapeType viewShape;
3172        viewShape.push_back(3);
3173        viewShape.push_back(3);
3174        viewShape.push_back(3);
3175    
3176        DataTagged::TagListType keys;
3177        keys.push_back(1);
3178    
3179        DataTagged::ValueListType values;
3180    
3181        // default value
3182        DataArrayView::ValueType viewData(27);
3183        for (int i=0;i<viewData.size();i++) {
3184          viewData[i]=i;
3185        }
3186        DataArrayView myView(viewData,viewShape);
3187    
3188        // value for tag "1"
3189        DataArrayView::ValueType viewData1(27);
3190        for (int i=0;i<viewData1.size();i++) {
3191          viewData1[i]=i+27.0;
3192        }
3193        DataArrayView myView1(viewData1,viewShape);
3194        values.push_back(myView1);
3195    
3196        DataTagged myData(keys,values,myView,FunctionSpace());
3197    
3198        //cout << myData.toString() << endl;
3199    
3200        // full slice
3201    
3202        std::pair<int, int> region_element;
3203        region_element.first=0;
3204        region_element.second=3;
3205        DataArrayView::RegionType region;
3206        region.push_back(region_element);
3207        region.push_back(region_element);
3208        region.push_back(region_element);
3209    
3210        DataAbstract* slicedDefault = myData.getSlice(region);
3211    
3212        //cout << slicedDefault->toString() << endl;
3213    
3214        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3215    
3216        assert(myDataSliced->getTagLookup().size()==1);
3217    
3218        assert(myDataSliced->getLength()==54);
3219    
3220        DataArrayView myDataView = myDataSliced->getDefaultValue();
3221        assert(!myDataView.isEmpty());
3222        assert(myDataView.getOffset()==0);
3223        assert(myDataView.getRank()==3);
3224        assert(myDataView.noValues()==27);
3225        assert(myDataView.getShape().size()==3);
3226    
3227        myDataView = myDataSliced->getDataPointByTag(1);
3228        assert(!myDataView.isEmpty());
3229        assert(myDataView.getOffset()==27);
3230        assert(myDataView.getRank()==3);
3231        assert(myDataView.noValues()==27);
3232        assert(myDataView.getShape().size()==3);
3233    
3234        // rank 1 slice
3235    
3236        region.clear();
3237        region.push_back(region_element);
3238        region_element.second=0;
3239        region.push_back(region_element);
3240        region.push_back(region_element);
3241    
3242        slicedDefault = myData.getSlice(region);
3243    
3244        //cout << slicedDefault->toString() << endl;
3245    
3246        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3247    
3248        assert(myDataSliced->getTagLookup().size()==1);
3249    
3250        assert(myDataSliced->getLength()==6);
3251    
3252        myDataView = myDataSliced->getDefaultValue();
3253        assert(!myDataView.isEmpty());
3254        assert(myDataView.getOffset()==0);
3255        assert(myDataView.getRank()==1);
3256        assert(myDataView.noValues()==3);
3257        assert(myDataView.getShape().size()==1);
3258        assert(myDataView(0)==0);
3259        assert(myDataView(1)==1);
3260        assert(myDataView(2)==2);
3261    
3262        myDataView = myDataSliced->getDataPointByTag(1);
3263        assert(!myDataView.isEmpty());
3264        assert(myDataView.getOffset()==3);
3265        assert(myDataView.getRank()==1);
3266        assert(myDataView.noValues()==3);
3267        assert(myDataView.getShape().size()==1);
3268        assert(myDataView(0)==27);
3269        assert(myDataView(1)==28);
3270        assert(myDataView(2)==29);
3271    
3272        // scalar slice
3273    
3274        region_element.first=1;
3275        region_element.second=1;
3276        region.clear();
3277        region.push_back(region_element);
3278        region.push_back(region_element);
3279        region.push_back(region_element);
3280    
3281        slicedDefault = myData.getSlice(region);
3282    
3283        //cout << slicedDefault->toString() << endl;
3284    
3285        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3286    
3287        assert(myDataSliced->getTagLookup().size()==1);
3288    
3289        assert(myDataSliced->getLength()==2);
3290    
3291        myDataView = myDataSliced->getDefaultValue();
3292        assert(!myDataView.isEmpty());
3293        assert(myDataView.getOffset()==0);
3294        assert(myDataView.getRank()==0);
3295        assert(myDataView.noValues()==1);
3296        assert(myDataView.getShape().size()==0);
3297        assert(myDataView()==13);
3298    
3299        myDataView = myDataSliced->getDataPointByTag(1);
3300        assert(!myDataView.isEmpty());
3301        assert(myDataView.getOffset()==1);
3302        assert(myDataView.getRank()==0);
3303        assert(myDataView.noValues()==1);
3304        assert(myDataView.getShape().size()==0);
3305        assert(myDataView()==40);
3306    
3307      }
3308    
3309      {
3310    
3311        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
3312    
3313        DataTagged::TagListType keys;
3314        keys.push_back(1);
3315        keys.push_back(2);
3316        keys.push_back(3);
3317    
3318        DataTagged::ValueListType values;
3319    
3320        DataArrayView::ShapeType viewShape;
3321    
3322        // default value
3323        DataArrayView::ValueType viewData(1);
3324        viewData[0]=0.0;
3325        DataArrayView myView(viewData,viewShape);
3326    
3327        // value for tag "1"
3328        DataArrayView::ValueType eOneData(viewData);
3329        DataArrayView eOneView(eOneData, viewShape);
3330        eOneView()=1.0;
3331        values.push_back(eOneView);
3332    
3333        // value for tag "2"
3334        DataArrayView::ValueType eTwoData(viewData);
3335        DataArrayView eTwoView(eTwoData, viewShape);
3336        eTwoView()=2.0;
3337        values.push_back(eTwoView);
3338    
3339        // value for tag "3"
3340        DataArrayView::ValueType eThreeData(viewData);
3341        DataArrayView eThreeView(eThreeData, viewShape);
3342        eThreeView()=3.0;
3343        values.push_back(eThreeView);
3344    
3345        DataTagged myData(keys,values,myView,FunctionSpace());
3346    
3347        // cout << myData.toString() << endl;
3348    
3349        // full slice
3350    
3351        DataArrayView::RegionType region;
3352    
3353        DataAbstract* slicedDefault = myData.getSlice(region);
3354    
3355        //cout << slicedDefault->toString() << endl;
3356    
3357        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3358    
3359        assert(myDataSliced->getTagLookup().size()==3);
3360    
3361        assert(myDataSliced->getLength()==4);
3362    
3363        DataArrayView myDataView = myDataSliced->getDefaultValue();
3364        assert(!myDataView.isEmpty());
3365        assert(myDataView.getOffset()==0);
3366        assert(myDataView.getRank()==0);
3367        assert(myDataView.noValues()==1);
3368        assert(myDataView.getShape().size()==0);
3369        assert(myDataView()==0);
3370    
3371        myDataView = myDataSliced->getDataPointByTag(1);
3372        assert(!myDataView.isEmpty());
3373        assert(myDataView.getOffset()==1);
3374        assert(myDataView.getRank()==0);
3375        assert(myDataView.noValues()==1);
3376        assert(myDataView.getShape().size()==0);
3377        assert(myDataView()==1);
3378    
3379        myDataView = myDataSliced->getDataPointByTag(2);
3380        assert(!myDataView.isEmpty());
3381        assert(myDataView.getOffset()==2);
3382        assert(myDataView.getRank()==0);
3383        assert(myDataView.noValues()==1);
3384        assert(myDataView.getShape().size()==0);
3385        assert(myDataView()==2);
3386    
3387        myDataView = myDataSliced->getDataPointByTag(3);
3388        assert(!myDataView.isEmpty());
3389        assert(myDataView.getOffset()==3);
3390        assert(myDataView.getRank()==0);
3391        assert(myDataView.noValues()==1);
3392        assert(myDataView.getShape().size()==0);
3393        assert(myDataView()==3);
3394    
3395      }
3396    
3397      {
3398    
3399        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
3400    
3401        DataArrayView::ShapeType viewShape;
3402        viewShape.push_back(3);
3403    
3404        DataTagged::TagListType keys;
3405        keys.push_back(1);
3406        keys.push_back(2);
3407        keys.push_back(3);
3408    
3409        DataTagged::ValueListType values;
3410    
3411        // default value
3412        DataArrayView::ValueType viewData(3);
3413        for (int i=0;i<viewShape[0];i++) {
3414          viewData[i]=i;
3415        }
3416        DataArrayView myView(viewData,viewShape);
3417    
3418        // value for tag "1"
3419        DataArrayView::ValueType eOneData(viewData);
3420        DataArrayView eOneView(eOneData, viewShape);
3421        for (int i=0;i<eOneView.getShape()[0];i++) {
3422          eOneView(i)=i+3.0;
3423        }
3424        values.push_back(eOneView);
3425    
3426        // value for tag "2"
3427        DataArrayView::ValueType eTwoData(viewData);
3428        DataArrayView eTwoView(eTwoData, viewShape);
3429        for (int i=0;i<eTwoView.getShape()[0];i++) {
3430          eTwoView(i)=i+6.0;
3431        }
3432        values.push_back(eTwoView);
3433    
3434        // value for tag "3"
3435        DataArrayView::ValueType eThreeData(viewData);
3436        DataArrayView eThreeView(eThreeData, viewShape);
3437        for (int i=0;i<eThreeView.getShape()[0];i++) {
3438          eThreeView(i)=i+9.0;
3439        }
3440        values.push_back(eThreeView);
3441    
3442        DataTagged myData(keys,values,myView,FunctionSpace());
3443    
3444        //cout << myData.toString() << endl;
3445    
3446        // full slice
3447    
3448        std::pair<int, int> region_element;
3449        region_element.first=0;
3450        region_element.second=3;
3451        DataArrayView::RegionType region;
3452        region.push_back(region_element);
3453    
3454        DataAbstract* slicedDefault = myData.getSlice(region);
3455    
3456        //cout << slicedDefault->toString() << endl;
3457    
3458        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3459    
3460        assert(myDataSliced->getTagLookup().size()==3);
3461    
3462        assert(myDataSliced->getLength()==12);
3463    
3464        DataArrayView myDataView = myDataSliced->getDefaultValue();
3465        assert(!myDataView.isEmpty());
3466        assert(myDataView.getOffset()==0);
3467        assert(myDataView.getRank()==1);
3468        assert(myDataView.noValues()==3);
3469        assert(myDataView.getShape().size()==1);
3470        assert(myDataView(0)==0);
3471        assert(myDataView(1)==1);
3472        assert(myDataView(2)==2);
3473    
3474        myDataView = myDataSliced->getDataPointByTag(1);
3475        assert(!myDataView.isEmpty());
3476        assert(myDataView.getOffset()==3);
3477        assert(myDataView.getRank()==1);
3478        assert(myDataView.noValues()==3);
3479        assert(myDataView.getShape().size()==1);
3480        assert(myDataView(0)==3);
3481        assert(myDataView(1)==4);
3482        assert(myDataView(2)==5);
3483    
3484        myDataView = myDataSliced->getDataPointByTag(2);
3485        assert(!myDataView.isEmpty());
3486        assert(myDataView.getOffset()==6);
3487        assert(myDataView.getRank()==1);
3488        assert(myDataView.noValues()==3);
3489        assert(myDataView.getShape().size()==1);
3490        assert(myDataView(0)==6);
3491        assert(myDataView(1)==7);
3492        assert(myDataView(2)==8);
3493    
3494        myDataView = myDataSliced->getDataPointByTag(3);
3495        assert(!myDataView.isEmpty());
3496        assert(myDataView.getOffset()==9);
3497        assert(myDataView.getRank()==1);
3498        assert(myDataView.noValues()==3);
3499        assert(myDataView.getShape().size()==1);
3500        assert(myDataView(0)==9);
3501        assert(myDataView(1)==10);
3502        assert(myDataView(2)==11);
3503    
3504        // scalar slice
3505    
3506        region.clear();
3507        region_element.first=1;
3508        region_element.second=1;
3509        region.push_back(region_element);
3510    
3511        slicedDefault = myData.getSlice(region);
3512    
3513        //cout << slicedDefault->toString() << endl;
3514    
3515        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3516    
3517        assert(myDataSliced->getTagLookup().size()==3);
3518    
3519        assert(myDataSliced->getLength()==4);
3520    
3521        myDataView = myDataSliced->getDefaultValue();
3522        assert(!myDataView.isEmpty());
3523        assert(myDataView.getOffset()==0);
3524        assert(myDataView.getRank()==0);
3525        assert(myDataView.noValues()==1);
3526        assert(myDataView.getShape().size()==0);
3527        assert(myDataView()==1);
3528    
3529        myDataView = myDataSliced->getDataPointByTag(1);
3530        assert(!myDataView.isEmpty());
3531        assert(myDataView.getOffset()==1);
3532        assert(myDataView.getRank()==0);
3533        assert(myDataView.noValues()==1);
3534        assert(myDataView.getShape().size()==0);
3535        assert(myDataView()==4);
3536    
3537        myDataView = myDataSliced->getDataPointByTag(2);
3538        assert(!myDataView.isEmpty());
3539        assert(myDataView.getOffset()==2);
3540        assert(myDataView.getRank()==0);
3541        assert(myDataView.noValues()==1);
3542        assert(myDataView.getShape().size()==0);
3543        assert(myDataView()==7);
3544    
3545        myDataView = myDataSliced->getDataPointByTag(3);
3546        assert(!myDataView.isEmpty());
3547        assert(myDataView.getOffset()==3);
3548        assert(myDataView.getRank()==0);
3549        assert(myDataView.noValues()==1);
3550        assert(myDataView.getShape().size()==0);
3551        assert(myDataView()==10);
3552    
3553      }
3554    
3555      {
3556    
3557        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
3558    
3559        DataArrayView::ShapeType viewShape;
3560        viewShape.push_back(3);
3561        viewShape.push_back(3);
3562        viewShape.push_back(3);
3563    
3564        DataTagged::TagListType keys;
3565        keys.push_back(1);
3566        keys.push_back(2);
3567        keys.push_back(3);
3568    
3569        DataTagged::ValueListType values;
3570    
3571        // default value
3572        DataArrayView::ValueType viewData(27);
3573        for (int i=0;i<viewData.size();i++) {
3574          viewData[i]=i;
3575        }
3576        DataArrayView myView(viewData,viewShape);
3577    
3578        // value for tag "1"
3579        DataArrayView::ValueType viewData1(27);
3580        for (int i=0;i<viewData1.size();i++) {
3581          viewData1[i]=i+27.0;
3582        }
3583        DataArrayView myView1(viewData1,viewShape);
3584        values.push_back(myView1);
3585    
3586        // value for tag "2"
3587        DataArrayView::ValueType viewData2(27);
3588        for (int i=0;i<viewData2.size();i++) {
3589          viewData2[i]=i+54.0;
3590        }
3591        DataArrayView myView2(viewData2,viewShape);
3592        values.push_back(myView2);
3593    
3594        // value for tag "3"
3595        DataArrayView::ValueType viewData3(27);
3596        for (int i=0;i<viewData3.size();i++) {
3597          viewData3[i]=i+81.0;
3598        }
3599        DataArrayView myView3(viewData3,viewShape);
3600        values.push_back(myView3);
3601    
3602        DataTagged myData(keys,values,myView,FunctionSpace());
3603    
3604        //cout << myData.toString() << endl;
3605    
3606        // full slice
3607    
3608        std::pair<int, int> region_element;
3609        region_element.first=0;
3610        region_element.second=3;
3611        DataArrayView::RegionType region;
3612        region.push_back(region_element);
3613        region.push_back(region_element);
3614        region.push_back(region_element);
3615    
3616        DataAbstract* slicedDefault = myData.getSlice(region);
3617    
3618        //cout << slicedDefault->toString() << endl;
3619    
3620        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3621    
3622        assert(myDataSliced->getTagLookup().size()==3);
3623    
3624        assert(myDataSliced->getLength()==108);
3625    
3626        DataArrayView myDataView = myDataSliced->getDefaultValue();
3627        assert(!myDataView.isEmpty());
3628        assert(myDataView.getOffset()==0);
3629        assert(myDataView.getRank()==3);
3630        assert(myDataView.noValues()==27);
3631        assert(myDataView.getShape().size()==3);
3632    
3633        myDataView = myDataSliced->getDataPointByTag(1);
3634        assert(!myDataView.isEmpty());
3635        assert(myDataView.getOffset()==27);
3636        assert(myDataView.getRank()==3);
3637        assert(myDataView.noValues()==27);
3638        assert(myDataView.getShape().size()==3);
3639    
3640        myDataView = myDataSliced->getDataPointByTag(2);
3641        assert(!myDataView.isEmpty());
3642        assert(myDataView.getOffset()==54);
3643        assert(myDataView.getRank()==3);
3644        assert(myDataView.noValues()==27);
3645        assert(myDataView.getShape().size()==3);
3646    
3647        myDataView = myDataSliced->getDataPointByTag(3);
3648        assert(!myDataView.isEmpty());
3649        assert(myDataView.getOffset()==81);
3650        assert(myDataView.getRank()==3);
3651        assert(myDataView.noValues()==27);
3652        assert(myDataView.getShape().size()==3);
3653    
3654        // rank 1 slice
3655    
3656        region.clear();
3657        region.push_back(region_element);
3658        region_element.second=0;
3659        region.push_back(region_element);
3660        region.push_back(region_element);
3661    
3662        slicedDefault = myData.getSlice(region);
3663    
3664        // cout << slicedDefault->toString() << endl;
3665    
3666        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3667    
3668        assert(myDataSliced->getTagLookup().size()==3);
3669    
3670        assert(myDataSliced->getLength()==12);
3671    
3672        myDataView = myDataSliced->getDefaultValue();
3673        assert(!myDataView.isEmpty());
3674        assert(myDataView.getOffset()==0);
3675        assert(myDataView.getRank()==1);
3676        assert(myDataView.noValues()==3);
3677        assert(myDataView.getShape().size()==1);
3678        assert(myDataView(0)==0);
3679        assert(myDataView(1)==1);
3680        assert(myDataView(2)==2);
3681    
3682        myDataView = myDataSliced->getDataPointByTag(1);
3683        assert(!myDataView.isEmpty());
3684        assert(myDataView.getOffset()==3);
3685        assert(myDataView.getRank()==1);
3686        assert(myDataView.noValues()==3);
3687        assert(myDataView.getShape().size()==1);
3688        assert(myDataView(0)==27);
3689        assert(myDataView(1)==28);
3690        assert(myDataView(2)==29);
3691    
3692        myDataView = myDataSliced->getDataPointByTag(2);
3693        assert(!myDataView.isEmpty());
3694        assert(myDataView.getOffset()==6);
3695        assert(myDataView.getRank()==1);
3696        assert(myDataView.noValues()==3);
3697        assert(myDataView.getShape().size()==1);
3698        assert(myDataView(0)==54);
3699        assert(myDataView(1)==55);
3700        assert(myDataView(2)==56);
3701    
3702        myDataView = myDataSliced->getDataPointByTag(3);
3703        assert(!myDataView.isEmpty());
3704        assert(myDataView.getOffset()==9);
3705        assert(myDataView.getRank()==1);
3706        assert(myDataView.noValues()==3);
3707        assert(myDataView.getShape().size()==1);
3708        assert(myDataView(0)==81);
3709        assert(myDataView(1)==82);
3710        assert(myDataView(2)==83);
3711    
3712        // scalar slice
3713    
3714        region_element.first=1;
3715        region_element.second=1;
3716        region.clear();
3717        region.push_back(region_element);
3718        region.push_back(region_element);
3719        region.push_back(region_element);
3720    
3721        slicedDefault = myData.getSlice(region);
3722    
3723        //cout << slicedDefault->toString() << endl;
3724    
3725        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3726    
3727        assert(myDataSliced->getTagLookup().size()==3);
3728    
3729        assert(myDataSliced->getLength()==4);
3730    
3731        myDataView = myDataSliced->getDefaultValue();
3732        assert(!myDataView.isEmpty());
3733        assert(myDataView.getOffset()==0);
3734        assert(myDataView.getRank()==0);
3735        assert(myDataView.noValues()==1);
3736        assert(myDataView.getShape().size()==0);
3737        assert(myDataView()==13);
3738    
3739        myDataView = myDataSliced->getDataPointByTag(1);
3740        assert(!myDataView.isEmpty());
3741        assert(myDataView.getOffset()==1);
3742        assert(myDataView.getRank()==0);
3743        assert(myDataView.noValues()==1);
3744        assert(myDataView.getShape().size()==0);
3745        assert(myDataView()==40);
3746    
3747        myDataView = myDataSliced->getDataPointByTag(2);
3748        assert(!myDataView.isEmpty());
3749        assert(myDataView.getOffset()==2);
3750        assert(myDataView.getRank()==0);
3751        assert(myDataView.noValues()==1);
3752        assert(myDataView.getShape().size()==0);
3753        assert(myDataView()==67);
3754    
3755        myDataView = myDataSliced->getDataPointByTag(3);
3756        assert(!myDataView.isEmpty());
3757        assert(myDataView.getOffset()==3);
3758        assert(myDataView.getRank()==0);
3759        assert(myDataView.noValues()==1);
3760        assert(myDataView.getShape().size()==0);
3761        assert(myDataView()==94);
3762    
3763      }
3764    
3765  }  }
3766    
3767  void DataTaggedTestCase::testSetSlice() {  void DataTaggedTestCase::testSetSlice() {
# Line 3332  void DataTaggedTestCase::testSetSlice() Line 3770  void DataTaggedTestCase::testSetSlice()
3770    
3771    {    {
3772    
3773        cout << "\tTest slicing default DataTagged." << endl;
3774    
3775        DataTagged myData1;
3776        DataTagged myData2;
3777    
3778        DataArrayView::RegionType region;
3779    
3780        myData2.getDefaultValue()()=1.0;
3781    
3782        myData1.setSlice(&myData2, region);
3783    
3784        //cout << myData1.toString() << endl;
3785    
3786        assert(myData1.getTagLookup().size()==0);
3787    
3788        assert(myData1.getLength()==1);
3789    
3790        DataArrayView myDataView = myData1.getDefaultValue();
3791        assert(!myDataView.isEmpty());
3792        assert(myDataView.getOffset()==0);
3793        assert(myDataView.getRank()==0);
3794        assert(myDataView.noValues()==1);
3795        assert(myDataView.getShape().size()==0);
3796        assert(myDataView()==1.0);
3797    
3798      }
3799    
3800      {
3801    
3802        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
3803    
3804        DataTagged::TagListType keys;
3805    
3806        DataTagged::ValueListType values;
3807    
3808        DataArrayView::ShapeType viewShape;
3809        viewShape.push_back(3);
3810    
3811        DataArrayView::ValueType viewData1(3);
3812        for (int i=0;i<viewShape[0];i++) {
3813          viewData1[i]=i;
3814        }
3815        DataArrayView myView1(viewData1,viewShape);
3816        DataTagged myData1(keys,values,myView1,FunctionSpace());
3817    
3818        DataArrayView::ValueType viewData2(3);
3819        for (int i=0;i<viewShape[0];i++) {
3820          viewData2[i]=i+3;
3821        }
3822        DataArrayView myView2(viewData2,viewShape);
3823        DataTagged myData2(keys,values,myView2,FunctionSpace());
3824    
3825        // full slice
3826    
3827        std::pair<int, int> region_element;
3828        region_element.first=0;
3829        region_element.second=3;
3830        DataArrayView::RegionType region;
3831        region.push_back(region_element);
3832    
3833        myData1.setSlice(&myData2, region);
3834    
3835        //cout << myData1.toString() << endl;
3836    
3837        assert(myData1.getTagLookup().size()==0);
3838    
3839        assert(myData1.getLength()==3);
3840    
3841        DataArrayView myDataView = myData1.getDefaultValue();
3842        assert(!myDataView.isEmpty());
3843        assert(myDataView.getOffset()==0);
3844        assert(myDataView.getRank()==1);
3845        assert(myDataView.noValues()==3);
3846        assert(myDataView.getShape().size()==1);
3847        assert(myDataView(0)==3.0);
3848        assert(myDataView(1)==4.0);
3849        assert(myDataView(2)==5.0);
3850    
3851        // rank 1 slice
3852    
3853        viewShape.clear();
3854        viewShape.push_back(1);
3855    
3856        DataArrayView::ValueType viewData3(1);
3857        viewData3[0]=6.0;
3858        DataArrayView myView3(viewData3,viewShape);
3859        DataTagged myData3(keys,values,myView3,FunctionSpace());
3860    
3861        region.clear();
3862        region_element.first=1;
3863        region_element.second=2;
3864        region.push_back(region_element);
3865    
3866        myData1.setSlice(&myData3, region);
3867    
3868        //cout << myData1.toString() << endl;
3869    
3870        assert(myData1.getTagLookup().size()==0);
3871    
3872        assert(myData1.getLength()==3);
3873    
3874        myDataView = myData1.getDefaultValue();
3875        assert(!myDataView.isEmpty());
3876        assert(myDataView.getOffset()==0);
3877        assert(myDataView.getRank()==1);
3878        assert(myDataView.noValues()==3);
3879        assert(myDataView.getShape().size()==1);
3880        assert(myDataView(0)==3.0);
3881        assert(myDataView(1)==6.0);
3882        assert(myDataView(2)==5.0);
3883    
3884        // scalar slice
3885    
3886        region.clear();
3887        region_element.first=0;
3888        region_element.second=0;
3889        region.push_back(region_element);
3890    
3891        DataTagged myData4;
3892        myData4.getDefaultValue()()=7.0;
3893    
3894        myData1.setSlice(&myData4, region);
3895    
3896        //cout << myData3.toString() << endl;
3897    
3898        assert(myData1.getTagLookup().size()==0);
3899    
3900        assert(myData1.getLength()==3);
3901    
3902        myDataView = myData1.getDefaultValue();
3903        assert(!myDataView.isEmpty());
3904        assert(myDataView.getOffset()==0);
3905        assert(myDataView.getRank()==1);
3906        assert(myDataView.noValues()==3);
3907        assert(myDataView.getShape().size()==1);
3908        assert(myDataView(0)==7.0);
3909        assert(myDataView(1)==6.0);
3910        assert(myDataView(2)==5.0);
3911    
3912      }
3913    
3914      {
3915    
3916        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
3917    
3918        DataTagged::TagListType keys;
3919    
3920        DataTagged::ValueListType values;
3921    
3922        DataArrayView::ShapeType viewShape;
3923        viewShape.push_back(3);
3924        viewShape.push_back(3);
3925        viewShape.push_back(3);
3926    
3927        DataArrayView::ValueType viewData1(27);
3928        for (int i=0;i<viewData1.size();i++) {
3929          viewData1[i]=i;
3930        }
3931        DataArrayView myView1(viewData1,viewShape);
3932        DataTagged myData1(keys,values,myView1,FunctionSpace());
3933    
3934        DataArrayView::ValueType viewData2(27);
3935        for (int i=0;i<viewData2.size();i++) {
3936          viewData2[i]=i+27;
3937        }
3938        DataArrayView myView2(viewData2,viewShape);
3939        DataTagged myData2(keys,values,myView2,FunctionSpace());
3940    
3941        // full slice
3942    
3943        std::pair<int, int> region_element;
3944        region_element.first=0;
3945        region_element.second=3;
3946        DataArrayView::RegionType region;
3947        region.push_back(region_element);
3948        region.push_back(region_element);
3949        region.push_back(region_element);
3950    
3951        myData1.setSlice(&myData2, region);
3952    
3953        //cout << myData1.toString() << endl;
3954    
3955        assert(myData1.getTagLookup().size()==0);
3956    
3957        assert(myData1.getLength()==27);
3958    
3959        DataArrayView myDataView = myData1.getDefaultValue();
3960        assert(!myDataView.isEmpty());
3961        assert(myDataView.getOffset()==0);
3962        assert(myDataView.getRank()==3);
3963        assert(myDataView.noValues()==27);
3964        assert(myDataView.getShape().size()==3);
3965    
3966        // rank 1 slice
3967    
3968        viewShape.clear();
3969        viewShape.push_back(3);
3970    
3971        DataArrayView::ValueType viewData3(3);
3972        for (int i=0;i<viewData3.size();i++) {
3973          viewData3[i]=i+60;
3974        }
3975        DataArrayView myView3(viewData3,viewShape);
3976        DataTagged myData3(keys,values,myView3,FunctionSpace());
3977    
3978        region.clear();
3979        region.push_back(region_element);
3980        region_element.first=0;
3981        region_element.second=0;
3982        region.push_back(region_element);
3983        region.push_back(region_element);
3984    
3985        myData1.setSlice(&myData3, region);
3986    
3987        //cout << myData1.toString() << endl;
3988    
3989        assert(myData1.getTagLookup().size()==0);
3990    
3991        assert(myData1.getLength()==27);
3992    
3993        myDataView = myData1.getDefaultValue();
3994        assert(!myDataView.isEmpty());
3995        assert(myDataView.getOffset()==0);
3996        assert(myDataView.getRank()==3);
3997        assert(myDataView.noValues()==27);
3998        assert(myDataView.getShape().size()==3);
3999        assert(myDataView(0,0,0)==60.0);
4000        assert(myDataView(1,0,0)==61.0);
4001        assert(myDataView(2,0,0)==62.0);
4002    
4003        // scalar slice
4004    
4005        region.clear();
4006        region_element.first=0;
4007        region_element.second=0;
4008        region.push_back(region_element);
4009        region.push_back(region_element);
4010        region.push_back(region_element);
4011    
4012        DataTagged myData4;
4013        myData4.getDefaultValue()()=70.0;
4014    
4015        myData1.setSlice(&myData4, region);
4016    
4017        //cout << myData1.toString() << endl;
4018    
4019        assert(myData1.getTagLookup().size()==0);
4020    
4021        assert(myData1.getLength()==27);
4022    
4023        myDataView = myData1.getDefaultValue();
4024        assert(!myDataView.isEmpty());
4025        assert(myDataView.getOffset()==0);
4026        assert(myDataView.getRank()==3);
4027        assert(myDataView.noValues()==27);
4028        assert(myDataView.getShape().size()==3);
4029        assert(myDataView(0,0,0)==70.0);
4030    
4031      }
4032    
4033      {
4034    
4035        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
4036    
4037        DataTagged::TagListType keys;
4038        keys.push_back(1);
4039    
4040        DataTagged::ValueListType values;
4041    
4042        DataArrayView::ShapeType viewShape;
4043    
4044        // default value for Data1
4045        DataArrayView::ValueType viewData1(1);
4046        viewData1[0]=0.0;
4047        DataArrayView myView1(viewData1,viewShape);
4048    
4049        // value for tag "1" for Data1
4050        DataArrayView::ValueType viewData2(1);
4051        viewData2[0]=0.0;
4052        DataArrayView myView2(viewData2,viewShape);
4053        values.push_back(myView2);
4054    
4055        DataTagged myData1(keys,values,myView1,FunctionSpace());
4056    
4057        values.clear();
4058    
4059        // default value for Data2
4060        DataArrayView::ValueType viewData3(1);
4061        viewData3[0]=1.0;
4062        DataArrayView myView3(viewData3,viewShape);
4063    
4064        // value for tag "1" for Data2
4065        DataArrayView::ValueType viewData4(1);
4066        viewData4[0]=2.0;
4067        DataArrayView myView4(viewData4,viewShape);
4068        values.push_back(myView4);
4069    
4070        DataTagged myData2(keys,values,myView3,FunctionSpace());
4071    
4072        // full slice
4073    
4074        DataArrayView::RegionType region;
4075    
4076        myData1.setSlice(&myData2, region);
4077    
4078        //cout << myData1.toString() << endl;
4079    
4080        assert(myData1.getTagLookup().size()==1);
4081    
4082        assert(myData1.getLength()==2);
4083    
4084        DataArrayView myDataView = myData1.getDefaultValue();
4085        assert(!myDataView.isEmpty());
4086        assert(myDataView.getOffset()==0);
4087        assert(myDataView.getRank()==0);
4088        assert(myDataView.noValues()==1);
4089        assert(myDataView.getShape().size()==0);
4090        assert(myDataView()==1.0);
4091    
4092        myDataView = myData1.getDataPointByTag(1);
4093        assert(!myDataView.isEmpty());
4094        assert(myDataView.getOffset()==1);
4095        assert(myDataView.getRank()==0);
4096        assert(myDataView.noValues()==1);
4097        assert(myDataView.getShape().size()==0);
4098        assert(myDataView()==2.0);
4099    
4100      }
4101    
4102      {
4103    
4104        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
4105    
4106        DataTagged::TagListType keys;
4107        keys.push_back(1);
4108    
4109        DataTagged::ValueListType values;
4110    
4111        DataArrayView::ShapeType viewShape;
4112        viewShape.push_back(3);
4113    
4114        // default value for Data1
4115        DataArrayView::ValueType viewData1(3);
4116        for (int i=0;i<viewData1.size();i++) {
4117          viewData1[i]=0.0;
4118        }
4119        DataArrayView myView1(viewData1,viewShape);
4120    
4121        // value for tag "1" for Data1
4122        DataArrayView::ValueType viewData2(3);
4123        for (int i=0;i<viewData2.size();i++) {
4124          viewData2[i]=0.0;
4125        }
4126        DataArrayView myView2(viewData2,viewShape);
4127        values.push_back(myView2);
4128    
4129        DataTagged myData1(keys,values,myView1,FunctionSpace());
4130    
4131        values.clear();
4132    
4133        // default value for Data2
4134        DataArrayView::ValueType viewData3(3);
4135        for (int i=0;i<viewData3.size();i++) {
4136          viewData3[i]=1.0;
4137        }
4138        DataArrayView myView3(viewData3,viewShape);
4139    
4140        // value for tag "1" for Data2
4141        DataArrayView::ValueType viewData4(3);
4142        for (int i=0;i<viewData4.size();i++) {
4143          viewData4[i]=2.0;
4144        }
4145        DataArrayView myView4(viewData4,viewShape);
4146        values.push_back(myView4);
4147    
4148        DataTagged myData2(keys,values,myView3,FunctionSpace());
4149    
4150        // full slice
4151    
4152        std::pair<int, int> region_element;
4153        region_element.first=0;
4154        region_element.second=3;
4155        DataArrayView::RegionType region;
4156        region.push_back(region_element);
4157    
4158        myData1.setSlice(&myData2, region);
4159    
4160        //cout << myData1.toString() << endl;
4161    
4162        assert(myData1.getTagLookup().size()==1);
4163    
4164        assert(myData1.getLength()==6);
4165    
4166        DataArrayView myDataView = myData1.getDefaultValue();
4167        assert(!myDataView.isEmpty());
4168        assert(myDataView.getOffset()==0);
4169        assert(myDataView.getRank()==1);
4170        assert(myDataView.noValues()==3);
4171        assert(myDataView.getShape().size()==1);
4172        assert(myDataView(0)==1.0);
4173        assert(myDataView(1)==1.0);
4174        assert(myDataView(2)==1.0);
4175    
4176        myDataView = myData1.getDataPointByTag(1);
4177        assert(!myDataView.isEmpty());
4178        assert(myDataView.getOffset()==3);
4179        assert(myDataView.getRank()==1);
4180        assert(myDataView.noValues()==3);
4181        assert(myDataView.getShape().size()==1);
4182        assert(myDataView(0)==2.0);
4183        assert(myDataView(1)==2.0);
4184        assert(myDataView(2)==2.0);
4185    
4186        // rank 1 slice
4187    
4188        viewShape.clear();
4189        viewShape.push_back(1);
4190    
4191        DataArrayView::ValueType viewData5(1);
4192        viewData5[0]=3.0;
4193        DataArrayView myView5(viewData5,viewShape);
4194    
4195        values.clear();
4196    
4197        DataArrayView::ValueType viewData6(1);
4198        viewData6[0]=4.0;
4199        DataArrayView myView6(viewData6,viewShape);
4200        values.push_back(myView6);
4201    
4202        DataTagged myData3(keys,values,myView5,FunctionSpace());
4203    
4204        region.clear();
4205        region_element.first=1;
4206        region_element.second=2;
4207        region.push_back(region_element);
4208    
4209        myData1.setSlice(&myData3, region);
4210    
4211        //cout << myData1.toString() << endl;
4212    
4213        assert(myData1.getTagLookup().size()==1);
4214    
4215        assert(myData1.getLength()==6);
4216    
4217        myDataView = myData1.getDefaultValue();
4218        assert(!myDataView.isEmpty());
4219        assert(myDataView.getOffset()==0);
4220        assert(myDataView.getRank()==1);
4221        assert(myDataView.noValues()==3);
4222        assert(myDataView.getShape().size()==1);
4223        assert(myDataView(0)==1.0);
4224        assert(myDataView(1)==3.0);
4225        assert(myDataView(2)==1.0);
4226    
4227        myDataView = myData1.getDataPointByTag(1);
4228        assert(!myDataView.isEmpty());
4229        assert(myDataView.getOffset()==3);
4230        assert(myDataView.getRank()==1);
4231        assert(myDataView.noValues()==3);
4232        assert(myDataView.getShape().size()==1);
4233        assert(myDataView(0)==2.0);
4234        assert(myDataView(1)==4.0);
4235        assert(myDataView(2)==2.0);
4236    
4237        // scalar slice
4238    
4239        viewShape.clear();
4240    
4241        DataArrayView::ValueType viewData7(1);
4242        viewData7[0]=5.0;
4243        DataArrayView myView7(viewData7,viewShape);
4244    
4245        values.clear();
4246    
4247        DataArrayView::ValueType viewData8(1);
4248        viewData8[0]=6.0;
4249        DataArrayView myView8(viewData8,viewShape);
4250        values.push_back(myView8);
4251    
4252        DataTagged myData4(keys,values,myView7,FunctionSpace());
4253    
4254        region.clear();
4255        region_element.first=0;
4256        region_element.second=0;
4257        region.push_back(region_element);
4258    
4259        myData1.setSlice(&myData4, region);
4260    
4261        //cout << myData1.toString() << endl;
4262    
4263        myDataView = myData1.getDefaultValue();
4264        assert(!myDataView.isEmpty());
4265        assert(myDataView.getOffset()==0);
4266        assert(myDataView.getRank()==1);
4267        assert(myDataView.noValues()==3);
4268        assert(myDataView.getShape().size()==1);
4269        assert(myDataView(0)==5.0);
4270        assert(myDataView(1)==3.0);
4271        assert(myDataView(2)==1.0);
4272    
4273        myDataView = myData1.getDataPointByTag(1);
4274        assert(!myDataView.isEmpty());
4275        assert(myDataView.getOffset()==3);
4276        assert(myDataView.getRank()==1);
4277        assert(myDataView.noValues()==3);
4278        assert(myDataView.getShape().size()==1);
4279        assert(myDataView(0)==6.0);
4280        assert(myDataView(1)==4.0);
4281        assert(myDataView(2)==2.0);
4282    
4283      }
4284    
4285      {
4286    
4287        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
4288    
4289        DataTagged::TagListType keys;
4290        keys.push_back(1);
4291    
4292        DataTagged::ValueListType values;
4293    
4294        DataArrayView::ShapeType viewShape;
4295        viewShape.push_back(3);
4296        viewShape.push_back(3);
4297        viewShape.push_back(3);
4298    
4299        // default value for Data1
4300        DataArrayView::ValueType viewData1(27);
4301        for (int i=0;i<viewData1.size();i++) {
4302          viewData1[i]=0.0;
4303        }
4304        DataArrayView myView1(viewData1,viewShape);
4305    
4306        // value for tag "1" for Data1
4307        DataArrayView::ValueType viewData2(27);
4308        for (int i=0;i<viewData2.size();i++) {
4309          viewData2[i]=0.0;
4310        }
4311        DataArrayView myView2(viewData2,viewShape);
4312        values.push_back(myView2);
4313    
4314        DataTagged myData1(keys,values,myView1,FunctionSpace());
4315    
4316        values.clear();
4317    
4318        // default value for Data2
4319        DataArrayView::ValueType viewData3(27);
4320        for (int i=0;i<viewData3.size();i++) {
4321          viewData3[i]=1.0;
4322        }
4323        DataArrayView myView3(viewData3,viewShape);
4324    
4325        // value for tag "1" for Data2
4326        DataArrayView::ValueType viewData4(27);
4327        for (int i=0;i<viewData4.size();i++) {
4328          viewData4[i]=2.0;
4329        }
4330        DataArrayView myView4(viewData4,viewShape);
4331        values.push_back(myView4);
4332    
4333        DataTagged myData2(keys,values,myView3,FunctionSpace());
4334    
4335        // full slice
4336    
4337        std::pair<int, int> region_element;
4338        region_element.first=0;
4339        region_element.second=3;
4340        DataArrayView::RegionType region;
4341        region.push_back(region_element);
4342        region.push_back(region_element);
4343        region.push_back(region_element);
4344    
4345        myData1.setSlice(&myData2, region);
4346    
4347        //cout << myData1.toString() << endl;
4348    
4349        assert(myData1.getTagLookup().size()==1);
4350    
4351        assert(myData1.getLength()==54);
4352    
4353        DataArrayView myDataView = myData1.getDefaultValue();
4354        assert(!myDataView.isEmpty());
4355        assert(myDataView.getOffset()==0);
4356        assert(myDataView.getRank()==3);
4357        assert(myDataView.noValues()==27);
4358        assert(myDataView.getShape().size()==3);
4359        assert(myDataView(0,0,0)==1.0);
4360        assert(myDataView(1,1,1)==1.0);
4361        assert(myDataView(2,2,2)==1.0);
4362    
4363        myDataView = myData1.getDataPointByTag(1);
4364        assert(!myDataView.isEmpty());
4365        assert(myDataView.getOffset()==27);
4366        assert(myDataView.getRank()==3);
4367        assert(myDataView.noValues()==27);
4368        assert(myDataView.getShape().size()==3);
4369        assert(myDataView(0,0,0)==2.0);
4370        assert(myDataView(1,1,1)==2.0);
4371        assert(myDataView(2,2,2)==2.0);
4372    
4373        // rank 1 slice
4374    
4375        viewShape.clear();
4376        viewShape.push_back(3);
4377    
4378        DataArrayView::ValueType viewData5(3);
4379        for (int i=0;i<viewData5.size();i++) {
4380          viewData5[i]=3.0;
4381        }
4382        DataArrayView myView5(viewData5,viewShape);
4383    
4384        values.clear();
4385    
4386        DataArrayView::ValueType viewData6(3);
4387        for (int i=0;i<viewData6.size();i++) {
4388          viewData6[i]=4.0;
4389        }
4390        DataArrayView myView6(viewData6,viewShape);
4391        values.push_back(myView6);
4392    
4393        DataTagged myData3(keys,values,myView5,FunctionSpace());
4394    
4395        region.clear();
4396        region.push_back(region_element);
4397        region_element.first=0;
4398        region_element.second=0;
4399        region.push_back(region_element);
4400        region.push_back(region_element);
4401    
4402        myData1.setSlice(&myData3, region);
4403    
4404        //cout << myData1.toString() << endl;
4405    
4406        assert(myData1.getTagLookup().size()==1);
4407    
4408        assert(myData1.getLength()==54);
4409    
4410        myDataView = myData1.getDefaultValue();
4411        assert(!myDataView.isEmpty());
4412        assert(myDataView.getOffset()==0);
4413        assert(myDataView.getRank()==3);
4414        assert(myDataView.noValues()==27);
4415        assert(myDataView.getShape().size()==3);
4416        assert(myDataView(0,0,0)==3.0);
4417        assert(myDataView(1,0,0)==3.0);
4418        assert(myDataView(2,0,0)==3.0);
4419    
4420        myDataView = myData1.getDataPointByTag(1);
4421        assert(!myDataView.isEmpty());
4422        assert(myDataView.getOffset()==27);
4423        assert(myDataView.getRank()==3);
4424        assert(myDataView.noValues()==27);
4425        assert(myDataView.getShape().size()==3);
4426        assert(myDataView(0,0,0)==4.0);
4427        assert(myDataView(1,0,0)==4.0);
4428        assert(myDataView(2,0,0)==4.0);
4429    
4430        // scalar slice
4431    
4432        viewShape.clear();
4433    
4434        DataArrayView::ValueType viewData7(1);
4435        viewData7[0]=5.0;
4436        DataArrayView myView7(viewData7,viewShape);
4437    
4438        values.clear();
4439    
4440        DataArrayView::ValueType viewData8(1);
4441        viewData8[0]=6.0;
4442        DataArrayView myView8(viewData8,viewShape);
4443        values.push_back(myView8);
4444    
4445        DataTagged myData4(keys,values,myView7,FunctionSpace());
4446    
4447        region.clear();
4448        region_element.first=0;
4449        region_element.second=0;
4450        region.push_back(region_element);
4451        region.push_back(region_element);
4452        region.push_back(region_element);
4453    
4454        myData1.setSlice(&myData4, region);
4455    
4456        //cout << myData1.toString() << endl;
4457    
4458        myDataView = myData1.getDefaultValue();
4459        assert(!myDataView.isEmpty());
4460        assert(myDataView.getOffset()==0);
4461        assert(myDataView.getRank()==3);
4462        assert(myDataView.noValues()==27);
4463        assert(myDataView.getShape().size()==3);
4464        assert(myDataView(0,0,0)==5.0);
4465    
4466        myDataView = myData1.getDataPointByTag(1);
4467        assert(!myDataView.isEmpty());
4468        assert(myDataView.getOffset()==27);
4469        assert(myDataView.getRank()==3);
4470        assert(myDataView.noValues()==27);
4471        assert(myDataView.getShape().size()==3);
4472        assert(myDataView(0,0,0)==6.0);
4473    
4474      }
4475    
4476      {
4477    
4478        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
4479    
4480        DataTagged::TagListType keys;
4481        keys.push_back(1);
4482        keys.push_back(2);
4483        keys.push_back(3);
4484    
4485        DataTagged::ValueListType values;
4486    
4487        DataArrayView::ShapeType viewShape;
4488    
4489        // default value for Data1
4490        DataArrayView::ValueType viewData1(1);
4491        viewData1[0]=0.0;
4492        DataArrayView myView1(viewData1,viewShape);
4493    
4494        // value for tag "1" for Data1
4495        DataArrayView::ValueType viewData2(1);
4496        viewData2[0]=0.0;
4497        DataArrayView myView2(viewData2,viewShape);
4498        values.push_back(myView2);
4499    
4500        // value for tag "2" for Data1
4501        DataArrayView::ValueType viewData5(1);
4502        viewData5[0]=0.0;
4503        DataArrayView myView5(viewData5,viewShape);
4504        values.push_back(myView5);
4505    
4506        // value for tag "3" for Data1
4507        DataArrayView::ValueType viewData6(1);
4508        viewData6[0]=0.0;
4509        DataArrayView myView6(viewData6,viewShape);
4510        values.push_back(myView6);
4511    
4512        DataTagged myData1(keys,values,myView1,FunctionSpace());
4513    
4514        values.clear();
4515    
4516        // default value for Data2
4517        DataArrayView::ValueType viewData3(1);
4518        viewData3[0]=1.0;
4519        DataArrayView myView3(viewData3,viewShape);
4520    
4521        // value for tag "1" for Data2
4522        DataArrayView::ValueType viewData4(1);
4523        viewData4[0]=2.0;
4524        DataArrayView myView4(viewData4,viewShape);
4525        values.push_back(myView4);
4526    
4527        // value for tag "2" for Data2
4528        DataArrayView::ValueType viewData7(1);
4529        viewData7[0]=3.0;
4530        DataArrayView myView7(viewData7,viewShape);
4531        values.push_back(myView7);
4532    
4533        // value for tag "3" for Data2
4534        DataArrayView::ValueType viewData8(1);
4535        viewData8[0]=4.0;
4536        DataArrayView myView8(viewData8,viewShape);
4537        values.push_back(myView8);
4538    
4539        DataTagged myData2(keys,values,myView3,FunctionSpace());
4540    
4541        // full slice
4542    
4543        DataArrayView::RegionType region;
4544    
4545        myData1.setSlice(&myData2, region);
4546    
4547        //cout << myData1.toString() << endl;
4548    
4549        assert(myData1.getTagLookup().size()==3);
4550    
4551        assert(myData1.getLength()==4);
4552    
4553        DataArrayView myDataView = myData1.getDefaultValue();
4554        assert(!myDataView.isEmpty());
4555        assert(myDataView.getOffset()==0);
4556        assert(myDataView.getRank()==0);
4557        assert(myDataView.noValues()==1);
4558        assert(myDataView.getShape().size()==0);
4559        assert(myDataView()==1.0);
4560    
4561        myDataView = myData1.getDataPointByTag(1);
4562        assert(!myDataView.isEmpty());
4563        assert(myDataView.getOffset()==1);
4564        assert(myDataView.getRank()==0);
4565        assert(myDataView.noValues()==1);
4566        assert(myDataView.getShape().size()==0);
4567        assert(myDataView()==2.0);
4568    
4569        myDataView = myData1.getDataPointByTag(2);
4570        assert(!myDataView.isEmpty());
4571        assert(myDataView.getOffset()==2);
4572        assert(myDataView.getRank()==0);
4573        assert(myDataView.noValues()==1);
4574        assert(myDataView.getShape().size()==0);
4575        assert(myDataView()==3.0);
4576    
4577        myDataView = myData1.getDataPointByTag(3);
4578        assert(!myDataView.isEmpty());
4579        assert(myDataView.getOffset()==3);
4580        assert(myDataView.getRank()==0);
4581        assert(myDataView.noValues()==1);
4582        assert(myDataView.getShape().size()==0);
4583        assert(myDataView()==4.0);
4584    
4585      }
4586    
4587      {
4588    
4589        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
4590    
4591        DataTagged::TagListType keys;
4592        keys.push_back(1);
4593        keys.push_back(2);
4594        keys.push_back(3);
4595    
4596        DataTagged::ValueListType values;
4597    
4598        DataArrayView::ShapeType viewShape;
4599        viewShape.push_back(3);
4600    
4601        // default value for Data1
4602        DataArrayView::ValueType viewData1(3);
4603        for (int i=0;i<viewData1.size();i++) {
4604          viewData1[i]=0.0;
4605        }
4606        DataArrayView myView1(viewData1,viewShape);
4607    
4608        // value for tag "1" for Data1
4609        DataArrayView::ValueType viewData2(3);
4610        for (int i=0;i<viewData2.size();i++) {
4611          viewData2[i]=0.0;
4612        }
4613        DataArrayView myView2(viewData2,viewShape);
4614        values.push_back(myView2);
4615    
4616        // value for tag "2" for Data1
4617        DataArrayView::ValueType viewData3(3);
4618        for (int i=0;i<viewData3.size();i++) {
4619          viewData3[i]=0.0;
4620        }
4621        DataArrayView myView3(viewData3,viewShape);
4622        values.push_back(myView3);
4623    
4624        // value for tag "3" for Data1
4625        DataArrayView::ValueType viewData4(3);
4626        for (int i=0;i<viewData4.size();i++) {
4627          viewData4[i]=0.0;
4628        }
4629        DataArrayView myView4(viewData4,viewShape);
4630        values.push_back(myView4);
4631    
4632        DataTagged myData1(keys,values,myView1,FunctionSpace());
4633    
4634        values.clear();
4635    
4636        // default value for Data2
4637        DataArrayView::ValueType viewData5(3);
4638        for (int i=0;i<viewData5.size();i++) {
4639          viewData5[i]=1.0;
4640        }
4641        DataArrayView myView5(viewData5,viewShape);
4642    
4643        // value for tag "1" for Data2
4644        DataArrayView::ValueType viewData6(3);
4645        for (int i=0;i<viewData6.size();i++) {
4646          viewData6[i]=2.0;
4647        }
4648        DataArrayView myView6(viewData6,viewShape);
4649        values.push_back(myView6);
4650    
4651        // value for tag "2" for Data2
4652        DataArrayView::ValueType viewData7(3);
4653        for (int i=0;i<viewData7.size();i++) {
4654          viewData7[i]=3.0;
4655        }
4656        DataArrayView myView7(viewData7,viewShape);
4657        values.push_back(myView7);
4658    
4659        // value for tag "3" for Data2
4660        DataArrayView::ValueType viewData8(3);
4661        for (int i=0;i<viewData8.size();i++) {
4662          viewData8[i]=4.0;
4663        }
4664        DataArrayView myView8(viewData8,viewShape);
4665        values.push_back(myView8);
4666    
4667        DataTagged myData2(keys,values,myView5,FunctionSpace());
4668    
4669        // full slice
4670    
4671        std::pair<int, int> region_element;
4672        region_element.first=0;
4673        region_element.second=3;
4674        DataArrayView::RegionType region;
4675        region.push_back(region_element);
4676    
4677        myData1.setSlice(&myData2, region);
4678    
4679        //cout << myData1.toString() << endl;
4680    
4681        assert(myData1.getTagLookup().size()==3);
4682    
4683        assert(myData1.getLength()==12);
4684    
4685        DataArrayView myDataView = myData1.getDefaultValue();
4686        assert(!myDataView.isEmpty());
4687        assert(myDataView.getOffset()==0);
4688        assert(myDataView.getRank()==1);
4689        assert(myDataView.noValues()==3);
4690        assert(myDataView.getShape().size()==1);
4691        assert(myDataView(0)==1.0);
4692        assert(myDataView(1)==1.0);
4693        assert(myDataView(2)==1.0);
4694    
4695        myDataView = myData1.getDataPointByTag(1);
4696        assert(!myDataView.isEmpty());
4697        assert(myDataView.getOffset()==3);
4698        assert(myDataView.getRank()==1);
4699        assert(myDataView.noValues()==3);
4700        assert(myDataView.getShape().size()==1);
4701        assert(myDataView(0)==2.0);
4702        assert(myDataView(1)==2.0);
4703        assert(myDataView(2)==2.0);
4704    
4705        myDataView = myData1.getDataPointByTag(2);
4706        assert(!myDataView.isEmpty());
4707        assert(myDataView.getOffset()==6);
4708        assert(myDataView.getRank()==1);
4709        assert(myDataView.noValues()==3);
4710        assert(myDataView.getShape().size()==1);
4711        assert(myDataView(0)==3.0);
4712        assert(myDataView(1)==3.0);
4713        assert(myDataView(2)==3.0);
4714    
4715        myDataView = myData1.getDataPointByTag(3);
4716        assert(!myDataView.isEmpty());
4717        assert(myDataView.getOffset()==9);
4718        assert(myDataView.getRank()==1);
4719        assert(myDataView.noValues()==3);
4720        assert(myDataView.getShape().size()==1);
4721        assert(myDataView(0)==4.0);
4722        assert(myDataView(1)==4.0);
4723        assert(myDataView(2)==4.0);
4724    
4725        // rank 1 slice
4726    
4727        viewShape.clear();
4728        viewShape.push_back(1);
4729    
4730        DataArrayView::ValueType viewData9(1);
4731        viewData9[0]=6.0;
4732        DataArrayView myView9(viewData9,viewShape);
4733    
4734        values.clear();
4735    
4736        DataArrayView::ValueType viewData10(1);
4737        viewData10[0]=7.0;
4738        DataArrayView myView10(viewData10,viewShape);
4739        values.push_back(myView10);
4740    
4741        DataArrayView::ValueType viewData11(1);
4742        viewData11[0]=8.0;
4743        DataArrayView myView11(viewData11,viewShape);
4744        values.push_back(myView11);
4745    
4746        DataArrayView::ValueType viewData12(1);
4747        viewData12[0]=9.0;
4748        DataArrayView myView12(viewData12,viewShape);
4749        values.push_back(myView12);
4750    
4751        DataTagged myData3(keys,values,myView9,FunctionSpace());
4752    
4753        region.clear();
4754        region_element.first=1;
4755        region_element.second=2;
4756        region.push_back(region_element);
4757    
4758        myData1.setSlice(&myData3, region);
4759    
4760        //cout << myData1.toString() << endl;
4761    
4762        assert(myData1.getTagLookup().size()==3);
4763    
4764        assert(myData1.getLength()==12);
4765    
4766        myDataView = myData1.getDefaultValue();
4767        assert(!myDataView.isEmpty());
4768        assert(myDataView.getOffset()==0);
4769        assert(myDataView.getRank()==1);
4770        assert(myDataView.noValues()==3);
4771        assert(myDataView.getShape().size()==1);
4772        assert(myDataView(0)==1.0);
4773        assert(myDataView(1)==6.0);
4774        assert(myDataView(2)==1.0);
4775    
4776        myDataView = myData1.getDataPointByTag(1);
4777        assert(!myDataView.isEmpty());
4778        assert(myDataView.getOffset()==3);
4779        assert(myDataView.getRank()==1);
4780        assert(myDataView.noValues()==3);
4781        assert(myDataView.getShape().size()==1);
4782        assert(myDataView(0)==2.0);
4783        assert(myDataView(1)==7.0);
4784        assert(myDataView(2)==2.0);
4785    
4786        myDataView = myData1.getDataPointByTag(2);
4787        assert(!myDataView.isEmpty());
4788        assert(myDataView.getOffset()==6);
4789        assert(myDataView.getRank()==1);
4790        assert(myDataView.noValues()==3);
4791        assert(myDataView.getShape().size()==1);
4792        assert(myDataView(0)==3.0);
4793        assert(myDataView(1)==8.0);
4794        assert(myDataView(2)==3.0);
4795    
4796        myDataView = myData1.getDataPointByTag(3);
4797        assert(!myDataView.isEmpty());
4798        assert(myDataView.getOffset()==9);
4799        assert(myDataView.getRank()==1);
4800        assert(myDataView.noValues()==3);
4801        assert(myDataView.getShape().size()==1);
4802        assert(myDataView(0)==4.0);
4803        assert(myDataView(1)==9.0);
4804        assert(myDataView(2)==4.0);
4805    
4806        // scalar slice
4807    
4808        viewShape.clear();
4809    
4810        DataArrayView::ValueType viewData13(1);
4811        viewData13[0]=10.0;
4812        DataArrayView myView13(viewData13,viewShape);
4813    
4814        values.clear();
4815    
4816        DataArrayView::ValueType viewData14(1);
4817        viewData14[0]=11.0;
4818        DataArrayView myView14(viewData14,viewShape);
4819        values.push_back(myView14);
4820    
4821        DataArrayView::ValueType viewData15(2);
4822        viewData15[0]=12.0;
4823        DataArrayView myView15(viewData15,viewShape);
4824        values.push_back(myView15);
4825    
4826        DataArrayView::ValueType viewData16(3);
4827        viewData16[0]=13.0;
4828        DataArrayView myView16(viewData16,viewShape);
4829        values.push_back(myView16);
4830    
4831        DataTagged myData4(keys,values,myView13,FunctionSpace());
4832    
4833        region.clear();
4834        region_element.first=0;
4835        region_element.second=0;
4836        region.push_back(region_element);
4837    
4838        myData1.setSlice(&myData4, region);
4839    
4840        //cout << myData1.toString() << endl;
4841    
4842        myDataView = myData1.getDefaultValue();
4843        assert(!myDataView.isEmpty());
4844        assert(myDataView.getOffset()==0);
4845        assert(myDataView.getRank()==1);
4846        assert(myDataView.noValues()==3);
4847        assert(myDataView.getShape().size()==1);
4848        assert(myDataView(0)==10.0);
4849        assert(myDataView(1)==6.0);
4850        assert(myDataView(2)==1.0);
4851    
4852        myDataView = myData1.getDataPointByTag(1);
4853        assert(!myDataView.isEmpty());
4854        assert(myDataView.getOffset()==3);
4855        assert(myDataView.getRank()==1);
4856        assert(myDataView.noValues()==3);
4857        assert(myDataView.getShape().size()==1);
4858        assert(myDataView(0)==11.0);
4859        assert(myDataView(1)==7.0);
4860        assert(myDataView(2)==2.0);
4861    
4862        myDataView = myData1.getDataPointByTag(2);
4863        assert(!myDataView.isEmpty());
4864        assert(myDataView.getOffset()==6);
4865        assert(myDataView.getRank()==1);
4866        assert(myDataView.noValues()==3);
4867        assert(myDataView.getShape().size()==1);
4868        assert(myDataView(0)==12.0);
4869        assert(myDataView(1)==8.0);
4870        assert(myDataView(2)==3.0);
4871    
4872        myDataView = myData1.getDataPointByTag(3);
4873        assert(!myDataView.isEmpty());
4874        assert(myDataView.getOffset()==9);
4875        assert(myDataView.getRank()==1);
4876        assert(myDataView.noValues()==3);
4877        assert(myDataView.getShape().size()==1);
4878        assert(myDataView(0)==13.0);
4879        assert(myDataView(1)==9.0);
4880        assert(myDataView(2)==4.0);
4881    
4882      }
4883    
4884      {
4885    
4886        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
4887    
4888        DataTagged::TagListType keys;
4889        keys.push_back(1);
4890        keys.push_back(2);
4891        keys.push_back(3);
4892    
4893        DataTagged::ValueListType values;
4894    
4895        DataArrayView::ShapeType viewShape;
4896        viewShape.push_back(3);
4897        viewShape.push_back(3);
4898        viewShape.push_back(3);
4899    
4900        // default value for Data1
4901        DataArrayView::ValueType viewData1(27);
4902        for (int i=0;i<viewData1.size();i++) {
4903          viewData1[i]=0.0;
4904        }
4905        DataArrayView myView1(viewData1,viewShape);
4906    
4907        // value for tag "1" for Data1
4908        DataArrayView::ValueType viewData2(27);
4909        for (int i=0;i<viewData2.size();i++) {
4910          viewData2[i]=0.0;
4911        }
4912        DataArrayView myView2(viewData2,viewShape);
4913        values.push_back(myView2);
4914    
4915        // value for tag "2" for Data1
4916        DataArrayView::ValueType viewData3(27);
4917        for (int i=0;i<viewData3.size();i++) {
4918          viewData3[i]=0.0;
4919        }
4920        DataArrayView myView3(viewData3,viewShape);
4921        values.push_back(myView3);
4922    
4923        // value for tag "3" for Data1
4924        DataArrayView::ValueType viewData4(27);
4925        for (int i=0;i<viewData4.size();i++) {
4926          viewData4[i]=0.0;
4927        }
4928        DataArrayView myView4(viewData4,viewShape);
4929        values.push_back(myView4);
4930    
4931        DataTagged myData1(keys,values,myView1,FunctionSpace());
4932    
4933        values.clear();
4934    
4935        // default value for Data2
4936        DataArrayView::ValueType viewData5(27);
4937        for (int i=0;i<viewData5.size();i++) {
4938          viewData5[i]=1.0;
4939        }
4940        DataArrayView myView5(viewData5,viewShape);
4941    
4942        // value for tag "1" for Data2
4943        DataArrayView::ValueType viewData6(27);
4944        for (int i=0;i<viewData6.size();i++) {
4945          viewData6[i]=2.0;
4946        }
4947        DataArrayView myView6(viewData6,viewShape);
4948        values.push_back(myView6);
4949    
4950        // value for tag "2" for Data2
4951        DataArrayView::ValueType viewData7(27);
4952        for (int i=0;i<viewData7.size();i++) {
4953          viewData7[i]=3.0;
4954        }
4955        DataArrayView myView7(viewData7,viewShape);
4956        values.push_back(myView7);
4957    
4958        // value for tag "3" for Data2
4959        DataArrayView::ValueType viewData8(27);
4960        for (int i=0;i<viewData8.size();i++) {
4961          viewData8[i]=4.0;
4962        }
4963        DataArrayView myView8(viewData8,viewShape);
4964        values.push_back(myView8);
4965    
4966        DataTagged myData2(keys,values,myView5,FunctionSpace());
4967    
4968        // full slice
4969    
4970        std::pair<int, int> region_element;
4971        region_element.first=0;
4972        region_element.second=3;
4973        DataArrayView::RegionType region;
4974        region.push_back(region_element);
4975        region.push_back(region_element);
4976        region.push_back(region_element);
4977    
4978        myData1.setSlice(&myData2, region);
4979    
4980        //cout << myData1.toString() << endl;
4981    
4982        assert(myData1.getTagLookup().size()==3);
4983    
4984        assert(myData1.getLength()==108);
4985    
4986        DataArrayView myDataView = myData1.getDefaultValue();
4987        assert(!myDataView.isEmpty());
4988        assert(myDataView.getOffset()==0);
4989        assert(myDataView.getRank()==3);
4990        assert(myDataView.noValues()==27);
4991        assert(myDataView.getShape().size()==3);
4992        assert(myDataView(0,0,0)==1.0);
4993        assert(myDataView(1,0,0)==1.0);
4994        assert(myDataView(2,0,0)==1.0);
4995    
4996        myDataView = myData1.getDataPointByTag(1);
4997        assert(!myDataView.isEmpty());
4998        assert(myDataView.getOffset()==27);
4999        assert(myDataView.getRank()==3);
5000        assert(myDataView.noValues()==27);
5001        assert(myDataView.getShape().size()==3);
5002        assert(myDataView(0,0,0)==2.0);
5003        assert(myDataView(1,0,0)==2.0);
5004        assert(myDataView(2,0,0)==2.0);
5005    
5006        myDataView = myData1.getDataPointByTag(2);
5007        assert(!myDataView.isEmpty());
5008        assert(myDataView.getOffset()==54);
5009        assert(myDataView.getRank()==3);
5010        assert(myDataView.noValues()==27);
5011        assert(myDataView.getShape().size()==3);
5012        assert(myDataView(0,0,0)==3.0);
5013        assert(myDataView(1,0,0)==3.0);
5014        assert(myDataView(2,0,0)==3.0);
5015    
5016        myDataView = myData1.getDataPointByTag(3);
5017        assert(!myDataView.isEmpty());
5018        assert(myDataView.getOffset()==81);
5019        assert(myDataView.getRank()==3);
5020        assert(myDataView.noValues()==27);
5021        assert(myDataView.getShape().size()==3);
5022        assert(myDataView(0,0,0)==4.0);
5023        assert(myDataView(1,0,0)==4.0);
5024        assert(myDataView(2,0,0)==4.0);
5025    
5026        // rank 1 slice
5027    
5028        viewShape.clear();
5029        viewShape.push_back(3);
5030    
5031        DataArrayView::ValueType viewData9(3);
5032        for (int i=0;i<viewData9.size();i++) {
5033          viewData9[i]=6.0;
5034        }
5035        DataArrayView myView9(viewData9,viewShape);
5036    
5037        values.clear();
5038    
5039        DataArrayView::ValueType viewData10(3);
5040        for (int i=0;i<viewData10.size();i++) {
5041          viewData10[i]=7.0;
5042        }
5043        DataArrayView myView10(viewData10,viewShape);
5044        values.push_back(myView10);
5045    
5046        DataArrayView::ValueType viewData11(3);
5047        for (int i=0;i<viewData11.size();i++) {
5048          viewData11[i]=8.0;
5049        }
5050        DataArrayView myView11(viewData11,viewShape);
5051        values.push_back(myView11);
5052    
5053        DataArrayView::ValueType viewData12(3);
5054        for (int i=0;i<viewData12.size();i++) {
5055          viewData12[i]=9.0;
5056        }
5057        DataArrayView myView12(viewData12,viewShape);
5058        values.push_back(myView12);
5059    
5060        DataTagged myData3(keys,values,myView9,FunctionSpace());
5061    
5062        region.clear();
5063        region_element.first=0;
5064        region_element.second=3;
5065        region.push_back(region_element);
5066        region_element.second=0;
5067        region.push_back(region_element);
5068        region.push_back(region_element);
5069    
5070        myData1.setSlice(&myData3, region);
5071    
5072        //cout << myData1.toString() << endl;
5073    
5074        assert(myData1.getTagLookup().size()==3);
5075    
5076        assert(myData1.getLength()==108);
5077    
5078        myDataView = myData1.getDefaultValue();
5079        assert(!myDataView.isEmpty());
5080        assert(myDataView.getOffset()==0);
5081        assert(myDataView.getRank()==3);
5082        assert(myDataView.noValues()==27);
5083        assert(myDataView.getShape().size()==3);
5084        assert(myDataView(0,0,0)==6.0);
5085        assert(myDataView(1,0,0)==6.0);
5086        assert(myDataView(2,0,0)==6.0);
5087    
5088        myDataView = myData1.getDataPointByTag(1);
5089        assert(!myDataView.isEmpty());
5090        assert(myDataView.getOffset()==27);
5091        assert(myDataView.getRank()==3);
5092        assert(myDataView.noValues()==27);
5093        assert(myDataView.getShape().size()==3);
5094        assert(myDataView(0,0,0)==7.0);
5095        assert(myDataView(1,0,0)==7.0);
5096        assert(myDataView(2,0,0)==7.0);
5097    
5098        myDataView = myData1.getDataPointByTag(2);
5099        assert(!myDataView.isEmpty());
5100        assert(myDataView.getOffset()==54);
5101        assert(myDataView.getRank()==3);
5102        assert(myDataView.noValues()==27);
5103        assert(myDataView.getShape().size()==3);
5104        assert(myDataView(0,0,0)==8.0);
5105        assert(myDataView(1,0,0)==8.0);
5106        assert(myDataView(2,0,0)==8.0);
5107    
5108        myDataView = myData1.getDataPointByTag(3);
5109        assert(!myDataView.isEmpty());
5110        assert(myDataView.getOffset()==81);
5111        assert(myDataView.getRank()==3);
5112        assert(myDataView.noValues()==27);
5113        assert(myDataView.getShape().size()==3);
5114        assert(myDataView(0,0,0)==9.0);
5115        assert(myDataView(1,0,0)==9.0);
5116        assert(myDataView(2,0,0)==9.0);
5117    
5118        // scalar slice
5119    
5120        viewShape.clear();
5121    
5122        DataArrayView::ValueType viewData13(1);
5123        viewData13[0]=10.0;
5124        DataArrayView myView13(viewData13,viewShape);
5125    
5126        values.clear();
5127    
5128        DataArrayView::ValueType viewData14(1);
5129        viewData14[0]=11.0;
5130        DataArrayView myView14(viewData14,viewShape);
5131        values.push_back(myView14);
5132    
5133        DataArrayView::ValueType viewData15(2);
5134        viewData15[0]=12.0;
5135        DataArrayView myView15(viewData15,viewShape);
5136        values.push_back(myView15);
5137    
5138        DataArrayView::ValueType viewData16(3);
5139        viewData16[0]=13.0;
5140        DataArrayView myView16(viewData16,viewShape);
5141        values.push_back(myView16);
5142    
5143        DataTagged myData4(keys,values,myView13,FunctionSpace());
5144    
5145        region.clear();
5146        region_element.first=0;
5147        region_element.second=0;
5148        region.push_back(region_element);
5149        region.push_back(region_element);
5150        region.push_back(region_element);
5151    
5152        myData1.setSlice(&myData4, region);
5153    
5154        //cout << myData1.toString() << endl;
5155    
5156        myDataView = myData1.getDefaultValue();
5157        assert(!myDataView.isEmpty());
5158        assert(myDataView.getOffset()==0);
5159        assert(myDataView.getRank()==3);
5160        assert(myDataView.noValues()==27);
5161        assert(myDataView.getShape().size()==3);
5162        assert(myDataView(0,0,0)==10.0);
5163    
5164        myDataView = myData1.getDataPointByTag(1);
5165        assert(!myDataView.isEmpty());
5166        assert(myDataView.getOffset()==27);
5167        assert(myDataView.getRank()==3);
5168        assert(myDataView.noValues()==27);
5169        assert(myDataView.getShape().size()==3);
5170        assert(myDataView(0,0,0)==11.0);
5171    
5172        myDataView = myData1.getDataPointByTag(2);
5173        assert(!myDataView.isEmpty());
5174        assert(myDataView.getOffset()==54);
5175        assert(myDataView.getRank()==3);
5176        assert(myDataView.noValues()==27);
5177        assert(myDataView.getShape().size()==3);
5178        assert(myDataView(0,0,0)==12.0);
5179    
5180        myDataView = myData1.getDataPointByTag(3);
5181        assert(!myDataView.isEmpty());
5182        assert(myDataView.getOffset()==81);
5183        assert(myDataView.getRank()==3);
5184        assert(myDataView.noValues()==27);
5185        assert(myDataView.getShape().size()==3);
5186        assert(myDataView(0,0,0)==13.0);
5187    
5188      }
5189    
5190      {
5191    
5192        cout << "\tTest slicing DataTagged with scalar values and three *mismatched* tags." << endl;
5193    
5194        DataTagged::TagListType keys1;
5195        keys1.push_back(1);
5196        keys1.push_back(2);
5197        keys1.push_back(3);
5198    
5199        DataTagged::TagListType keys2;
5200        keys2.push_back(3);
5201        keys2.push_back(4);
5202        keys2.push_back(5);
5203    
5204        DataTagged::ValueListType values;
5205    
5206        DataArrayView::ShapeType viewShape;
5207    
5208        // default value for Data1
5209        DataArrayView::ValueType viewData1(1);
5210        viewData1[0]=0.0;
5211        DataArrayView myView1(viewData1,viewShape);
5212    
5213        // value for tag "1" for Data1
5214        DataArrayView::ValueType viewData2(1);
5215        viewData2[0]=0.0;
5216        DataArrayView myView2(viewData2,viewShape);
5217        values.push_back(myView2);
5218    
5219        // value for tag "2" for Data1
5220        DataArrayView::ValueType viewData5(1);
5221        viewData5[0]=0.0;
5222        DataArrayView myView5(viewData5,viewShape);
5223        values.push_back(myView5);
5224    
5225        // value for tag "3" for Data1
5226        DataArrayView::ValueType viewData6(1);
5227        viewData6[0]=0.0;
5228        DataArrayView myView6(viewData6,viewShape);
5229        values.push_back(myView6);
5230    
5231        DataTagged myData1(keys1,values,myView1,FunctionSpace());
5232    
5233        values.clear();
5234    
5235        // default value for Data2
5236        DataArrayView::ValueType viewData3(1);
5237        viewData3[0]=1.0;
5238        DataArrayView myView3(viewData3,viewShape);
5239    
5240        // value for tag "3" for Data2
5241        DataArrayView::ValueType viewData4(1);
5242        viewData4[0]=2.0;
5243        DataArrayView myView4(viewData4,viewShape);
5244        values.push_back(myView4);
5245    
5246        // value for tag "4" for Data2
5247        DataArrayView::ValueType viewData7(1);
5248        viewData7[0]=3.0;
5249        DataArrayView myView7(viewData7,viewShape);
5250        values.push_back(myView7);
5251    
5252        // value for tag "5" for Data2
5253        DataArrayView::ValueType viewData8(1);
5254        viewData8[0]=4.0;
5255        DataArrayView myView8(viewData8,viewShape);
5256        values.push_back(myView8);
5257    
5258        DataTagged myData2(keys2,values,myView3,FunctionSpace());
5259    
5260        //cout << myData1.toString() << endl;
5261        //cout << myData2.toString() << endl;
5262    
5263        // full slice
5264    
5265        DataArrayView::RegionType region;
5266    
5267        myData1.setSlice(&myData2, region);
5268    
5269        //cout << myData1.toString() << endl;
5270    
5271        assert(myData1.getTagLookup().size()==5);
5272    
5273        assert(myData1.getLength()==6);
5274    
5275        DataArrayView myDataView = myData1.getDefaultValue();
5276        assert(!myDataView.isEmpty());
5277        assert(myDataView.getOffset()==0);
5278        assert(myDataView.getRank()==0);
5279        assert(myDataView.noValues()==1);
5280        assert(myDataView.getShape().size()==0);
5281        assert(myDataView()==1.0);
5282    
5283        myDataView = myData1.getDataPointByTag(1);
5284        assert(!myDataView.isEmpty());
5285        assert(myDataView.getOffset()==1);
5286        assert(myDataView.getRank()==0);
5287        assert(myDataView.noValues()==1);
5288        assert(myDataView.getShape().size()==0);
5289        assert(myDataView()==1.0);
5290    
5291        myDataView = myData1.getDataPointByTag(2);
5292        assert(!myDataView.isEmpty());
5293        assert(myDataView.getOffset()==2);
5294        assert(myDataView.getRank()==0);
5295        assert(myDataView.noValues()==1);
5296        assert(myDataView.getShape().size()==0);
5297        assert(myDataView()==1.0);
5298    
5299        myDataView = myData1.getDataPointByTag(3);
5300        assert(!myDataView.isEmpty());
5301        assert(myDataView.getOffset()==3);
5302        assert(myDataView.getRank()==0);
5303        assert(myDataView.noValues()==1);
5304        assert(myDataView.getShape().size()==0);
5305        assert(myDataView()==2.0);
5306    
5307        myDataView = myData1.getDataPointByTag(4);
5308        assert(!myDataView.isEmpty());
5309        assert(myDataView.getOffset()==4);
5310        assert(myDataView.getRank()==0);
5311        assert(myDataView.noValues()==1);
5312        assert(myDataView.getShape().size()==0);
5313        assert(myDataView()==3.0);
5314    
5315        myDataView = myData1.getDataPointByTag(5);
5316        assert(!myDataView.isEmpty());
5317        assert(myDataView.getOffset()==5);
5318        assert(myDataView.getRank()==0);
5319        assert(myDataView.noValues()==1);
5320        assert(myDataView.getShape().size()==0);
5321        assert(myDataView()==4.0);
5322    
5323    }    }
5324    
5325  }  }
# Line 3346  TestSuite* DataTaggedTestCase::suite () Line 5334  TestSuite* DataTaggedTestCase::suite ()
5334    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetTaggedValue",&DataTaggedTestCase::testSetTaggedValue));
5335    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
5336    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
   testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));  
5337    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testGetSlice",&DataTaggedTestCase::testGetSlice));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testGetSlice",&DataTaggedTestCase::testGetSlice));
5338    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetSlice",&DataTaggedTestCase::testSetSlice));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetSlice",&DataTaggedTestCase::testSetSlice));
5339    return testSuite;    return testSuite;

Legend:
Removed from v.515  
changed lines
  Added in v.1387

  ViewVC Help
Powered by ViewVC 1.1.26