/[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 502 by jgs, Wed Feb 8 03:57:20 2006 UTC trunk/escript/test/DataTaggedTestCase.cpp revision 1325 by matt, Mon Oct 1 06:28:24 2007 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     *
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 36  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
47    
48  }  }
49    
50  void DataTaggedTestCase::testReshape() {  
51    void DataTaggedTestCase::testOperations() {
52    
53    cout << endl;    cout << endl;
54    
55    {    {
56      cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;      cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
57      DataTagged value;  
58      value.getPointDataView()()=1.0;      DataTagged myData;
59      DataArrayView::ShapeType shape;      DataTagged right;
60      shape.push_back(2);  
61      value.reshapeDataPoint(shape);      binaryOp(myData,right,plus<double>());
62      for (int i=0;i<shape[0];++i) {  
63        assert(value.getDefaultValue()(i)==1);      //cout << myData.toString() << endl;
64    
65        assert(myData.getNumSamples()==1);
66        assert(myData.getNumDPPSample()==1);
67    
68        assert(myData.validSamplePointNo(0));
69        assert(myData.validSampleNo(0));
70        assert(!myData.validSamplePointNo(1));
71        assert(!myData.validSampleNo(1));
72    
73        // data-point 0 has tag number 1 by default
74        assert(myData.getTagNumber(0)==1);
75    
76        assert(!myData.isCurrentTag(1));
77    
78        assert(myData.getTagLookup().size()==0);
79    
80        assert(myData.getLength()==1);
81    
82        assert(myData.getPointOffset(0,0)==0);
83    
84        DataArrayView myDataView = myData.getDataPoint(0,0);
85        assert(!myDataView.isEmpty());
86        assert(myDataView.getOffset()==0);
87        assert(myDataView.getRank()==0);
88        assert(myDataView.noValues()==1);
89        assert(myDataView.getShape().size()==0);
90        assert(myDataView()==0.0);
91    
92        // Test non-existent tag returns the default value.
93        myDataView = myData.getDataPointByTag(1);
94        assert(!myDataView.isEmpty());
95        assert(myDataView.getOffset()==0);
96        assert(myDataView.getRank()==0);
97        assert(myDataView.noValues()==1);
98        assert(myDataView.getShape().size()==0);
99        assert(myDataView()==0.0);
100    
101        myDataView = myData.getDefaultValue();
102        assert(!myDataView.isEmpty());
103        assert(myDataView.getOffset()==0);
104        assert(myDataView.getRank()==0);
105        assert(myDataView.noValues()==1);
106        assert(myDataView.getShape().size()==0);
107        assert(myDataView()==0.0);
108    
109        // use a non-existent tag so we get a pointer to
110        // the first element of the data array
111        double* sampleData=myData.getSampleDataByTag(9);
112        for (int i=0; i<myData.getLength(); i++) {
113          assert(sampleData[i]==i);
114      }      }
115    
116    }    }
117    
118    {    {
119      cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;      cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
120      DataTagged value;  
121      value.getPointDataView()()=0.0;      DataArrayView::ShapeType viewShape;
122      DataArray vOne(1.0);      viewShape.push_back(3);
123      DataArray vTwo(2.0);  
124      value.addTaggedValue(1,vOne.getView());      DataTagged::TagListType keys;
125      value.addTaggedValue(2,vTwo.getView());  
126      DataArrayView::ShapeType shape;      DataTagged::ValueListType values;
127      shape.push_back(2);  
128      shape.push_back(5);      DataArrayView::ValueType viewData(3);
129      value.reshapeDataPoint(shape);      for (int i=0;i<viewShape[0];i++) {
130      for (int j=0;j<shape[1];++j) {        viewData[i]=i;
       for (int i=0;i<shape[0];++i) {  
     assert(value.getDefaultValue()(i,j)==0.0);  
     assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());  
     assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());  
       }  
131      }      }
132        DataArrayView myView(viewData,viewShape);
133    
134        DataTagged myData(keys,values,myView,FunctionSpace());
135        DataTagged right(keys,values,myView,FunctionSpace());
136    
137        binaryOp(myData,right,plus<double>());
138    
139        //cout << myData.toString() << endl;
140    
141        assert(myData.getNumSamples()==1);
142        assert(myData.getNumDPPSample()==1);
143    
144        assert(myData.validSamplePointNo(0));
145        assert(myData.validSampleNo(0));
146        assert(!myData.validSamplePointNo(1));
147        assert(!myData.validSampleNo(1));
148    
149        // data-point 0 has tag number 1 by default
150        assert(myData.getTagNumber(0)==1);
151    
152        assert(!myData.isCurrentTag(1));
153    
154        assert(myData.getTagLookup().size()==0);
155    
156        assert(myData.getLength()==3);
157    
158        assert(myData.getPointOffset(0,0)==0);
159    
160        DataArrayView myDataView = myData.getDefaultValue();
161        assert(!myDataView.isEmpty());
162        assert(myDataView.getOffset()==0);
163        assert(myDataView.getRank()==1);
164        assert(myDataView.noValues()==3);
165        assert(myDataView.getShape().size()==1);
166        assert(myDataView(0)==0);
167        assert(myDataView(1)==2);
168        assert(myDataView(2)==4);
169    
170        // use a non-existent tag so we get a pointer to
171        // the first element of the data array
172        double* sampleData=myData.getSampleDataByTag(9);
173        for (int i=0; i<myData.getLength(); i++) {
174          assert(sampleData[i]==i*2);
175        }
176    
177    }    }
 }  
178    
179  void DataTaggedTestCase::testOperations() {    {
180        cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
181    
182    cout << endl;      DataTagged myData;
183        DataTagged right;
184    
185        DataVector vOneData(1, 1.0 ,1);
186        // create a view with an empty shape, a scalar.
187        DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
188    
189        myData.addTaggedValue(1,vOneView);
190        right.addTaggedValue(1,vOneView);
191    
192        binaryOp(myData,right,plus<double>());
193    
194        assert(myData.getNumSamples()==1);
195        assert(myData.getNumDPPSample()==1);
196    
197        assert(myData.validSamplePointNo(0));
198        assert(myData.validSampleNo(0));
199        assert(!myData.validSamplePointNo(1));
200        assert(!myData.validSampleNo(1));
201    
202        // data-point 0 has tag number 1 by default
203        assert(myData.getTagNumber(0)==1);
204    
205        assert(myData.isCurrentTag(1));
206    
207        assert(myData.getTagLookup().size()==1);
208    
209        assert(myData.getLength()==2);
210    
211        assert(myData.getPointOffset(0,0)==1);
212    
213        // check result value for tag "1"
214        DataArrayView myDataView = myData.getDataPointByTag(1);
215        assert(!myDataView.isEmpty());
216        assert(myDataView.getOffset()==1);
217        assert(myDataView.getRank()==0);
218        assert(myDataView.noValues()==1);
219        assert(myDataView.getShape().size()==0);
220        assert(myDataView()==2.0);
221    
222        // check result for default value
223        myDataView = myData.getDefaultValue();
224        assert(!myDataView.isEmpty());
225        assert(myDataView.getOffset()==0);
226        assert(myDataView.getRank()==0);
227        assert(myDataView.noValues()==1);
228        assert(myDataView.getShape().size()==0);
229        assert(myDataView()==0.0);
230    
231        // use a non-existent tag so we get a pointer to
232        // the first element of the data array
233        double* sampleData=myData.getSampleDataByTag(9);
234        for (int i=0; i<myData.getLength(); i++) {
235          assert(sampleData[i]==i*2);
236        }
237    
238      }
239    
240      {
241        cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
242    
243        DataTagged myData;
244        DataTagged right;
245    
246        // it's important that default values are different, as we need to be able to
247        // verify that the tag values in each object are being added to the correct
248        // default values - since the tag lists don't match, the default values will
249        // 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>());
268    
269        //cout << myData.toString() << endl;
270    
271        assert(myData.getNumSamples()==1);
272        assert(myData.getNumDPPSample()==1);
273    
274        assert(myData.validSamplePointNo(0));
275        assert(myData.validSampleNo(0));
276        assert(!myData.validSamplePointNo(1));
277        assert(!myData.validSampleNo(1));
278    
279        // data-point 0 has tag number 1 by default
280        assert(myData.getTagNumber(0)==1);
281    
282        assert(myData.isCurrentTag(1));
283        assert(myData.isCurrentTag(2));
284    
285        assert(myData.getTagLookup().size()==2);
286    
287        assert(myData.getLength()==3);
288    
289        assert(myData.getPointOffset(0,0)==1);
290    
291        // check result value for tag "1"
292        DataArrayView myDataView = myData.getDataPointByTag(1);
293        assert(!myDataView.isEmpty());
294        assert(myDataView.getOffset()==1);
295        assert(myDataView.getRank()==0);
296        assert(myDataView.noValues()==1);
297        assert(myDataView.getShape().size()==0);
298        assert(myDataView()==5.0);
299    
300        // check result value for tag "2"
301        myDataView = myData.getDataPointByTag(2);
302        assert(!myDataView.isEmpty());
303        assert(myDataView.getOffset()==2);
304        assert(myDataView.getRank()==0);
305        assert(myDataView.noValues()==1);
306        assert(myDataView.getShape().size()==0);
307        assert(myDataView()==5.0);
308    
309        // check result for default value
310        myDataView = myData.getDefaultValue();
311        assert(!myDataView.isEmpty());
312        assert(myDataView.getOffset()==0);
313        assert(myDataView.getRank()==0);
314        assert(myDataView.noValues()==1);
315        assert(myDataView.getShape().size()==0);
316        assert(myDataView()==3.0);
317    
318        // use a non-existent tag so we get a pointer to
319        // the first element of the data array
320        double* sampleData=myData.getSampleDataByTag(9);
321        assert(sampleData[0]==3);
322        assert(sampleData[1]==5);
323        assert(sampleData[2]==5);
324    
325      }
326    
327    {    {
328      DataTagged left;      cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
329    
330        DataTagged myData;
331      DataTagged right;      DataTagged right;
332    
333      cout << "\tTest default DataTagged contains only a default value." << endl;      // it's important that default values are different, as we need to be able to
334      binaryOp(left,right,plus<double>());      // verify that the tag values in each object are being added to the correct
335      assert(left.getPointDataView()()==0);      // default values - since the tag lists don't match, the default values will
336      assert(right.getPointDataView()()==0);      // be used for missing tags in each object
337        myData.getDefaultValue()()=2.0;
338      cout << "\tTest binaryOp(plus)." << endl;      right.getDefaultValue()()=3.0;
339      DataArray vOne(1.0);  
340      DataArray vTwo(2.0);      DataVector vOneData(1, 1.0 ,1);
341      right.addTaggedValue(1,vOne.getView());      // create a view with an empty shape, a scalar.
342      right.addTaggedValue(2,vTwo.getView());      DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
343      binaryOp(left,right,plus<double>());  
344      assert(left.getPointDataView()()==0);      myData.addTaggedValue(1,vOneView);
345      assert(left.getDataPointByTag(1)==vOne.getView());      myData.addTaggedValue(2,vOneView);
346      assert(left.getDataPointByTag(2)==vTwo.getView());      right.addTaggedValue(2,vOneView);
347        right.addTaggedValue(3,vOneView);
348      cout << "\tTest binaryOp(multiplies)." << endl;  
349      DataArray vZero(0.0);      //cout << myData.toString() << endl;
350      right.setTaggedValue(1,vZero.getView());      //cout << right.toString() << endl;
351      right.setTaggedValue(2,vZero.getView());  
352      binaryOp(left,right,multiplies<double>());      binaryOp(myData,right,plus<double>());
353      assert(left.getPointDataView()()==0);  
354      assert(left.getDataPointByTag(1)==vZero.getView());      //cout << myData.toString() << endl;
355      assert(left.getDataPointByTag(2)==vZero.getView());  
356        assert(myData.getNumSamples()==1);
357        assert(myData.getNumDPPSample()==1);
358    
359        assert(myData.validSamplePointNo(0));
360        assert(myData.validSampleNo(0));
361        assert(!myData.validSamplePointNo(1));
362        assert(!myData.validSampleNo(1));
363    
364        // data-point 0 has tag number 1 by default
365        assert(myData.getTagNumber(0)==1);
366    
367        assert(myData.isCurrentTag(1));
368        assert(myData.isCurrentTag(2));
369        assert(myData.isCurrentTag(3));
370    
371        assert(myData.getTagLookup().size()==3);
372    
373        assert(myData.getLength()==4);
374    
375        assert(myData.getPointOffset(0,0)==1);
376    
377        // check result value for tag "1"
378        DataArrayView myDataView = myData.getDataPointByTag(1);
379        assert(!myDataView.isEmpty());
380        assert(myDataView.getOffset()==1);
381        assert(myDataView.getRank()==0);
382        assert(myDataView.noValues()==1);
383        assert(myDataView.getShape().size()==0);
384        assert(myDataView()==4.0);
385    
386        // check result value for tag "2"
387        myDataView = myData.getDataPointByTag(2);
388        assert(!myDataView.isEmpty());
389        assert(myDataView.getOffset()==2);
390        assert(myDataView.getRank()==0);
391        assert(myDataView.noValues()==1);
392        assert(myDataView.getShape().size()==0);
393        assert(myDataView()==2.0);
394    
395        // check result value for tag "3"
396        myDataView = myData.getDataPointByTag(3);
397        assert(!myDataView.isEmpty());
398        assert(myDataView.getOffset()==3);
399        assert(myDataView.getRank()==0);
400        assert(myDataView.noValues()==1);
401        assert(myDataView.getShape().size()==0);
402        assert(myDataView()==3.0);
403    
404        // check result for default value
405        myDataView = myData.getDefaultValue();
406        assert(!myDataView.isEmpty());
407        assert(myDataView.getOffset()==0);
408        assert(myDataView.getRank()==0);
409        assert(myDataView.noValues()==1);
410        assert(myDataView.getShape().size()==0);
411        assert(myDataView()==5.0);
412    
413        // use a non-existent tag so we get a pointer to
414        // the first element of the data array
415        double* sampleData=myData.getSampleDataByTag(9);
416        assert(sampleData[0]==5);
417        assert(sampleData[1]==4);
418        assert(sampleData[2]==2);
419        assert(sampleData[3]==3);
420    
421    }    }
422    
423    {    {
424        cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
425    
426      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
427      viewShape.push_back(3);      viewShape.push_back(3);
428      DataArrayView::ValueType viewData(3);  
429      DataTagged::TagListType keys;      DataTagged::TagListType keys;
430    
431      DataTagged::ValueListType values;      DataTagged::ValueListType values;
432      for (int i=0;i<viewShape[0];++i) {  
433        DataArrayView::ValueType viewData(3);
434        for (int i=0;i<viewShape[0];i++) {
435        viewData[i]=i;        viewData[i]=i;
436      }      }
437      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
438      cout << "\tCreate tagged data with no tag values just a default." << endl;  
439      DataTagged left(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
440      DataTagged right(keys,values,myView,FunctionSpace());      DataTagged right(keys,values,myView,FunctionSpace());
441      binaryOp(left,right,minus<double>());  
442      for (int i=0;i<viewShape[0];++i) {      binaryOp(myData,right,multiplies<double>());
443        assert(left.getDefaultValue()(i)==0);  
444      }      //cout << myData.toString() << endl;
445      double mVal=10.0;  
446      for (int i=0;i<viewShape[0];++i) {      assert(myData.getNumSamples()==1);
447        viewData[i]=i*mVal;      assert(myData.getNumDPPSample()==1);
448      }  
449      cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      assert(myData.validSamplePointNo(0));
450      binaryOp(left,myView,minus<double>());      assert(myData.validSampleNo(0));
451      for (int i=0;i<viewShape[0];++i) {      assert(!myData.validSamplePointNo(1));
452        assert(left.getDefaultValue()(i)==-(i*mVal));      assert(!myData.validSampleNo(1));
453    
454        // data-point 0 has tag number 1 by default
455        assert(myData.getTagNumber(0)==1);
456    
457        assert(!myData.isCurrentTag(1));
458    
459        assert(myData.getTagLookup().size()==0);
460    
461        assert(myData.getLength()==3);
462    
463        assert(myData.getPointOffset(0,0)==0);
464    
465        DataArrayView myDataView = myData.getDefaultValue();
466        assert(!myDataView.isEmpty());
467        assert(myDataView.getOffset()==0);
468        assert(myDataView.getRank()==1);
469        assert(myDataView.noValues()==3);
470        assert(myDataView.getShape().size()==1);
471        assert(myDataView(0)==0);
472        assert(myDataView(1)==1);
473        assert(myDataView(2)==4);
474    
475        // use a non-existent tag so we get a pointer to
476        // the first element of the data array
477        double* sampleData=myData.getSampleDataByTag(9);
478        for (int i=0; i<myData.getLength(); i++) {
479          assert(sampleData[i]==i*i);
480      }      }
481    
482    }    }
483    
484    {    {
485      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;  
486      DataTagged data;      cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
487      unaryOp(data,negate<double>());  
488      assert(data.getDefaultValue()()==0);      DataTagged myData;
489      DataArray vOne(1);  
490      binaryOp(data,vOne.getView(),plus<double>());      DataVector vOneData(1, 1.0 ,1);
491      assert(data.getDefaultValue()()==1);      // create a view with an empty shape, a scalar.
492      unaryOp(data,negate<double>());      DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
493      assert(data.getDefaultValue()()==-1);  
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 unaryOp(negate) on DataTagged with 3 tags." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
572      DataArrayView::ShapeType vShape;  
573      vShape.push_back(3);      DataTagged myData;
574      vShape.push_back(2);      DataTagged right;
575      vShape.push_back(1);  
576      DataArray defData(vShape,0.0);      // it's important that default values are different, as we need to be able to
577      DataArrayView& defView=defData.getView();      // verify that the tag values in each object are being added to the correct
578      DataArray tOneData(vShape,1.0);      // default values - since the tag lists don't match, the default values will
579      DataArrayView& tOneView=tOneData.getView();      // be used for missing tags in each object
580      DataArray tTwoData(vShape,2.0);      myData.getDefaultValue()()=2.0;
581      DataArrayView& tTwoView=tTwoData.getView();      right.getDefaultValue()()=3.0;
582      DataArray tThreeData(vShape,3.0);  
583      DataArrayView& tThreeView=tThreeData.getView();      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>());
600    
601        //cout << myData.toString() << endl;
602    
603        assert(myData.getNumSamples()==1);
604        assert(myData.getNumDPPSample()==1);
605    
606        assert(myData.validSamplePointNo(0));
607        assert(myData.validSampleNo(0));
608        assert(!myData.validSamplePointNo(1));
609        assert(!myData.validSampleNo(1));
610    
611        // data-point 0 has tag number 1 by default
612        assert(myData.getTagNumber(0)==1);
613    
614        assert(myData.isCurrentTag(1));
615        assert(myData.isCurrentTag(2));
616        assert(myData.isCurrentTag(3));
617    
618        assert(myData.getTagLookup().size()==3);
619    
620        assert(myData.getLength()==4);
621    
622        assert(myData.getPointOffset(0,0)==1);
623    
624        // check result value for tag "1"
625        DataArrayView myDataView = myData.getDataPointByTag(1);
626        assert(!myDataView.isEmpty());
627        assert(myDataView.getOffset()==1);
628        assert(myDataView.getRank()==0);
629        assert(myDataView.noValues()==1);
630        assert(myDataView.getShape().size()==0);
631        assert(myDataView()==3.0);
632    
633        // check result value for tag "2"
634        myDataView = myData.getDataPointByTag(2);
635        assert(!myDataView.isEmpty());
636        assert(myDataView.getOffset()==2);
637        assert(myDataView.getRank()==0);
638        assert(myDataView.noValues()==1);
639        assert(myDataView.getShape().size()==0);
640        assert(myDataView()==2.0);
641    
642        // check result value for tag "3"
643        myDataView = myData.getDataPointByTag(3);
644        assert(!myDataView.isEmpty());
645        assert(myDataView.getOffset()==3);
646        assert(myDataView.getRank()==0);
647        assert(myDataView.noValues()==1);
648        assert(myDataView.getShape().size()==0);
649        assert(myDataView()==4.0);
650    
651        // check result for default value
652        myDataView = myData.getDefaultValue();
653        assert(!myDataView.isEmpty());
654        assert(myDataView.getOffset()==0);
655        assert(myDataView.getRank()==0);
656        assert(myDataView.noValues()==1);
657        assert(myDataView.getShape().size()==0);
658        assert(myDataView()==6.0);
659    
660        // use a non-existent tag so we get a pointer to
661        // the first element of the data array
662        double* sampleData=myData.getSampleDataByTag(9);
663        assert(sampleData[0]==6);
664        assert(sampleData[1]==3);
665        assert(sampleData[2]==2);
666        assert(sampleData[3]==4);
667    
668      }
669    
670      {
671        cout << "\tTest unaryOp negate on default DataTagged object." << endl;
672    
673        DataTagged myData;
674    
675        unaryOp(myData,negate<double>());
676    
677        //cout << myData.toString() << endl;
678    
679        assert(myData.getNumSamples()==1);
680        assert(myData.getNumDPPSample()==1);
681    
682        assert(myData.validSamplePointNo(0));
683        assert(myData.validSampleNo(0));
684        assert(!myData.validSamplePointNo(1));
685        assert(!myData.validSampleNo(1));
686    
687        // data-point 0 has tag number 1 by default
688        assert(myData.getTagNumber(0)==1);
689    
690        assert(!myData.isCurrentTag(1));
691    
692        assert(myData.getTagLookup().size()==0);
693    
694        assert(myData.getLength()==1);
695    
696        assert(myData.getPointOffset(0,0)==0);
697    
698        DataArrayView myDataView = myData.getDataPoint(0,0);
699        assert(!myDataView.isEmpty());
700        assert(myDataView.getOffset()==0);
701        assert(myDataView.getRank()==0);
702        assert(myDataView.noValues()==1);
703        assert(myDataView.getShape().size()==0);
704        assert(myDataView()==0.0);
705    
706        // Test non-existent tag returns the default value.
707        myDataView = myData.getDataPointByTag(1);
708        assert(!myDataView.isEmpty());
709        assert(myDataView.getOffset()==0);
710        assert(myDataView.getRank()==0);
711        assert(myDataView.noValues()==1);
712        assert(myDataView.getShape().size()==0);
713        assert(myDataView()==0.0);
714    
715        myDataView = myData.getDefaultValue();
716        assert(!myDataView.isEmpty());
717        assert(myDataView.getOffset()==0);
718        assert(myDataView.getRank()==0);
719        assert(myDataView.noValues()==1);
720        assert(myDataView.getShape().size()==0);
721        assert(myDataView()==0.0);
722    
723        // use a non-existent tag so we get a pointer to
724        // the first element of the data array
725        double* sampleData=myData.getSampleDataByTag(9);
726        for (int i=0; i<myData.getLength(); i++) {
727          assert(sampleData[i]==i);
728        }
729    
730      }
731    
732      {
733        cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
734    
735        DataArrayView::ShapeType viewShape;
736        viewShape.push_back(3);
737    
738      DataTagged::TagListType keys;      DataTagged::TagListType keys;
739    
740      DataTagged::ValueListType values;      DataTagged::ValueListType values;
741      keys.push_back(1);  
742      keys.push_back(2);      DataArrayView::ValueType viewData(3);
743      keys.push_back(3);      for (int i=0;i<viewShape[0];i++) {
744      values.push_back(tOneView);        viewData[i]=i;
745      values.push_back(tTwoView);      }
746      values.push_back(tThreeView);      DataArrayView myView(viewData,viewShape);
747      DataTagged tData(keys,values,defView,FunctionSpace());  
748      unaryOp(tData,negate<double>());      DataTagged myData(keys,values,myView,FunctionSpace());
749      unaryOp(tData,negate<double>());  
750      assert(tData.getDataPointByTag(1)==tOneView);      unaryOp(myData,negate<double>());
751      assert(tData.getDataPointByTag(2)==tTwoView);  
752      assert(tData.getDataPointByTag(3)==tThreeView);      //cout << myData.toString() << endl;
753    
754        assert(myData.getNumSamples()==1);
755        assert(myData.getNumDPPSample()==1);
756    
757        assert(myData.validSamplePointNo(0));
758        assert(myData.validSampleNo(0));
759        assert(!myData.validSamplePointNo(1));
760        assert(!myData.validSampleNo(1));
761    
762        // data-point 0 has tag number 1 by default
763        assert(myData.getTagNumber(0)==1);
764    
765        assert(!myData.isCurrentTag(1));
766    
767        assert(myData.getTagLookup().size()==0);
768    
769        assert(myData.getLength()==3);
770    
771        assert(myData.getPointOffset(0,0)==0);
772    
773        DataArrayView myDataView = myData.getDefaultValue();
774        assert(!myDataView.isEmpty());
775        assert(myDataView.getOffset()==0);
776        assert(myDataView.getRank()==1);
777        assert(myDataView.noValues()==3);
778        assert(myDataView.getShape().size()==1);
779        assert(myDataView(0)==0);
780        assert(myDataView(1)==-1);
781        assert(myDataView(2)==-2);
782    
783        // use a non-existent tag so we get a pointer to
784        // the first element of the data array
785        double* sampleData=myData.getSampleDataByTag(9);
786        for (int i=0; i<myData.getLength(); i++) {
787          assert(sampleData[i]==0-i);
788        }
789    
790      }
791    
792      {
793        cout << "\tTest unnaryOp negate on DataTagged object with two tags." << endl;
794    
795        DataTagged myData;
796    
797        DataVector vOneData(1, 1.0 ,1);
798        // create a view with an empty shape, a scalar.
799        DataArrayView vOneView(vOneData,DataArrayView::ShapeType());
800    
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>());
809    
810        assert(myData.getNumSamples()==1);
811        assert(myData.getNumDPPSample()==1);
812    
813        assert(myData.validSamplePointNo(0));
814        assert(myData.validSampleNo(0));
815        assert(!myData.validSamplePointNo(1));
816        assert(!myData.validSampleNo(1));
817    
818        // data-point 0 has tag number 1 by default
819        assert(myData.getTagNumber(0)==1);
820    
821        assert(myData.isCurrentTag(1));
822        assert(myData.isCurrentTag(2));
823    
824        assert(myData.getTagLookup().size()==2);
825    
826        assert(myData.getLength()==3);
827    
828        assert(myData.getPointOffset(0,0)==1);
829    
830        // check result value for tag "1"
831        DataArrayView myDataView = myData.getDataPointByTag(1);
832        assert(!myDataView.isEmpty());
833        assert(myDataView.getOffset()==1);
834        assert(myDataView.getRank()==0);
835        assert(myDataView.noValues()==1);
836        assert(myDataView.getShape().size()==0);
837        assert(myDataView()==-1.0);
838    
839        // check result value for tag "2"
840        myDataView = myData.getDataPointByTag(2);
841        assert(!myDataView.isEmpty());
842        assert(myDataView.getOffset()==2);
843        assert(myDataView.getRank()==0);
844        assert(myDataView.noValues()==1);
845        assert(myDataView.getShape().size()==0);
846        assert(myDataView()==-2.0);
847    
848        // check result for default value
849        myDataView = myData.getDefaultValue();
850        assert(!myDataView.isEmpty());
851        assert(myDataView.getOffset()==0);
852        assert(myDataView.getRank()==0);
853        assert(myDataView.noValues()==1);
854        assert(myDataView.getShape().size()==0);
855        assert(myDataView()==0.0);
856    
857        // use a non-existent tag so we get a pointer to
858        // the first element of the data array
859        double* sampleData=myData.getSampleDataByTag(9);
860        for (int i=0; i<myData.getLength(); i++) {
861          assert(sampleData[i]==0-i);
862        }
863    
864    }    }
865    
866  }  }
# Line 238  void DataTaggedTestCase::testAddTaggedVa Line 916  void DataTaggedTestCase::testAddTaggedVa
916      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
917      assert(myDataView()==0.0);      assert(myDataView()==0.0);
918    
919        // use a non-existent tag so we get a pointer to
920        // the first element of the data array
921        double* sampleData=myData.getSampleDataByTag(9);
922        for (int i=0; i<myData.getLength(); i++) {
923          assert(sampleData[i]==0);
924        }
925    
926    }    }
927    
928    {    {
# Line 293  void DataTaggedTestCase::testAddTaggedVa Line 978  void DataTaggedTestCase::testAddTaggedVa
978      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
979      assert(myDataView()==0.0);      assert(myDataView()==0.0);
980    
981        // use a non-existent tag so we get a pointer to
982        // the first element of the data array
983        double* sampleData=myData.getSampleDataByTag(9);
984        for (int i=0; i<myData.getLength(); i++) {
985          assert(sampleData[i]==i);
986        }
987    
988    }    }
989    
990    {    {
# Line 368  void DataTaggedTestCase::testAddTaggedVa Line 1060  void DataTaggedTestCase::testAddTaggedVa
1060      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1061      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1062    
1063        // use a non-existent tag so we get a pointer to
1064        // the first element of the data array
1065        double* sampleData=myData.getSampleDataByTag(9);
1066        for (int i=0; i<myData.getLength(); i++) {
1067          if (i==0) {
1068            assert(sampleData[i]==0);
1069          } else {
1070            assert(sampleData[i]==1);
1071          }
1072        }
1073    
1074    }    }
1075    
1076    {    {
# Line 451  void DataTaggedTestCase::testAddTaggedVa Line 1154  void DataTaggedTestCase::testAddTaggedVa
1154      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1155      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1156    
1157        // use a non-existent tag so we get a pointer to
1158        // the first element of the data array
1159        double* sampleData=myData.getSampleDataByTag(9);
1160        for (int i=0; i<myData.getLength(); i++) {
1161          assert(sampleData[i]==i);
1162        }
1163    
1164    }    }
1165    
1166    {    {
# Line 521  void DataTaggedTestCase::testAddTaggedVa Line 1231  void DataTaggedTestCase::testAddTaggedVa
1231      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1232      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1233    
1234        // use a non-existent tag so we get a pointer to
1235        // the first element of the data array
1236        double* sampleData=myData.getSampleDataByTag(9);
1237        for (int i=0; i<myData.getLength(); i++) {
1238          assert(sampleData[i]==i%3);
1239        }
1240    
1241    }    }
1242    
1243    {    {
# Line 546  void DataTaggedTestCase::testAddTaggedVa Line 1263  void DataTaggedTestCase::testAddTaggedVa
1263    
1264      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1265      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1266        viewData1[i]=i+1;        viewData1[i]=i+3;
1267      }      }
1268      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1269      values.push_back(myView1);      values.push_back(myView1);
# Line 571  void DataTaggedTestCase::testAddTaggedVa Line 1288  void DataTaggedTestCase::testAddTaggedVa
1288      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1289      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1290      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1291      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1292      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1293      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1294    
1295      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
1296      assert(myDataView==myView1);      assert(myDataView==myView1);
# Line 582  void DataTaggedTestCase::testAddTaggedVa Line 1299  void DataTaggedTestCase::testAddTaggedVa
1299      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1300      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1301      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1302      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1303      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1304      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1305    
1306      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
1307      assert(myDataView==myView);      assert(myDataView==myView);
# Line 597  void DataTaggedTestCase::testAddTaggedVa Line 1314  void DataTaggedTestCase::testAddTaggedVa
1314      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1315      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1316    
1317        // use a non-existent tag so we get a pointer to
1318        // the first element of the data array
1319        double* sampleData=myData.getSampleDataByTag(9);
1320        for (int i=0; i<myData.getLength(); i++) {
1321          assert(sampleData[i]==i);
1322        }
1323    
1324    }    }
1325    
1326    {    {
# Line 624  void DataTaggedTestCase::testAddTaggedVa Line 1348  void DataTaggedTestCase::testAddTaggedVa
1348    
1349      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1350      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1351        viewData1[i]=i+1;        viewData1[i]=3;
1352      }      }
1353      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1354      values.push_back(myView1);      values.push_back(myView1);
# Line 651  void DataTaggedTestCase::testAddTaggedVa Line 1375  void DataTaggedTestCase::testAddTaggedVa
1375      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1376      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1377      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1378      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1379      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1380      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1381    
1382      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
# Line 662  void DataTaggedTestCase::testAddTaggedVa Line 1386  void DataTaggedTestCase::testAddTaggedVa
1386      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1387      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1388      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1389      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1390      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1391      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1392    
1393      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 673  void DataTaggedTestCase::testAddTaggedVa Line 1397  void DataTaggedTestCase::testAddTaggedVa
1397      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1398      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1399      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1400      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1401      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1402      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1403    
1404      myDataView = myData.getDataPointByTag(3);      myDataView = myData.getDataPointByTag(3);
# Line 684  void DataTaggedTestCase::testAddTaggedVa Line 1408  void DataTaggedTestCase::testAddTaggedVa
1408      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1409      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1410      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1411      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1412      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1413      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1414    
1415      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 699  void DataTaggedTestCase::testAddTaggedVa Line 1423  void DataTaggedTestCase::testAddTaggedVa
1423      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1424      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1425    
1426        // use a non-existent tag so we get a pointer to
1427        // the first element of the data array
1428        double* sampleData=myData.getSampleDataByTag(9);
1429        for (int i=0; i<myData.getLength(); i++) {
1430          if (i<3) {
1431            assert(sampleData[i]==i);
1432          } else {
1433            assert(sampleData[i]==3);
1434          }
1435        }
1436    
1437    }    }
1438    
1439    {    {
# Line 815  void DataTaggedTestCase::testAddTaggedVa Line 1550  void DataTaggedTestCase::testAddTaggedVa
1550      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1551      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1552    
1553        // use a non-existent tag so we get a pointer to
1554        // the first element of the data array
1555        double* sampleData=myData.getSampleDataByTag(9);
1556        for (int i=0; i<myData.getLength(); i++) {
1557          if (i<3) {
1558            assert(sampleData[i]==i);
1559          } else if ((i>=3) && (i<6)) {
1560            assert(sampleData[i]==i-2);
1561          } else if ((i>=6) && (i<9)) {
1562            assert(sampleData[i]==i-4);
1563          } else  {
1564            assert(sampleData[i]==i-6);
1565          }
1566        }
1567    
1568    }    }
1569    
1570    {    {
# Line 839  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 884  void DataTaggedTestCase::testAddTaggedVa Line 1637  void DataTaggedTestCase::testAddTaggedVa
1637      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1638      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1639    
1640        // use a non-existent tag so we get a pointer to
1641        // the first element of the data array
1642        double* sampleData=myData.getSampleDataByTag(9);
1643        for (int i=0; i<myData.getLength(); i++) {
1644          if (i<3) {
1645            assert(sampleData[i]==i);
1646          } else if ((i>=3) && (i<6)) {
1647            assert(sampleData[i]==i-2);
1648          } else if ((i>=6) && (i<9)) {
1649            assert(sampleData[i]==i-4);
1650          } else if ((i>=9) && (i<12)) {
1651            assert(sampleData[i]==i-6);
1652          } else {
1653            assert(sampleData[i]==i-12);
1654          }
1655        }
1656    
1657    }    }
1658    
1659    {    {
# Line 908  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 935  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 950  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 960  void DataTaggedTestCase::testAddTaggedVa Line 1734  void DataTaggedTestCase::testAddTaggedVa
1734      assert(myDataView(1)==5);      assert(myDataView(1)==5);
1735      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1736    
1737        // use a non-existent tag so we get a pointer to
1738        // the first element of the data array
1739        double* sampleData=myData.getSampleDataByTag(9);
1740        for (int i=0; i<myData.getLength(); i++) {
1741          if (i<3) {
1742            assert(sampleData[i]==i);
1743          } else if ((i>=3) && (i<6)) {
1744            assert(sampleData[i]==i-2);
1745          } else if ((i>=6) && (i<9)) {
1746            assert(sampleData[i]==i-4);
1747          } else if ((i>=9) && (i<12)) {
1748            assert(sampleData[i]==i-6);
1749          } else {
1750            assert(sampleData[i]==i-8);
1751          }
1752        }
1753    
1754    }    }
1755    
1756    {    {
# Line 984  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 1013  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 1030  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 1041  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 1052  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 1062  void DataTaggedTestCase::testAddTaggedVa Line 1857  void DataTaggedTestCase::testAddTaggedVa
1857      assert(myDataView(1)==5);      assert(myDataView(1)==5);
1858      assert(myDataView(2)==6);      assert(myDataView(2)==6);
1859    
1860        // use a non-existent tag so we get a pointer to
1861        // the first element of the data array
1862        double* sampleData=myData.getSampleDataByTag(9);
1863        for (int i=0; i<myData.getLength(); i++) {
1864          if (i<3) {
1865            assert(sampleData[i]==i);
1866          } else if ((i>=3) && (i<6)) {
1867            assert(sampleData[i]==i-2);
1868          } else if ((i>=6) && (i<9)) {
1869            assert(sampleData[i]==i-4);
1870          } else if ((i>=9) && (i<12)) {
1871            assert(sampleData[i]==i-6);
1872          } else if ((i>=12) && (i<15)) {
1873            assert(sampleData[i]==i-8);
1874          } else if ((i>=15) && (i<18)) {
1875            assert(sampleData[i]==i-11);
1876          } else {
1877            assert(sampleData[i]==i-14);
1878          }
1879        }
1880    
1881    }    }
1882    
1883    {    {
# Line 1086  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 1116  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 1147  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 1158  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 1169  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 1179  void DataTaggedTestCase::testAddTaggedVa Line 2001  void DataTaggedTestCase::testAddTaggedVa
2001      assert(myDataView(1)==7);      assert(myDataView(1)==7);
2002      assert(myDataView(2)==8);      assert(myDataView(2)==8);
2003    
2004        // use a non-existent tag so we get a pointer to
2005        // the first element of the data array
2006        double* sampleData=myData.getSampleDataByTag(9);
2007        for (int i=0; i<myData.getLength(); i++) {
2008          if (i<3) {
2009            assert(sampleData[i]==i);
2010          } else if ((i>=3) && (i<6)) {
2011            assert(sampleData[i]==i-2);
2012          } else if ((i>=6) && (i<9)) {
2013            assert(sampleData[i]==i-4);
2014          } else if ((i>=9) && (i<12)) {
2015            assert(sampleData[i]==i-6);
2016          } else if ((i>=12) && (i<15)) {
2017            assert(sampleData[i]==i-8);
2018          } else if ((i>=15) && (i<18)) {
2019            assert(sampleData[i]==i-10);
2020          } else {
2021            assert(sampleData[i]==i-12);
2022          }
2023        }
2024    
2025    }    }
2026    
2027  }  }
# Line 1209  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 1245  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 1255  void DataTaggedTestCase::testSetTaggedVa Line 2101  void DataTaggedTestCase::testSetTaggedVa
2101      assert(myDataView(1)==6);      assert(myDataView(1)==6);
2102      assert(myDataView(2)==7);      assert(myDataView(2)==7);
2103    
2104        // use a non-existent tag so we get a pointer to
2105        // the first element of the data array
2106        double* sampleData=myData.getSampleDataByTag(9);
2107        for (int i=0; i<myData.getLength(); i++) {
2108          if (i<3) {
2109            assert(sampleData[i]==i);
2110          } else if ((i>=3) && (i<6)) {
2111            assert(sampleData[i]==i-2);
2112          } else if ((i>=6) && (i<9)) {
2113            assert(sampleData[i]==i-1);
2114          } else {
2115            assert(sampleData[i]==i-6);
2116          }
2117        }
2118    
2119    }    }
2120    
2121  }  }
# Line 1314  void DataTaggedTestCase::testAll() { Line 2175  void DataTaggedTestCase::testAll() {
2175      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2176      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2177    
2178        // use a non-existent tag so we get a pointer to
2179        // the first element of the data array
2180        double* sampleData=myData.getSampleDataByTag(9);
2181        for (int i=0; i<myData.getLength(); i++) {
2182          assert(sampleData[i]==i);
2183        }
2184        sampleData=myData.getSampleData(0);
2185        for (int i=0; i<myDataView.noValues(); i++) {
2186          assert(sampleData[i]==i);
2187        }
2188    
2189    }    }
2190    
2191    {    {
# Line 1390  void DataTaggedTestCase::testAll() { Line 2262  void DataTaggedTestCase::testAll() {
2262      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2263      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2264    
2265        // use a non-existent tag so we get a pointer to
2266        // the first element of the data array
2267        double* sampleData=myData.getSampleDataByTag(9);
2268        for (int i=0; i<myData.getLength(); i++) {
2269          assert(sampleData[i]==i);
2270        }
2271        sampleData=myData.getSampleDataByTag(0);
2272        for (int i=0; i<myDataView.noValues(); i++) {
2273          assert(sampleData[i]==i);
2274        }
2275    
2276    }    }
2277    
2278    {    {
# Line 1414  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 1445  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 1456  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 1467  void DataTaggedTestCase::testAll() { Line 2351  void DataTaggedTestCase::testAll() {
2351      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2352    
2353      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2354      myDataView = myData.getDataPointByTag(0);      myDataView = myData.getDataPointByTag(9);
2355      assert(myDataView==myView);      assert(myDataView==myView);
2356      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2357      assert(myDataView.getOffset()==0);      assert(myDataView.getOffset()==0);
# Line 1489  void DataTaggedTestCase::testAll() { Line 2373  void DataTaggedTestCase::testAll() {
2373      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2374      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2375    
2376        // use a non-existent tag so we get a pointer to
2377        // the first element of the data array
2378        double* sampleData=myData.getSampleDataByTag(9);
2379        for (int i=0; i<myData.getLength(); i++) {
2380          if (i<3) {
2381            assert(sampleData[i]==i);
2382          } else {
2383            assert(sampleData[i]==i-2);
2384          }
2385        }
2386        sampleData=myData.getSampleData(0);
2387        for (int i=0; i<myDataView.noValues(); i++) {
2388          assert(sampleData[i]==i+1);
2389        }
2390    
2391    }    }
2392    
2393    {    {
# Line 1515  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 1562  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 1573  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 1608  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 1619  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 1629  void DataTaggedTestCase::testAll() { Line 2531  void DataTaggedTestCase::testAll() {
2531      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2532      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2533    
2534        // use a non-existent tag so we get a pointer to
2535        // the first element of the data array
2536        double* sampleData=myData.getSampleDataByTag(9);
2537        for (int i=0; i<myData.getLength(); i++) {
2538          if (i<3) {
2539            assert(sampleData[i]==i);
2540          } else if ((i>=3) && (i<6)) {
2541            assert(sampleData[i]==i-2);
2542          } else if ((i>=6) && (i<9)) {
2543            assert(sampleData[i]==i-4);
2544          } else {
2545            assert(sampleData[i]==i-6);
2546          }
2547        }
2548        sampleData=myData.getSampleData(0);
2549        for (int i=0; i<myDataView.noValues(); i++) {
2550          assert(sampleData[i]==i+1);
2551        }
2552    
2553      }
2554    
2555    }
2556    
2557    void DataTaggedTestCase::testCopyConstructors() {
2558    
2559      cout << endl;
2560    
2561      {
2562    
2563        cout << "\tTest DataTagged copy constructor for DataTagged with multiple tags." << endl;
2564    
2565        // the one data-point has tag value "1"
2566    
2567        DataTagged::TagListType keys;
2568        keys.push_back(1);
2569        keys.push_back(2);
2570        keys.push_back(3);
2571    
2572        DataTagged::ValueListType values;
2573    
2574        DataArrayView::ShapeType viewShape;
2575        viewShape.push_back(3);
2576    
2577        // default value
2578        DataArrayView::ValueType viewData(3);
2579        for (int i=0;i<viewShape[0];i++) {
2580          viewData[i]=i;
2581        }
2582        DataArrayView myView(viewData,viewShape);
2583    
2584        // value for tag "1"
2585        DataArrayView::ValueType eOneData(viewData);
2586        DataArrayView eOneView(eOneData, viewShape);
2587        for (int i=0;i<eOneView.getShape()[0];i++) {
2588          eOneView(i)=i+1.0;
2589        }
2590        values.push_back(eOneView);
2591    
2592        // value for tag "2"
2593        DataArrayView::ValueType eTwoData(viewData);
2594        DataArrayView eTwoView(eTwoData, viewShape);
2595        for (int i=0;i<eTwoView.getShape()[0];i++) {
2596          eTwoView(i)=i+2.0;
2597        }
2598        values.push_back(eTwoView);
2599    
2600        // value for tag "3"
2601        DataArrayView::ValueType eThreeData(viewData);
2602        DataArrayView eThreeView(eThreeData, viewShape);
2603        for (int i=0;i<eThreeView.getShape()[0];i++) {
2604          eThreeView(i)=i+3.0;
2605        }
2606        values.push_back(eThreeView);
2607    
2608        DataTagged myData(keys,values,myView,FunctionSpace());
2609    
2610        DataTagged myDataCopy(myData);
2611    
2612        //cout << myDataCopy.toString() << endl;
2613    
2614        assert(myDataCopy.getNumSamples()==1);
2615        assert(myDataCopy.getNumDPPSample()==1);
2616    
2617        assert(myDataCopy.validSamplePointNo(0));
2618        assert(myDataCopy.validSampleNo(0));
2619        assert(!myDataCopy.validSamplePointNo(1));
2620        assert(!myDataCopy.validSampleNo(1));
2621    
2622        // data-point 0 has tag number 1 by default
2623        assert(myDataCopy.getTagNumber(0)==1);
2624    
2625        assert(!myDataCopy.isCurrentTag(0));
2626        assert(myDataCopy.isCurrentTag(1));
2627        assert(myDataCopy.isCurrentTag(2));
2628        assert(myDataCopy.isCurrentTag(3));
2629    
2630        assert(myDataCopy.getTagLookup().size()==3);
2631    
2632        assert(myDataCopy.getLength()==12);
2633    
2634        assert(myDataCopy.getPointOffset(0,0)==3);
2635    
2636        DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
2637        assert(myDataView==eOneView);
2638        assert(!myDataView.isEmpty());
2639        assert(myDataView.getOffset()==3);
2640        assert(myDataView.getRank()==1);
2641        assert(myDataView.noValues()==3);
2642        assert(myDataView.getShape().size()==1);
2643        assert(myDataView(0)==1);
2644        assert(myDataView(1)==2);
2645        assert(myDataView(2)==3);
2646    
2647        myDataView = myDataCopy.getDataPointByTag(1);
2648        assert(myDataView==eOneView);
2649        assert(!myDataView.isEmpty());
2650        assert(myDataView.getOffset()==3);
2651        assert(myDataView.getRank()==1);
2652        assert(myDataView.noValues()==3);
2653        assert(myDataView.getShape().size()==1);
2654        assert(myDataView(0)==1);
2655        assert(myDataView(1)==2);
2656        assert(myDataView(2)==3);
2657    
2658        // Test non-existent tag returns the default value.
2659        myDataView = myDataCopy.getDataPointByTag(0);
2660        assert(myDataView==myView);
2661        assert(!myDataView.isEmpty());
2662        assert(myDataView.getOffset()==0);
2663        assert(myDataView.getRank()==1);
2664        assert(myDataView.noValues()==3);
2665        assert(myDataView.getShape().size()==1);
2666        assert(myDataView(0)==0);
2667        assert(myDataView(1)==1);
2668        assert(myDataView(2)==2);
2669    
2670        myDataView = myDataCopy.getDefaultValue();
2671        assert(myDataView==myView);
2672        assert(!myDataView.isEmpty());
2673        assert(myDataView.getOffset()==0);
2674        assert(myDataView.getRank()==1);
2675        assert(myDataView.noValues()==3);
2676        assert(myDataView.getShape().size()==1);
2677        assert(myDataView(0)==0);
2678        assert(myDataView(1)==1);
2679        assert(myDataView(2)==2);
2680    
2681        // Test data-points held for remaining tags
2682        myDataView = myDataCopy.getDataPointByTag(2);
2683        assert(myDataView==eTwoView);
2684        assert(!myDataView.isEmpty());
2685        assert(myDataView.getOffset()==6);
2686        assert(myDataView.getRank()==1);
2687        assert(myDataView.noValues()==3);
2688        assert(myDataView.getShape().size()==1);
2689        assert(myDataView(0)==2);
2690        assert(myDataView(1)==3);
2691        assert(myDataView(2)==4);
2692    
2693        myDataView = myDataCopy.getDataPointByTag(3);
2694        assert(myDataView==eThreeView);
2695        assert(!myDataView.isEmpty());
2696        assert(myDataView.getOffset()==9);
2697        assert(myDataView.getRank()==1);
2698        assert(myDataView.noValues()==3);
2699        assert(myDataView.getShape().size()==1);
2700        assert(myDataView(0)==3);
2701        assert(myDataView(1)==4);
2702        assert(myDataView(2)==5);
2703    
2704        // use a non-existent tag so we get a pointer to
2705        // the first element of the data array
2706        double* sampleData=myDataCopy.getSampleDataByTag(9);
2707        for (int i=0; i<myData.getLength(); i++) {
2708          if (i<3) {
2709            assert(sampleData[i]==i);
2710          } else if ((i>=3) && (i<6)) {
2711            assert(sampleData[i]==i-2);
2712          } else if ((i>=6) && (i<9)) {
2713            assert(sampleData[i]==i-4);
2714          } else {
2715            assert(sampleData[i]==i-6);
2716          }
2717        }
2718    
2719      }
2720    
2721      {
2722    
2723        cout << "\tTest DataTagged copy constructor for DataConstant." << endl;
2724    
2725        // Create a DataConstant
2726        DataArrayView::ShapeType shape;
2727        DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
2728        DataArrayView pointData(data,shape);
2729        pointData()=1.0;
2730        DataConstant myConstantData(pointData, FunctionSpace());
2731    
2732        // use this DataConstant to initialise a DataTagged
2733        DataTagged myData(myConstantData);
2734    
2735        //cout << myData.toString() << endl;
2736    
2737        assert(myData.getNumSamples()==1);
2738        assert(myData.getNumDPPSample()==1);
2739    
2740        assert(myData.validSamplePointNo(0));
2741        assert(myData.validSampleNo(0));
2742        assert(!myData.validSamplePointNo(1));
2743        assert(!myData.validSampleNo(1));
2744    
2745        // data-point 0 has tag number 1 by default
2746        assert(myData.getTagNumber(0)==1);
2747    
2748        assert(!myData.isCurrentTag(1));
2749    
2750        assert(myData.getTagLookup().size()==0);
2751    
2752        assert(myData.getLength()==1);
2753    
2754        assert(myData.getPointOffset(0,0)==0);
2755    
2756        DataArrayView myDataView = myData.getDataPoint(0,0);
2757        assert(!myDataView.isEmpty());
2758        assert(myDataView.getOffset()==0);
2759        assert(myDataView.getRank()==0);
2760        assert(myDataView.noValues()==1);
2761        assert(myDataView.getShape().size()==0);
2762        assert(myDataView()==1.0);
2763    
2764        // Test non-existent tag returns the default value.
2765        myDataView = myData.getDataPointByTag(1);
2766        assert(!myDataView.isEmpty());
2767        assert(myDataView.getOffset()==0);
2768        assert(myDataView.getRank()==0);
2769        assert(myDataView.noValues()==1);
2770        assert(myDataView.getShape().size()==0);
2771        assert(myDataView()==1.0);
2772    
2773        myDataView = myData.getDefaultValue();
2774        assert(!myDataView.isEmpty());
2775        assert(myDataView.getOffset()==0);
2776        assert(myDataView.getRank()==0);
2777        assert(myDataView.noValues()==1);
2778        assert(myDataView.getShape().size()==0);
2779        assert(myDataView()==1.0);
2780    
2781        // use a non-existent tag so we get a pointer to
2782        // the first element of the data array
2783        double* sampleData=myData.getSampleDataByTag(9);
2784        for (int i=0; i<myData.getLength(); i++) {
2785          assert(sampleData[i]==i+1);
2786        }
2787    
2788      }
2789    
2790    }
2791    
2792    void DataTaggedTestCase::testGetSlice() {
2793    
2794      cout << endl;
2795    
2796      {
2797    
2798        cout << "\tTest slicing default DataTagged." << endl;
2799    
2800        DataTagged myData;
2801    
2802        DataArrayView::RegionType region;
2803    
2804        DataAbstract* slicedDefault = myData.getSlice(region);
2805    
2806        // cout << slicedDefault->toString() << endl;
2807    
2808        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2809    
2810        assert(myDataSliced->getTagLookup().size()==0);
2811    
2812        assert(myDataSliced->getLength()==1);
2813    
2814        DataArrayView myDataView = myDataSliced->getDefaultValue();
2815        assert(!myDataView.isEmpty());
2816        assert(myDataView.getOffset()==0);
2817        assert(myDataView.getRank()==0);
2818        assert(myDataView.noValues()==1);
2819        assert(myDataView.getShape().size()==0);
2820        assert(myDataView()==0.0);
2821    
2822      }
2823    
2824      {
2825    
2826        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
2827    
2828        DataArrayView::ShapeType viewShape;
2829        viewShape.push_back(3);
2830    
2831        DataTagged::TagListType keys;
2832    
2833        DataTagged::ValueListType values;
2834    
2835        DataArrayView::ValueType viewData(3);
2836        for (int i=0;i<viewShape[0];i++) {
2837          viewData[i]=i;
2838        }
2839        DataArrayView myView(viewData,viewShape);
2840    
2841        DataTagged myData(keys,values,myView,FunctionSpace());
2842    
2843        // full slice
2844    
2845        std::pair<int, int> region_element;
2846        region_element.first=0;
2847        region_element.second=3;
2848        DataArrayView::RegionType region;
2849        region.push_back(region_element);
2850    
2851        DataAbstract* slicedDefault = myData.getSlice(region);
2852    
2853        //cout << slicedDefault->toString() << endl;
2854    
2855        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2856    
2857        assert(myDataSliced->getTagLookup().size()==0);
2858    
2859        assert(myDataSliced->getLength()==3);
2860    
2861        DataArrayView myDataView = myDataSliced->getDefaultValue();
2862        assert(!myDataView.isEmpty());
2863        assert(myDataView.getOffset()==0);
2864        assert(myDataView.getRank()==1);
2865        assert(myDataView.noValues()==3);
2866        assert(myDataView.getShape().size()==1);
2867        assert(myDataView(0)==0.0);
2868        assert(myDataView(1)==1.0);
2869        assert(myDataView(2)==2.0);
2870    
2871        // scalar slice
2872    
2873        region.clear();
2874        region_element.first=0;
2875        region_element.second=0;
2876        region.push_back(region_element);
2877    
2878        slicedDefault = myData.getSlice(region);
2879    
2880        //cout << slicedDefault->toString() << endl;
2881    
2882        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2883    
2884        assert(myDataSliced->getTagLookup().size()==0);
2885    
2886        assert(myDataSliced->getLength()==1);
2887    
2888        myDataView = myDataSliced->getDefaultValue();
2889        assert(!myDataView.isEmpty());
2890        assert(myDataView.getOffset()==0);
2891        assert(myDataView.getRank()==0);
2892        assert(myDataView.noValues()==1);
2893        assert(myDataView.getShape().size()==0);
2894        assert(myDataView()==0.0);
2895    
2896      }
2897    
2898      {
2899    
2900        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
2901    
2902        DataArrayView::ShapeType viewShape;
2903        viewShape.push_back(3);
2904        viewShape.push_back(3);
2905        viewShape.push_back(3);
2906    
2907        DataTagged::TagListType keys;
2908    
2909        DataTagged::ValueListType values;
2910    
2911        DataArrayView::ValueType viewData(27);
2912        for (int i=0;i<viewData.size();i++) {
2913          viewData[i]=i;
2914        }
2915        DataArrayView myView(viewData,viewShape);
2916    
2917        DataTagged myData(keys,values,myView,FunctionSpace());
2918    
2919        //cout << myData.toString() << endl;
2920    
2921        // full slice
2922    
2923        std::pair<int, int> region_element;
2924        region_element.first=0;
2925        region_element.second=3;
2926        DataArrayView::RegionType region;
2927        region.push_back(region_element);
2928        region.push_back(region_element);
2929        region.push_back(region_element);
2930    
2931        DataAbstract* slicedDefault = myData.getSlice(region);
2932    
2933        //cout << slicedDefault->toString() << endl;
2934    
2935        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2936    
2937        assert(myDataSliced->getTagLookup().size()==0);
2938    
2939        assert(myDataSliced->getLength()==27);
2940    
2941        DataArrayView myDataView = myDataSliced->getDefaultValue();
2942        assert(!myDataView.isEmpty());
2943        assert(myDataView.getOffset()==0);
2944        assert(myDataView.getRank()==3);
2945        assert(myDataView.noValues()==27);
2946        assert(myDataView.getShape().size()==3);
2947    
2948        // rank 1 slice
2949    
2950        region.clear();
2951        region.push_back(region_element);
2952        region_element.second=0;
2953        region.push_back(region_element);
2954        region.push_back(region_element);
2955    
2956        slicedDefault = myData.getSlice(region);
2957    
2958        //cout << slicedDefault->toString() << endl;
2959    
2960        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2961    
2962        assert(myDataSliced->getTagLookup().size()==0);
2963    
2964        assert(myDataSliced->getLength()==3);
2965    
2966        myDataView = myDataSliced->getDefaultValue();
2967        assert(!myDataView.isEmpty());
2968        assert(myDataView.getOffset()==0);
2969        assert(myDataView.getRank()==1);
2970        assert(myDataView.noValues()==3);
2971        assert(myDataView.getShape().size()==1);
2972        assert(myDataView(0)==0.0);
2973        assert(myDataView(1)==1.0);
2974        assert(myDataView(2)==2.0);
2975    
2976        // scalar slice
2977    
2978        region.clear();
2979        region_element.first=2;
2980        region_element.second=2;
2981        region.push_back(region_element);
2982        region.push_back(region_element);
2983        region.push_back(region_element);
2984    
2985        slicedDefault = myData.getSlice(region);
2986    
2987        //cout << slicedDefault->toString() << endl;
2988    
2989        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2990    
2991        assert(myDataSliced->getTagLookup().size()==0);
2992    
2993        assert(myDataSliced->getLength()==1);
2994    
2995        myDataView = myDataSliced->getDefaultValue();
2996        assert(!myDataView.isEmpty());
2997        assert(myDataView.getOffset()==0);
2998        assert(myDataView.getRank()==0);
2999        assert(myDataView.noValues()==1);
3000        assert(myDataView.getShape().size()==0);
3001        assert(myDataView()==26);
3002    
3003      }
3004    
3005      {
3006    
3007        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
3008    
3009        DataTagged::TagListType keys;
3010        keys.push_back(1);
3011    
3012        DataTagged::ValueListType values;
3013    
3014        DataArrayView::ShapeType viewShape;
3015    
3016        // default value
3017        DataArrayView::ValueType viewData(1);
3018        viewData[0]=0.0;
3019        DataArrayView myView(viewData,viewShape);
3020    
3021        // value for tag "1"
3022        DataArrayView::ValueType eOneData(viewData);
3023        DataArrayView eOneView(eOneData, viewShape);
3024        eOneView()=1.0;
3025        values.push_back(eOneView);
3026    
3027        DataTagged myData(keys,values,myView,FunctionSpace());
3028    
3029        //cout << myData.toString() << endl;
3030    
3031        // full slice
3032    
3033        DataArrayView::RegionType region;
3034    
3035        DataAbstract* slicedDefault = myData.getSlice(region);
3036    
3037        //cout << slicedDefault->toString() << endl;
3038    
3039        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3040    
3041        assert(myDataSliced->getTagLookup().size()==1);
3042    
3043        assert(myDataSliced->getLength()==2);
3044    
3045        DataArrayView myDataView = myDataSliced->getDefaultValue();
3046        assert(!myDataView.isEmpty());
3047        assert(myDataView.getOffset()==0);
3048        assert(myDataView.getRank()==0);
3049        assert(myDataView.noValues()==1);
3050        assert(myDataView.getShape().size()==0);
3051        assert(myDataView()==0);
3052    
3053        myDataView = myDataSliced->getDataPointByTag(1);
3054        assert(!myDataView.isEmpty());
3055        assert(myDataView.getOffset()==1);
3056        assert(myDataView.getRank()==0);
3057        assert(myDataView.noValues()==1);
3058        assert(myDataView.getShape().size()==0);
3059        assert(myDataView()==1);
3060    
3061      }
3062    
3063      {
3064    
3065        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
3066    
3067        DataArrayView::ShapeType viewShape;
3068        viewShape.push_back(3);
3069    
3070        DataTagged::TagListType keys;
3071        keys.push_back(1);
3072    
3073        DataTagged::ValueListType values;
3074    
3075        // default value
3076        DataArrayView::ValueType viewData(3);
3077        for (int i=0;i<viewShape[0];i++) {
3078          viewData[i]=i;
3079        }
3080        DataArrayView myView(viewData,viewShape);
3081    
3082        // value for tag "1"
3083        DataArrayView::ValueType eOneData(viewData);
3084        DataArrayView eOneView(eOneData, viewShape);
3085        for (int i=0;i<eOneView.getShape()[0];i++) {
3086          eOneView(i)=i+3.0;
3087        }
3088        values.push_back(eOneView);
3089    
3090        DataTagged myData(keys,values,myView,FunctionSpace());
3091    
3092        //cout << myData.toString() << endl;
3093    
3094        // full slice
3095    
3096        std::pair<int, int> region_element;
3097        region_element.first=0;
3098        region_element.second=3;
3099        DataArrayView::RegionType region;
3100        region.push_back(region_element);
3101    
3102        DataAbstract* slicedDefault = myData.getSlice(region);
3103    
3104        //cout << slicedDefault->toString() << endl;
3105    
3106        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3107    
3108        assert(myDataSliced->getTagLookup().size()==1);
3109    
3110        assert(myDataSliced->getLength()==6);
3111    
3112        DataArrayView myDataView = myDataSliced->getDefaultValue();
3113        assert(!myDataView.isEmpty());
3114        assert(myDataView.getOffset()==0);
3115        assert(myDataView.getRank()==1);
3116        assert(myDataView.noValues()==3);
3117        assert(myDataView.getShape().size()==1);
3118        assert(myDataView(0)==0);
3119        assert(myDataView(1)==1);
3120        assert(myDataView(2)==2);
3121    
3122        myDataView = myDataSliced->getDataPointByTag(1);
3123        assert(!myDataView.isEmpty());
3124        assert(myDataView.getOffset()==3);
3125        assert(myDataView.getRank()==1);
3126        assert(myDataView.noValues()==3);
3127        assert(myDataView.getShape().size()==1);
3128        assert(myDataView(0)==3);
3129        assert(myDataView(1)==4);
3130        assert(myDataView(2)==5);
3131    
3132        // scalar slice
3133    
3134        region_element.first=1;
3135        region_element.second=1;
3136        region.clear();
3137        region.push_back(region_element);
3138    
3139        slicedDefault = myData.getSlice(region);
3140    
3141        //cout << slicedDefault->toString() << endl;
3142    
3143        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3144    
3145        assert(myDataSliced->getTagLookup().size()==1);
3146    
3147        assert(myDataSliced->getLength()==2);
3148    
3149        myDataView = myDataSliced->getDefaultValue();
3150        assert(!myDataView.isEmpty());
3151        assert(myDataView.getOffset()==0);
3152        assert(myDataView.getRank()==0);
3153        assert(myDataView.noValues()==1);
3154        assert(myDataView.getShape().size()==0);
3155        assert(myDataView()==1);
3156    
3157        myDataView = myDataSliced->getDataPointByTag(1);
3158        assert(!myDataView.isEmpty());
3159        assert(myDataView.getOffset()==1);
3160        assert(myDataView.getRank()==0);
3161        assert(myDataView.noValues()==1);
3162        assert(myDataView.getShape().size()==0);
3163        assert(myDataView()==4);
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() {
3768    
3769      cout << endl;
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);