/[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 503 by jgs, Wed Feb 8 04:25:40 2006 UTC branches/ROBW_XPLATFORM/escript/test/DataTagged/DataTaggedTestCase.cpp revision 622 by robwdcock, Wed Mar 22 14:00:08 2006 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2    
3  /*  /*
4   *****************************************************************************   *****************************************************************************
5   *                                                                           *   *                                                                           *
# Line 51  void DataTaggedTestCase::testReshape() { Line 52  void DataTaggedTestCase::testReshape() {
52    cout << endl;    cout << endl;
53    
54    {    {
55      cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;  
56      DataTagged value;      cout << "\tTest rank 1 reshape of default DataTagged." << endl;
57      value.getPointDataView()()=1.0;  
58        DataTagged myData;
59        myData.getPointDataView()()=1.0;
60    
61      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
62      shape.push_back(2);      shape.push_back(2);
63      value.reshapeDataPoint(shape);  
64      for (int i=0;i<shape[0];++i) {      myData.reshapeDataPoint(shape);
65        assert(value.getDefaultValue()(i)==1);  
66        for (int i=0;i<shape[0];i++) {
67          assert(myData.getDefaultValue()(i)==1);
68        }
69    
70        //cout << myData.toString() << endl;
71    
72        assert(myData.getNumSamples()==1);
73        assert(myData.getNumDPPSample()==1);
74    
75        assert(myData.validSamplePointNo(0));
76        assert(myData.validSampleNo(0));
77        assert(!myData.validSamplePointNo(1));
78        assert(!myData.validSampleNo(1));
79    
80        // data-point 0 has tag number 1 by default
81        assert(myData.getTagNumber(0)==1);
82    
83        assert(!myData.isCurrentTag(1));
84    
85        assert(myData.getTagLookup().size()==0);
86    
87        assert(myData.getLength()==2);
88    
89        assert(myData.getPointOffset(0,0)==0);
90    
91        DataArrayView myDataView = myData.getDataPoint(0,0);
92        assert(!myDataView.isEmpty());
93        assert(myDataView.getOffset()==0);
94        assert(myDataView.getRank()==1);
95        assert(myDataView.noValues()==2);
96        assert(myDataView.getShape().size()==1);
97        assert(myDataView(0)==1.0);
98        assert(myDataView(1)==1.0);
99    
100        // Test non-existent tag returns the default value.
101        myDataView = myData.getDataPointByTag(1);
102        assert(!myDataView.isEmpty());
103        assert(myDataView.getOffset()==0);
104        assert(myDataView.getRank()==1);
105        assert(myDataView.noValues()==2);
106        assert(myDataView.getShape().size()==1);
107        assert(myDataView(0)==1.0);
108        assert(myDataView(1)==1.0);
109    
110        myDataView = myData.getDefaultValue();
111        assert(!myDataView.isEmpty());
112        assert(myDataView.getOffset()==0);
113        assert(myDataView.getRank()==1);
114        assert(myDataView.noValues()==2);
115        assert(myDataView.getShape().size()==1);
116        assert(myDataView(0)==1.0);
117        assert(myDataView(1)==1.0);
118    
119        // use a non-existent tag so we get a pointer to
120        // the first element of the data array
121        double* sampleData=myData.getSampleDataByTag(9);
122        for (int i=0; i<myData.getLength(); i++) {
123          assert(sampleData[i]==1.0);
124      }      }
125    
126    }    }
127    
128    {    {
129      cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;  
130      DataTagged value;      cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;
131      value.getPointDataView()()=0.0;  
132      DataArray vOne(1.0);      DataTagged::TagListType keys;
133      DataArray vTwo(2.0);      keys.push_back(1);
134      value.addTaggedValue(1,vOne.getView());  
135      value.addTaggedValue(2,vTwo.getView());      DataTagged::ValueListType values;
136    
137        DataArrayView::ShapeType viewShape;
138    
139        // default value
140        DataArrayView::ValueType viewData(1);
141        viewData[0]=1.0;
142        DataArrayView myView(viewData,viewShape);
143    
144        // value for tag "1"
145        DataArray eOne(myView);
146        eOne.getView()()=2.0;
147        values.push_back(eOne.getView());
148    
149        DataTagged myData(keys,values,myView,FunctionSpace());
150    
151      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
152      shape.push_back(2);      shape.push_back(2);
153      shape.push_back(5);      shape.push_back(5);
154      value.reshapeDataPoint(shape);  
155      for (int j=0;j<shape[1];++j) {      myData.reshapeDataPoint(shape);
156        for (int i=0;i<shape[0];++i) {  
157      assert(value.getDefaultValue()(i,j)==0.0);      //cout << myData.toString() << endl;
158      assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());  
159      assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());      assert(myData.getNumSamples()==1);
160        assert(myData.getNumDPPSample()==1);
161    
162        assert(myData.validSamplePointNo(0));
163        assert(myData.validSampleNo(0));
164        assert(!myData.validSamplePointNo(1));
165        assert(!myData.validSampleNo(1));
166    
167        // data-point 0 has tag number 1 by default
168        assert(myData.getTagNumber(0)==1);
169    
170        assert(myData.isCurrentTag(1));
171    
172        assert(myData.getTagLookup().size()==1);
173    
174        assert(myData.getLength()==20);
175    
176        assert(myData.getPointOffset(0,0)==10);
177    
178        DataArrayView myDataView = myData.getDataPoint(0,0);
179        assert(!myDataView.isEmpty());
180        assert(myDataView.getOffset()==10);
181        assert(myDataView.getRank()==2);
182        assert(myDataView.noValues()==10);
183        assert(myDataView.getShape().size()==2);
184        for (int j=0;j<shape[1];j++) {
185          for (int i=0;i<shape[0];i++) {
186            assert(myDataView(i,j)==2.0);
187        }        }
188      }      }
189    
190        myDataView = myData.getDataPointByTag(1);
191        assert(!myDataView.isEmpty());
192        assert(myDataView.getOffset()==10);
193        assert(myDataView.getRank()==2);
194        assert(myDataView.noValues()==10);
195        assert(myDataView.getShape().size()==2);
196        for (int j=0;j<shape[1];j++) {
197          for (int i=0;i<shape[0];i++) {
198            assert(myDataView(i,j)==2.0);
199          }
200        }
201    
202        myDataView = myData.getDefaultValue();
203        assert(!myDataView.isEmpty());
204        assert(myDataView.getOffset()==0);
205        assert(myDataView.getRank()==2);
206        assert(myDataView.noValues()==10);
207        assert(myDataView.getShape().size()==2);
208        for (int j=0;j<shape[1];j++) {
209          for (int i=0;i<shape[0];i++) {
210            assert(myDataView(i,j)==1.0);
211          }
212        }
213    
214        // use a non-existent tag so we get a pointer to
215        // the first element of the data array
216        double* sampleData=myData.getSampleDataByTag(9);
217        for (int i=0; i<myData.getLength(); i++) {
218          if (i<10) {
219            assert(sampleData[i]==1.0);
220          } else {
221            assert(sampleData[i]==2.0);
222          }
223        }
224    
225    }    }
226    
227      {
228    
229        cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;
230    
231        DataTagged::TagListType keys;
232        keys.push_back(1);
233        keys.push_back(2);
234        keys.push_back(3);
235    
236        DataTagged::ValueListType values;
237    
238        DataArrayView::ShapeType viewShape;
239    
240        // default value
241        DataArrayView::ValueType viewData(1);
242        viewData[0]=0.0;
243        DataArrayView myView(viewData,viewShape);
244    
245        // value for tag "1"
246        DataArray eOne(myView);
247        eOne.getView()()=1.0;
248        values.push_back(eOne.getView());
249    
250        // value for tag "2"
251        DataArray eTwo(myView);
252        eTwo.getView()()=2.0;
253        values.push_back(eTwo.getView());
254    
255        // value for tag "3"
256        DataArray eThree(myView);
257        eThree.getView()()=3.0;
258        values.push_back(eThree.getView());
259    
260        DataTagged myData(keys,values,myView,FunctionSpace());
261    
262        DataArrayView::ShapeType shape;
263        shape.push_back(2);
264        shape.push_back(2);
265        shape.push_back(2);
266    
267        myData.reshapeDataPoint(shape);
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        assert(myData.isCurrentTag(3));
285    
286        assert(myData.getTagLookup().size()==3);
287    
288        assert(myData.getLength()==32);
289    
290        assert(myData.getPointOffset(0,0)==8);
291    
292        DataArrayView myDataView = myData.getDataPoint(0,0);
293        assert(!myDataView.isEmpty());
294        assert(myDataView.getOffset()==8);
295        assert(myDataView.getRank()==3);
296        assert(myDataView.noValues()==8);
297        assert(myDataView.getShape().size()==3);
298        for (int k=0;k<shape[2];k++) {
299          for (int j=0;j<shape[1];j++) {
300            for (int i=0;i<shape[0];i++) {
301              assert(myDataView(i,j,k)==1.0);
302            }
303          }
304        }
305    
306        myDataView = myData.getDataPointByTag(1);
307        assert(!myDataView.isEmpty());
308        assert(myDataView.getOffset()==8);
309        assert(myDataView.getRank()==3);
310        assert(myDataView.noValues()==8);
311        assert(myDataView.getShape().size()==3);
312        for (int k=0;k<shape[2];k++) {
313          for (int j=0;j<shape[1];j++) {
314            for (int i=0;i<shape[0];i++) {
315              assert(myDataView(i,j,k)==1.0);
316            }
317          }
318        }
319    
320        myDataView = myData.getDataPointByTag(2);
321        assert(!myDataView.isEmpty());
322        assert(myDataView.getOffset()==16);
323        assert(myDataView.getRank()==3);
324        assert(myDataView.noValues()==8);
325        assert(myDataView.getShape().size()==3);
326        for (int k=0;k<shape[2];k++) {
327          for (int j=0;j<shape[1];j++) {
328            for (int i=0;i<shape[0];i++) {
329              assert(myDataView(i,j,k)==2.0);
330            }
331          }
332        }
333    
334        myDataView = myData.getDataPointByTag(3);
335        assert(!myDataView.isEmpty());
336        assert(myDataView.getOffset()==24);
337        assert(myDataView.getRank()==3);
338        assert(myDataView.noValues()==8);
339        assert(myDataView.getShape().size()==3);
340        for (int k=0;k<shape[2];k++) {
341          for (int j=0;j<shape[1];j++) {
342            for (int i=0;i<shape[0];i++) {
343              assert(myDataView(i,j,k)==3.0);
344            }
345          }
346        }
347    
348        myDataView = myData.getDefaultValue();
349        assert(!myDataView.isEmpty());
350        assert(myDataView.getOffset()==0);
351        assert(myDataView.getRank()==3);
352        assert(myDataView.noValues()==8);
353        assert(myDataView.getShape().size()==3);
354        for (int k=0;k<shape[2];k++) {
355          for (int j=0;j<shape[1];j++) {
356            for (int i=0;i<shape[0];i++) {
357              assert(myDataView(i,j,k)==0.0);
358            }
359          }
360        }
361    
362        // use a non-existent tag so we get a pointer to
363        // the first element of the data array
364        double* sampleData=myData.getSampleDataByTag(9);
365        for (int i=0; i<myData.getLength(); i++) {
366          if (i<8) {
367            assert(sampleData[i]==0.0);
368          } else if ((i>=8) && (i<16)) {
369            assert(sampleData[i]==1.0);
370          } else if ((i>=16) && (i<24)) {
371            assert(sampleData[i]==2.0);
372          } else {
373            assert(sampleData[i]==3.0);
374          }
375        }
376    
377      }
378    
379  }  }
380    
381  void DataTaggedTestCase::testOperations() {  void DataTaggedTestCase::testOperations() {
# Line 88  void DataTaggedTestCase::testOperations( Line 383  void DataTaggedTestCase::testOperations(
383    cout << endl;    cout << endl;
384    
385    {    {
386      DataTagged left;      cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
387    
388        DataTagged myData;
389      DataTagged right;      DataTagged right;
390    
391      cout << "\tTest default DataTagged contains only a default value." << endl;      binaryOp(myData,right,plus<double>());
392      binaryOp(left,right,plus<double>());  
393      assert(left.getPointDataView()()==0);      //cout << myData.toString() << endl;
394      assert(right.getPointDataView()()==0);  
395        assert(myData.getNumSamples()==1);
396        assert(myData.getNumDPPSample()==1);
397    
398        assert(myData.validSamplePointNo(0));
399        assert(myData.validSampleNo(0));
400        assert(!myData.validSamplePointNo(1));
401        assert(!myData.validSampleNo(1));
402    
403        // data-point 0 has tag number 1 by default
404        assert(myData.getTagNumber(0)==1);
405    
406        assert(!myData.isCurrentTag(1));
407    
408        assert(myData.getTagLookup().size()==0);
409    
410        assert(myData.getLength()==1);
411    
412        assert(myData.getPointOffset(0,0)==0);
413    
414        DataArrayView myDataView = myData.getDataPoint(0,0);
415        assert(!myDataView.isEmpty());
416        assert(myDataView.getOffset()==0);
417        assert(myDataView.getRank()==0);
418        assert(myDataView.noValues()==1);
419        assert(myDataView.getShape().size()==0);
420        assert(myDataView()==0.0);
421    
422        // Test non-existent tag returns the default value.
423        myDataView = myData.getDataPointByTag(1);
424        assert(!myDataView.isEmpty());
425        assert(myDataView.getOffset()==0);
426        assert(myDataView.getRank()==0);
427        assert(myDataView.noValues()==1);
428        assert(myDataView.getShape().size()==0);
429        assert(myDataView()==0.0);
430    
431        myDataView = myData.getDefaultValue();
432        assert(!myDataView.isEmpty());
433        assert(myDataView.getOffset()==0);
434        assert(myDataView.getRank()==0);
435        assert(myDataView.noValues()==1);
436        assert(myDataView.getShape().size()==0);
437        assert(myDataView()==0.0);
438    
439        // use a non-existent tag so we get a pointer to
440        // the first element of the data array
441        double* sampleData=myData.getSampleDataByTag(9);
442        for (int i=0; i<myData.getLength(); i++) {
443          assert(sampleData[i]==i);
444        }
445    
446      }
447    
448      {
449        cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
450    
451        DataArrayView::ShapeType viewShape;
452        viewShape.push_back(3);
453    
454        DataTagged::TagListType keys;
455    
456        DataTagged::ValueListType values;
457    
458        DataArrayView::ValueType viewData(3);
459        for (int i=0;i<viewShape[0];i++) {
460          viewData[i]=i;
461        }
462        DataArrayView myView(viewData,viewShape);
463    
464        DataTagged myData(keys,values,myView,FunctionSpace());
465        DataTagged right(keys,values,myView,FunctionSpace());
466    
467        binaryOp(myData,right,plus<double>());
468    
469        //cout << myData.toString() << endl;
470    
471        assert(myData.getNumSamples()==1);
472        assert(myData.getNumDPPSample()==1);
473    
474        assert(myData.validSamplePointNo(0));
475        assert(myData.validSampleNo(0));
476        assert(!myData.validSamplePointNo(1));
477        assert(!myData.validSampleNo(1));
478    
479        // data-point 0 has tag number 1 by default
480        assert(myData.getTagNumber(0)==1);
481    
482        assert(!myData.isCurrentTag(1));
483    
484        assert(myData.getTagLookup().size()==0);
485    
486        assert(myData.getLength()==3);
487    
488        assert(myData.getPointOffset(0,0)==0);
489    
490        DataArrayView myDataView = myData.getDefaultValue();
491        assert(!myDataView.isEmpty());
492        assert(myDataView.getOffset()==0);
493        assert(myDataView.getRank()==1);
494        assert(myDataView.noValues()==3);
495        assert(myDataView.getShape().size()==1);
496        assert(myDataView(0)==0);
497        assert(myDataView(1)==2);
498        assert(myDataView(2)==4);
499    
500        // use a non-existent tag so we get a pointer to
501        // the first element of the data array
502        double* sampleData=myData.getSampleDataByTag(9);
503        for (int i=0; i<myData.getLength(); i++) {
504          assert(sampleData[i]==i*2);
505        }
506    
507      }
508    
509      {
510        cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
511    
512        DataTagged myData;
513        DataTagged right;
514    
     cout << "\tTest binaryOp(plus)." << endl;  
515      DataArray vOne(1.0);      DataArray vOne(1.0);
516      DataArray vTwo(2.0);      myData.addTaggedValue(1,vOne.getView());
517      right.addTaggedValue(1,vOne.getView());      right.addTaggedValue(1,vOne.getView());
518    
519        binaryOp(myData,right,plus<double>());
520    
521        assert(myData.getNumSamples()==1);
522        assert(myData.getNumDPPSample()==1);
523    
524        assert(myData.validSamplePointNo(0));
525        assert(myData.validSampleNo(0));
526        assert(!myData.validSamplePointNo(1));
527        assert(!myData.validSampleNo(1));
528    
529        // data-point 0 has tag number 1 by default
530        assert(myData.getTagNumber(0)==1);
531    
532        assert(myData.isCurrentTag(1));
533    
534        assert(myData.getTagLookup().size()==1);
535    
536        assert(myData.getLength()==2);
537    
538        assert(myData.getPointOffset(0,0)==1);
539    
540        // check result value for tag "1"
541        DataArrayView myDataView = myData.getDataPointByTag(1);
542        assert(!myDataView.isEmpty());
543        assert(myDataView.getOffset()==1);
544        assert(myDataView.getRank()==0);
545        assert(myDataView.noValues()==1);
546        assert(myDataView.getShape().size()==0);
547        assert(myDataView()==2.0);
548    
549        // check result for default value
550        myDataView = myData.getDefaultValue();
551        assert(!myDataView.isEmpty());
552        assert(myDataView.getOffset()==0);
553        assert(myDataView.getRank()==0);
554        assert(myDataView.noValues()==1);
555        assert(myDataView.getShape().size()==0);
556        assert(myDataView()==0.0);
557    
558        // use a non-existent tag so we get a pointer to
559        // the first element of the data array
560        double* sampleData=myData.getSampleDataByTag(9);
561        for (int i=0; i<myData.getLength(); i++) {
562          assert(sampleData[i]==i*2);
563        }
564    
565      }
566    
567      {
568        cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
569    
570        DataTagged myData;
571        DataTagged right;
572    
573        // it's important that default values are different, as we need to be able to
574        // verify that the tag values in each object are being added to the correct
575        // default values - since the tag lists don't match, the default values will
576        // be used for missing tags in each object
577        myData.getDefaultValue()()=1.0;
578        right.getDefaultValue()()=2.0;
579    
580        DataArray vOne(3.0);
581        DataArray vTwo(4.0);
582        myData.addTaggedValue(1,vOne.getView());
583      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
584      binaryOp(left,right,plus<double>());  
585      assert(left.getPointDataView()()==0);      //cout << myData.toString() << endl;
586      assert(left.getDataPointByTag(1)==vOne.getView());      //cout << right.toString() << endl;
587      assert(left.getDataPointByTag(2)==vTwo.getView());  
588        binaryOp(myData,right,plus<double>());
589      cout << "\tTest binaryOp(multiplies)." << endl;  
590      DataArray vZero(0.0);      //cout << myData.toString() << endl;
591      right.setTaggedValue(1,vZero.getView());  
592      right.setTaggedValue(2,vZero.getView());      assert(myData.getNumSamples()==1);
593      binaryOp(left,right,multiplies<double>());      assert(myData.getNumDPPSample()==1);
594      assert(left.getPointDataView()()==0);  
595      assert(left.getDataPointByTag(1)==vZero.getView());      assert(myData.validSamplePointNo(0));
596      assert(left.getDataPointByTag(2)==vZero.getView());      assert(myData.validSampleNo(0));
597        assert(!myData.validSamplePointNo(1));
598        assert(!myData.validSampleNo(1));
599    
600        // data-point 0 has tag number 1 by default
601        assert(myData.getTagNumber(0)==1);
602    
603        assert(myData.isCurrentTag(1));
604        assert(myData.isCurrentTag(2));
605    
606        assert(myData.getTagLookup().size()==2);
607    
608        assert(myData.getLength()==3);
609    
610        assert(myData.getPointOffset(0,0)==1);
611    
612        // check result value for tag "1"
613        DataArrayView myDataView = myData.getDataPointByTag(1);
614        assert(!myDataView.isEmpty());
615        assert(myDataView.getOffset()==1);
616        assert(myDataView.getRank()==0);
617        assert(myDataView.noValues()==1);
618        assert(myDataView.getShape().size()==0);
619        assert(myDataView()==5.0);
620    
621        // check result value for tag "2"
622        myDataView = myData.getDataPointByTag(2);
623        assert(!myDataView.isEmpty());
624        assert(myDataView.getOffset()==2);
625        assert(myDataView.getRank()==0);
626        assert(myDataView.noValues()==1);
627        assert(myDataView.getShape().size()==0);
628        assert(myDataView()==5.0);
629    
630        // check result for default value
631        myDataView = myData.getDefaultValue();
632        assert(!myDataView.isEmpty());
633        assert(myDataView.getOffset()==0);
634        assert(myDataView.getRank()==0);
635        assert(myDataView.noValues()==1);
636        assert(myDataView.getShape().size()==0);
637        assert(myDataView()==3.0);
638    
639        // use a non-existent tag so we get a pointer to
640        // the first element of the data array
641        double* sampleData=myData.getSampleDataByTag(9);
642        assert(sampleData[0]==3);
643        assert(sampleData[1]==5);
644        assert(sampleData[2]==5);
645    
646    }    }
647    
648    {    {
649        cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
650    
651        DataTagged myData;
652        DataTagged right;
653    
654        // it's important that default values are different, as we need to be able to
655        // verify that the tag values in each object are being added to the correct
656        // default values - since the tag lists don't match, the default values will
657        // be used for missing tags in each object
658        myData.getDefaultValue()()=2.0;
659        right.getDefaultValue()()=3.0;
660    
661        DataArray vOne(1.0);
662        myData.addTaggedValue(1,vOne.getView());
663        myData.addTaggedValue(2,vOne.getView());
664        right.addTaggedValue(2,vOne.getView());
665        right.addTaggedValue(3,vOne.getView());
666    
667        //cout << myData.toString() << endl;
668        //cout << right.toString() << endl;
669    
670        binaryOp(myData,right,plus<double>());
671    
672        //cout << myData.toString() << endl;
673    
674        assert(myData.getNumSamples()==1);
675        assert(myData.getNumDPPSample()==1);
676    
677        assert(myData.validSamplePointNo(0));
678        assert(myData.validSampleNo(0));
679        assert(!myData.validSamplePointNo(1));
680        assert(!myData.validSampleNo(1));
681    
682        // data-point 0 has tag number 1 by default
683        assert(myData.getTagNumber(0)==1);
684    
685        assert(myData.isCurrentTag(1));
686        assert(myData.isCurrentTag(2));
687        assert(myData.isCurrentTag(3));
688    
689        assert(myData.getTagLookup().size()==3);
690    
691        assert(myData.getLength()==4);
692    
693        assert(myData.getPointOffset(0,0)==1);
694    
695        // check result value for tag "1"
696        DataArrayView myDataView = myData.getDataPointByTag(1);
697        assert(!myDataView.isEmpty());
698        assert(myDataView.getOffset()==1);
699        assert(myDataView.getRank()==0);
700        assert(myDataView.noValues()==1);
701        assert(myDataView.getShape().size()==0);
702        assert(myDataView()==4.0);
703    
704        // check result value for tag "2"
705        myDataView = myData.getDataPointByTag(2);
706        assert(!myDataView.isEmpty());
707        assert(myDataView.getOffset()==2);
708        assert(myDataView.getRank()==0);
709        assert(myDataView.noValues()==1);
710        assert(myDataView.getShape().size()==0);
711        assert(myDataView()==2.0);
712    
713        // check result value for tag "3"
714        myDataView = myData.getDataPointByTag(3);
715        assert(!myDataView.isEmpty());
716        assert(myDataView.getOffset()==3);
717        assert(myDataView.getRank()==0);
718        assert(myDataView.noValues()==1);
719        assert(myDataView.getShape().size()==0);
720        assert(myDataView()==3.0);
721    
722        // check result for default value
723        myDataView = myData.getDefaultValue();
724        assert(!myDataView.isEmpty());
725        assert(myDataView.getOffset()==0);
726        assert(myDataView.getRank()==0);
727        assert(myDataView.noValues()==1);
728        assert(myDataView.getShape().size()==0);
729        assert(myDataView()==5.0);
730    
731        // use a non-existent tag so we get a pointer to
732        // the first element of the data array
733        double* sampleData=myData.getSampleDataByTag(9);
734        assert(sampleData[0]==5);
735        assert(sampleData[1]==4);
736        assert(sampleData[2]==2);
737        assert(sampleData[3]==3);
738    
739      }
740    
741      {
742        cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
743    
744      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
745      viewShape.push_back(3);      viewShape.push_back(3);
746      DataArrayView::ValueType viewData(3);  
747      DataTagged::TagListType keys;      DataTagged::TagListType keys;
748    
749      DataTagged::ValueListType values;      DataTagged::ValueListType values;
750      for (int i=0;i<viewShape[0];++i) {  
751        DataArrayView::ValueType viewData(3);
752        for (int i=0;i<viewShape[0];i++) {
753        viewData[i]=i;        viewData[i]=i;
754      }      }
755      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
756      cout << "\tCreate tagged data with no tag values just a default." << endl;  
757      DataTagged left(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
758      DataTagged right(keys,values,myView,FunctionSpace());      DataTagged right(keys,values,myView,FunctionSpace());
759      binaryOp(left,right,minus<double>());  
760      for (int i=0;i<viewShape[0];++i) {      binaryOp(myData,right,multiplies<double>());
761        assert(left.getDefaultValue()(i)==0);  
762      }      //cout << myData.toString() << endl;
763      double mVal=10.0;  
764      for (int i=0;i<viewShape[0];++i) {      assert(myData.getNumSamples()==1);
765        viewData[i]=i*mVal;      assert(myData.getNumDPPSample()==1);
766      }  
767      cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      assert(myData.validSamplePointNo(0));
768      binaryOp(left,myView,minus<double>());      assert(myData.validSampleNo(0));
769      for (int i=0;i<viewShape[0];++i) {      assert(!myData.validSamplePointNo(1));
770        assert(left.getDefaultValue()(i)==-(i*mVal));      assert(!myData.validSampleNo(1));
771    
772        // data-point 0 has tag number 1 by default
773        assert(myData.getTagNumber(0)==1);
774    
775        assert(!myData.isCurrentTag(1));
776    
777        assert(myData.getTagLookup().size()==0);
778    
779        assert(myData.getLength()==3);
780    
781        assert(myData.getPointOffset(0,0)==0);
782    
783        DataArrayView myDataView = myData.getDefaultValue();
784        assert(!myDataView.isEmpty());
785        assert(myDataView.getOffset()==0);
786        assert(myDataView.getRank()==1);
787        assert(myDataView.noValues()==3);
788        assert(myDataView.getShape().size()==1);
789        assert(myDataView(0)==0);
790        assert(myDataView(1)==1);
791        assert(myDataView(2)==4);
792    
793        // use a non-existent tag so we get a pointer to
794        // the first element of the data array
795        double* sampleData=myData.getSampleDataByTag(9);
796        for (int i=0; i<myData.getLength(); i++) {
797          assert(sampleData[i]==i*i);
798      }      }
799    
800    }    }
801    
802    {    {
803      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;  
804      DataTagged data;      cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
805      unaryOp(data,negate<double>());  
806      assert(data.getDefaultValue()()==0);      DataTagged myData;
807      DataArray vOne(1);  
808      binaryOp(data,vOne.getView(),plus<double>());      DataArray vOne(1.0);
809      assert(data.getDefaultValue()()==1);      DataArray vTwo(2.0);
810      unaryOp(data,negate<double>());      myData.addTaggedValue(1,vOne.getView());
811      assert(data.getDefaultValue()()==-1);      myData.addTaggedValue(2,vTwo.getView());
812    
813        DataArray vThree(3.0);
814        DataArrayView right=vThree.getView();
815    
816        //cout << myData.toString() << endl;
817        //cout << right.toString() << endl;
818    
819        binaryOp(myData,right,multiplies<double>());
820    
821        //cout << myData.toString() << endl;
822    
823        assert(myData.getNumSamples()==1);
824        assert(myData.getNumDPPSample()==1);
825    
826        assert(myData.validSamplePointNo(0));
827        assert(myData.validSampleNo(0));
828        assert(!myData.validSamplePointNo(1));
829        assert(!myData.validSampleNo(1));
830    
831        // data-point 0 has tag number 1 by default
832        assert(myData.getTagNumber(0)==1);
833    
834        assert(myData.isCurrentTag(1));
835        assert(myData.isCurrentTag(2));
836    
837        assert(myData.getTagLookup().size()==2);
838    
839        assert(myData.getLength()==3);
840    
841        assert(myData.getPointOffset(0,0)==1);
842    
843        // check result value for tag "1"
844        DataArrayView myDataView = myData.getDataPointByTag(1);
845        assert(!myDataView.isEmpty());
846        assert(myDataView.getOffset()==1);
847        assert(myDataView.getRank()==0);
848        assert(myDataView.noValues()==1);
849        assert(myDataView.getShape().size()==0);
850        assert(myDataView()==3.0);
851    
852        // check result value for tag "2"
853        myDataView = myData.getDataPointByTag(2);
854        assert(!myDataView.isEmpty());
855        assert(myDataView.getOffset()==2);
856        assert(myDataView.getRank()==0);
857        assert(myDataView.noValues()==1);
858        assert(myDataView.getShape().size()==0);
859        assert(myDataView()==6.0);
860    
861        // check result for default value
862        myDataView = myData.getDefaultValue();
863        assert(!myDataView.isEmpty());
864        assert(myDataView.getOffset()==0);
865        assert(myDataView.getRank()==0);
866        assert(myDataView.noValues()==1);
867        assert(myDataView.getShape().size()==0);
868        assert(myDataView()==0.0);
869    
870        // use a non-existent tag so we get a pointer to
871        // the first element of the data array
872        double* sampleData=myData.getSampleDataByTag(9);
873        assert(sampleData[0]==0);
874        assert(sampleData[1]==3);
875        assert(sampleData[2]==6);
876    
877    }    }
878    
879    {    {
880      cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;      cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
881      DataArrayView::ShapeType vShape;  
882      vShape.push_back(3);      DataTagged myData;
883      vShape.push_back(2);      DataTagged right;
884      vShape.push_back(1);  
885      DataArray defData(vShape,0.0);      // it's important that default values are different, as we need to be able to
886      DataArrayView& defView=defData.getView();      // verify that the tag values in each object are being added to the correct
887      DataArray tOneData(vShape,1.0);      // default values - since the tag lists don't match, the default values will
888      DataArrayView& tOneView=tOneData.getView();      // be used for missing tags in each object
889      DataArray tTwoData(vShape,2.0);      myData.getDefaultValue()()=2.0;
890      DataArrayView& tTwoView=tTwoData.getView();      right.getDefaultValue()()=3.0;
891      DataArray tThreeData(vShape,3.0);  
892      DataArrayView& tThreeView=tThreeData.getView();      DataArray vOne(1.0);
893        DataArray vTwo(2.0);
894        myData.addTaggedValue(1,vOne.getView());
895        myData.addTaggedValue(2,vOne.getView());
896        right.addTaggedValue(2,vTwo.getView());
897        right.addTaggedValue(3,vTwo.getView());
898    
899        //cout << myData.toString() << endl;
900        //cout << right.toString() << endl;
901    
902        binaryOp(myData,right,multiplies<double>());
903    
904        //cout << myData.toString() << endl;
905    
906        assert(myData.getNumSamples()==1);
907        assert(myData.getNumDPPSample()==1);
908    
909        assert(myData.validSamplePointNo(0));
910        assert(myData.validSampleNo(0));
911        assert(!myData.validSamplePointNo(1));
912        assert(!myData.validSampleNo(1));
913    
914        // data-point 0 has tag number 1 by default
915        assert(myData.getTagNumber(0)==1);
916    
917        assert(myData.isCurrentTag(1));
918        assert(myData.isCurrentTag(2));
919        assert(myData.isCurrentTag(3));
920    
921        assert(myData.getTagLookup().size()==3);
922    
923        assert(myData.getLength()==4);
924    
925        assert(myData.getPointOffset(0,0)==1);
926    
927        // check result value for tag "1"
928        DataArrayView myDataView = myData.getDataPointByTag(1);
929        assert(!myDataView.isEmpty());
930        assert(myDataView.getOffset()==1);
931        assert(myDataView.getRank()==0);
932        assert(myDataView.noValues()==1);
933        assert(myDataView.getShape().size()==0);
934        assert(myDataView()==3.0);
935    
936        // check result value for tag "2"
937        myDataView = myData.getDataPointByTag(2);
938        assert(!myDataView.isEmpty());
939        assert(myDataView.getOffset()==2);
940        assert(myDataView.getRank()==0);
941        assert(myDataView.noValues()==1);
942        assert(myDataView.getShape().size()==0);
943        assert(myDataView()==2.0);
944    
945        // check result value for tag "3"
946        myDataView = myData.getDataPointByTag(3);
947        assert(!myDataView.isEmpty());
948        assert(myDataView.getOffset()==3);
949        assert(myDataView.getRank()==0);
950        assert(myDataView.noValues()==1);
951        assert(myDataView.getShape().size()==0);
952        assert(myDataView()==4.0);
953    
954        // check result for default value
955        myDataView = myData.getDefaultValue();
956        assert(!myDataView.isEmpty());
957        assert(myDataView.getOffset()==0);
958        assert(myDataView.getRank()==0);
959        assert(myDataView.noValues()==1);
960        assert(myDataView.getShape().size()==0);
961        assert(myDataView()==6.0);
962    
963        // use a non-existent tag so we get a pointer to
964        // the first element of the data array
965        double* sampleData=myData.getSampleDataByTag(9);
966        assert(sampleData[0]==6);
967        assert(sampleData[1]==3);
968        assert(sampleData[2]==2);
969        assert(sampleData[3]==4);
970    
971      }
972    
973      {
974        cout << "\tTest unaryOp negate on default DataTagged object." << endl;
975    
976        DataTagged myData;
977    
978        unaryOp(myData,negate<double>());
979    
980        //cout << myData.toString() << endl;
981    
982        assert(myData.getNumSamples()==1);
983        assert(myData.getNumDPPSample()==1);
984    
985        assert(myData.validSamplePointNo(0));
986        assert(myData.validSampleNo(0));
987        assert(!myData.validSamplePointNo(1));
988        assert(!myData.validSampleNo(1));
989    
990        // data-point 0 has tag number 1 by default
991        assert(myData.getTagNumber(0)==1);
992    
993        assert(!myData.isCurrentTag(1));
994    
995        assert(myData.getTagLookup().size()==0);
996    
997        assert(myData.getLength()==1);
998    
999        assert(myData.getPointOffset(0,0)==0);
1000    
1001        DataArrayView myDataView = myData.getDataPoint(0,0);
1002        assert(!myDataView.isEmpty());
1003        assert(myDataView.getOffset()==0);
1004        assert(myDataView.getRank()==0);
1005        assert(myDataView.noValues()==1);
1006        assert(myDataView.getShape().size()==0);
1007        assert(myDataView()==0.0);
1008    
1009        // Test non-existent tag returns the default value.
1010        myDataView = myData.getDataPointByTag(1);
1011        assert(!myDataView.isEmpty());
1012        assert(myDataView.getOffset()==0);
1013        assert(myDataView.getRank()==0);
1014        assert(myDataView.noValues()==1);
1015        assert(myDataView.getShape().size()==0);
1016        assert(myDataView()==0.0);
1017    
1018        myDataView = myData.getDefaultValue();
1019        assert(!myDataView.isEmpty());
1020        assert(myDataView.getOffset()==0);
1021        assert(myDataView.getRank()==0);
1022        assert(myDataView.noValues()==1);
1023        assert(myDataView.getShape().size()==0);
1024        assert(myDataView()==0.0);
1025    
1026        // use a non-existent tag so we get a pointer to
1027        // the first element of the data array
1028        double* sampleData=myData.getSampleDataByTag(9);
1029        for (int i=0; i<myData.getLength(); i++) {
1030          assert(sampleData[i]==i);
1031        }
1032    
1033      }
1034    
1035      {
1036        cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
1037    
1038        DataArrayView::ShapeType viewShape;
1039        viewShape.push_back(3);
1040    
1041      DataTagged::TagListType keys;      DataTagged::TagListType keys;
1042    
1043      DataTagged::ValueListType values;      DataTagged::ValueListType values;
1044      keys.push_back(1);  
1045      keys.push_back(2);      DataArrayView::ValueType viewData(3);
1046      keys.push_back(3);      for (int i=0;i<viewShape[0];i++) {
1047      values.push_back(tOneView);        viewData[i]=i;
1048      values.push_back(tTwoView);      }
1049      values.push_back(tThreeView);      DataArrayView myView(viewData,viewShape);
1050      DataTagged tData(keys,values,defView,FunctionSpace());  
1051      unaryOp(tData,negate<double>());      DataTagged myData(keys,values,myView,FunctionSpace());
1052      unaryOp(tData,negate<double>());  
1053      assert(tData.getDataPointByTag(1)==tOneView);      unaryOp(myData,negate<double>());
1054      assert(tData.getDataPointByTag(2)==tTwoView);  
1055      assert(tData.getDataPointByTag(3)==tThreeView);      //cout << myData.toString() << endl;
1056    
1057        assert(myData.getNumSamples()==1);
1058        assert(myData.getNumDPPSample()==1);
1059    
1060        assert(myData.validSamplePointNo(0));
1061        assert(myData.validSampleNo(0));
1062        assert(!myData.validSamplePointNo(1));
1063        assert(!myData.validSampleNo(1));
1064    
1065        // data-point 0 has tag number 1 by default
1066        assert(myData.getTagNumber(0)==1);
1067    
1068        assert(!myData.isCurrentTag(1));
1069    
1070        assert(myData.getTagLookup().size()==0);
1071    
1072        assert(myData.getLength()==3);
1073    
1074        assert(myData.getPointOffset(0,0)==0);
1075    
1076        DataArrayView myDataView = myData.getDefaultValue();
1077        assert(!myDataView.isEmpty());
1078        assert(myDataView.getOffset()==0);
1079        assert(myDataView.getRank()==1);
1080        assert(myDataView.noValues()==3);
1081        assert(myDataView.getShape().size()==1);
1082        assert(myDataView(0)==0);
1083        assert(myDataView(1)==-1);
1084        assert(myDataView(2)==-2);
1085    
1086        // use a non-existent tag so we get a pointer to
1087        // the first element of the data array
1088        double* sampleData=myData.getSampleDataByTag(9);
1089        for (int i=0; i<myData.getLength(); i++) {
1090          assert(sampleData[i]==0-i);
1091        }
1092    
1093      }
1094    
1095      {
1096        cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;
1097    
1098        DataTagged myData;
1099    
1100        DataArray vOne(1.0);
1101        DataArray vTwo(2.0);
1102        myData.addTaggedValue(1,vOne.getView());
1103        myData.addTaggedValue(2,vTwo.getView());
1104    
1105        unaryOp(myData,negate<double>());
1106    
1107        assert(myData.getNumSamples()==1);
1108        assert(myData.getNumDPPSample()==1);
1109    
1110        assert(myData.validSamplePointNo(0));
1111        assert(myData.validSampleNo(0));
1112        assert(!myData.validSamplePointNo(1));
1113        assert(!myData.validSampleNo(1));
1114    
1115        // data-point 0 has tag number 1 by default
1116        assert(myData.getTagNumber(0)==1);
1117    
1118        assert(myData.isCurrentTag(1));
1119        assert(myData.isCurrentTag(2));
1120    
1121        assert(myData.getTagLookup().size()==2);
1122    
1123        assert(myData.getLength()==3);
1124    
1125        assert(myData.getPointOffset(0,0)==1);
1126    
1127        // check result value for tag "1"
1128        DataArrayView myDataView = myData.getDataPointByTag(1);
1129        assert(!myDataView.isEmpty());
1130        assert(myDataView.getOffset()==1);
1131        assert(myDataView.getRank()==0);
1132        assert(myDataView.noValues()==1);
1133        assert(myDataView.getShape().size()==0);
1134        assert(myDataView()==-1.0);
1135    
1136        // check result value for tag "2"
1137        myDataView = myData.getDataPointByTag(2);
1138        assert(!myDataView.isEmpty());
1139        assert(myDataView.getOffset()==2);
1140        assert(myDataView.getRank()==0);
1141        assert(myDataView.noValues()==1);
1142        assert(myDataView.getShape().size()==0);
1143        assert(myDataView()==-2.0);
1144    
1145        // check result for default value
1146        myDataView = myData.getDefaultValue();
1147        assert(!myDataView.isEmpty());
1148        assert(myDataView.getOffset()==0);
1149        assert(myDataView.getRank()==0);
1150        assert(myDataView.noValues()==1);
1151        assert(myDataView.getShape().size()==0);
1152        assert(myDataView()==0.0);
1153    
1154        // use a non-existent tag so we get a pointer to
1155        // the first element of the data array
1156        double* sampleData=myData.getSampleDataByTag(9);
1157        for (int i=0; i<myData.getLength(); i++) {
1158          assert(sampleData[i]==0-i);
1159        }
1160    
1161    }    }
1162    
1163  }  }
# Line 239  void DataTaggedTestCase::testAddTaggedVa Line 1213  void DataTaggedTestCase::testAddTaggedVa
1213      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1214      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1215    
1216        // use a non-existent tag so we get a pointer to
1217        // the first element of the data array
1218        double* sampleData=myData.getSampleDataByTag(9);
1219        for (int i=0; i<myData.getLength(); i++) {
1220          assert(sampleData[i]==0);
1221        }
1222    
1223    }    }
1224    
1225    {    {
# Line 294  void DataTaggedTestCase::testAddTaggedVa Line 1275  void DataTaggedTestCase::testAddTaggedVa
1275      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1276      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1277    
1278        // use a non-existent tag so we get a pointer to
1279        // the first element of the data array
1280        double* sampleData=myData.getSampleDataByTag(9);
1281        for (int i=0; i<myData.getLength(); i++) {
1282          assert(sampleData[i]==i);
1283        }
1284    
1285    }    }
1286    
1287    {    {
# Line 369  void DataTaggedTestCase::testAddTaggedVa Line 1357  void DataTaggedTestCase::testAddTaggedVa
1357      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1358      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1359    
1360        // use a non-existent tag so we get a pointer to
1361        // the first element of the data array
1362        double* sampleData=myData.getSampleDataByTag(9);
1363        for (int i=0; i<myData.getLength(); i++) {
1364          if (i==0) {
1365            assert(sampleData[i]==0);
1366          } else {
1367            assert(sampleData[i]==1);
1368          }
1369        }
1370    
1371    }    }
1372    
1373    {    {
# Line 452  void DataTaggedTestCase::testAddTaggedVa Line 1451  void DataTaggedTestCase::testAddTaggedVa
1451      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
1452      assert(myDataView()==0.0);      assert(myDataView()==0.0);
1453    
1454        // use a non-existent tag so we get a pointer to
1455        // the first element of the data array
1456        double* sampleData=myData.getSampleDataByTag(9);
1457        for (int i=0; i<myData.getLength(); i++) {
1458          assert(sampleData[i]==i);
1459        }
1460    
1461    }    }
1462    
1463    {    {
# Line 522  void DataTaggedTestCase::testAddTaggedVa Line 1528  void DataTaggedTestCase::testAddTaggedVa
1528      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1529      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1530    
1531        // use a non-existent tag so we get a pointer to
1532        // the first element of the data array
1533        double* sampleData=myData.getSampleDataByTag(9);
1534        for (int i=0; i<myData.getLength(); i++) {
1535          assert(sampleData[i]==i%3);
1536        }
1537    
1538    }    }
1539    
1540    {    {
# Line 547  void DataTaggedTestCase::testAddTaggedVa Line 1560  void DataTaggedTestCase::testAddTaggedVa
1560    
1561      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1562      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1563        viewData1[i]=i+1;        viewData1[i]=i+3;
1564      }      }
1565      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1566      values.push_back(myView1);      values.push_back(myView1);
# Line 572  void DataTaggedTestCase::testAddTaggedVa Line 1585  void DataTaggedTestCase::testAddTaggedVa
1585      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1586      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1587      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1588      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1589      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1590      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1591    
1592      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
1593      assert(myDataView==myView1);      assert(myDataView==myView1);
# Line 583  void DataTaggedTestCase::testAddTaggedVa Line 1596  void DataTaggedTestCase::testAddTaggedVa
1596      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1597      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1598      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1599      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1600      assert(myDataView(1)==2);      assert(myDataView(1)==4);
1601      assert(myDataView(2)==3);      assert(myDataView(2)==5);
1602    
1603      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
1604      assert(myDataView==myView);      assert(myDataView==myView);
# Line 598  void DataTaggedTestCase::testAddTaggedVa Line 1611  void DataTaggedTestCase::testAddTaggedVa
1611      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1612      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1613    
1614        // use a non-existent tag so we get a pointer to
1615        // the first element of the data array
1616        double* sampleData=myData.getSampleDataByTag(9);
1617        for (int i=0; i<myData.getLength(); i++) {
1618          assert(sampleData[i]==i);
1619        }
1620    
1621    }    }
1622    
1623    {    {
# Line 625  void DataTaggedTestCase::testAddTaggedVa Line 1645  void DataTaggedTestCase::testAddTaggedVa
1645    
1646      DataArrayView::ValueType viewData1(3);      DataArrayView::ValueType viewData1(3);
1647      for (int i=0;i<viewShape[0];i++) {      for (int i=0;i<viewShape[0];i++) {
1648        viewData1[i]=i+1;        viewData1[i]=3;
1649      }      }
1650      DataArrayView myView1(viewData1,viewShape);      DataArrayView myView1(viewData1,viewShape);
1651      values.push_back(myView1);      values.push_back(myView1);
# Line 652  void DataTaggedTestCase::testAddTaggedVa Line 1672  void DataTaggedTestCase::testAddTaggedVa
1672      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1673      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1674      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1675      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1676      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1677      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1678    
1679      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
# Line 663  void DataTaggedTestCase::testAddTaggedVa Line 1683  void DataTaggedTestCase::testAddTaggedVa
1683      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1684      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1685      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1686      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1687      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1688      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1689    
1690      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 674  void DataTaggedTestCase::testAddTaggedVa Line 1694  void DataTaggedTestCase::testAddTaggedVa
1694      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1695      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1696      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1697      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1698      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1699      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1700    
1701      myDataView = myData.getDataPointByTag(3);      myDataView = myData.getDataPointByTag(3);
# Line 685  void DataTaggedTestCase::testAddTaggedVa Line 1705  void DataTaggedTestCase::testAddTaggedVa
1705      assert(myDataView.getRank()==1);      assert(myDataView.getRank()==1);
1706      assert(myDataView.noValues()==3);      assert(myDataView.noValues()==3);
1707      assert(myDataView.getShape().size()==1);      assert(myDataView.getShape().size()==1);
1708      assert(myDataView(0)==1);      assert(myDataView(0)==3);
1709      assert(myDataView(1)==2);      assert(myDataView(1)==3);
1710      assert(myDataView(2)==3);      assert(myDataView(2)==3);
1711    
1712      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 700  void DataTaggedTestCase::testAddTaggedVa Line 1720  void DataTaggedTestCase::testAddTaggedVa
1720      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1721      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1722    
1723        // use a non-existent tag so we get a pointer to
1724        // the first element of the data array
1725        double* sampleData=myData.getSampleDataByTag(9);
1726        for (int i=0; i<myData.getLength(); i++) {
1727          if (i<3) {
1728            assert(sampleData[i]==i);
1729          } else {
1730            assert(sampleData[i]==3);
1731          }
1732        }
1733    
1734    }    }
1735    
1736    {    {
# Line 816  void DataTaggedTestCase::testAddTaggedVa Line 1847  void DataTaggedTestCase::testAddTaggedVa
1847      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1848      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1849    
1850        // use a non-existent tag so we get a pointer to
1851        // the first element of the data array
1852        double* sampleData=myData.getSampleDataByTag(9);
1853        for (int i=0; i<myData.getLength(); i++) {
1854          if (i<3) {
1855            assert(sampleData[i]==i);
1856          } else if ((i>=3) && (i<6)) {
1857            assert(sampleData[i]==i-2);
1858          } else if ((i>=6) && (i<9)) {
1859            assert(sampleData[i]==i-4);
1860          } else  {
1861            assert(sampleData[i]==i-6);
1862          }
1863        }
1864    
1865    }    }
1866    
1867    {    {
# Line 885  void DataTaggedTestCase::testAddTaggedVa Line 1931  void DataTaggedTestCase::testAddTaggedVa
1931      assert(myDataView(1)==1);      assert(myDataView(1)==1);
1932      assert(myDataView(2)==2);      assert(myDataView(2)==2);
1933    
1934        // use a non-existent tag so we get a pointer to
1935        // the first element of the data array
1936        double* sampleData=myData.getSampleDataByTag(9);
1937        for (int i=0; i<myData.getLength(); i++) {
1938          if (i<3) {
1939            assert(sampleData[i]==i);
1940          } else if ((i>=3) && (i<6)) {
1941            assert(sampleData[i]==i-2);
1942          } else if ((i>=6) && (i<9)) {
1943            assert(sampleData[i]==i-4);
1944          } else if ((i>=9) && (i<12)) {
1945            assert(sampleData[i]==i-6);
1946          } else {
1947            assert(sampleData[i]==i-12);
1948          }
1949        }
1950    
1951    }    }
1952    
1953    {    {
# Line 961  void DataTaggedTestCase::testAddTaggedVa Line 2024  void DataTaggedTestCase::testAddTaggedVa
2024      assert(myDataView(1)==5);      assert(myDataView(1)==5);
2025      assert(myDataView(2)==6);      assert(myDataView(2)==6);
2026    
2027        // use a non-existent tag so we get a pointer to
2028        // the first element of the data array
2029        double* sampleData=myData.getSampleDataByTag(9);
2030        for (int i=0; i<myData.getLength(); i++) {
2031          if (i<3) {
2032            assert(sampleData[i]==i);
2033          } else if ((i>=3) && (i<6)) {
2034            assert(sampleData[i]==i-2);
2035          } else if ((i>=6) && (i<9)) {
2036            assert(sampleData[i]==i-4);
2037          } else if ((i>=9) && (i<12)) {
2038            assert(sampleData[i]==i-6);
2039          } else {
2040            assert(sampleData[i]==i-8);
2041          }
2042        }
2043    
2044    }    }
2045    
2046    {    {
# Line 1063  void DataTaggedTestCase::testAddTaggedVa Line 2143  void DataTaggedTestCase::testAddTaggedVa
2143      assert(myDataView(1)==5);      assert(myDataView(1)==5);
2144      assert(myDataView(2)==6);      assert(myDataView(2)==6);
2145    
2146        // use a non-existent tag so we get a pointer to
2147        // the first element of the data array
2148        double* sampleData=myData.getSampleDataByTag(9);
2149        for (int i=0; i<myData.getLength(); i++) {
2150          if (i<3) {
2151            assert(sampleData[i]==i);
2152          } else if ((i>=3) && (i<6)) {
2153            assert(sampleData[i]==i-2);
2154          } else if ((i>=6) && (i<9)) {
2155            assert(sampleData[i]==i-4);
2156          } else if ((i>=9) && (i<12)) {
2157            assert(sampleData[i]==i-6);
2158          } else if ((i>=12) && (i<15)) {
2159            assert(sampleData[i]==i-8);
2160          } else if ((i>=15) && (i<18)) {
2161            assert(sampleData[i]==i-11);
2162          } else {
2163            assert(sampleData[i]==i-14);
2164          }
2165        }
2166    
2167    }    }
2168    
2169    {    {
# Line 1180  void DataTaggedTestCase::testAddTaggedVa Line 2281  void DataTaggedTestCase::testAddTaggedVa
2281      assert(myDataView(1)==7);      assert(myDataView(1)==7);
2282      assert(myDataView(2)==8);      assert(myDataView(2)==8);
2283    
2284        // use a non-existent tag so we get a pointer to
2285        // the first element of the data array
2286        double* sampleData=myData.getSampleDataByTag(9);
2287        for (int i=0; i<myData.getLength(); i++) {
2288          if (i<3) {
2289            assert(sampleData[i]==i);
2290          } else if ((i>=3) && (i<6)) {
2291            assert(sampleData[i]==i-2);
2292          } else if ((i>=6) && (i<9)) {
2293            assert(sampleData[i]==i-4);
2294          } else if ((i>=9) && (i<12)) {
2295            assert(sampleData[i]==i-6);
2296          } else if ((i>=12) && (i<15)) {
2297            assert(sampleData[i]==i-8);
2298          } else if ((i>=15) && (i<18)) {
2299            assert(sampleData[i]==i-10);
2300          } else {
2301            assert(sampleData[i]==i-12);
2302          }
2303        }
2304    
2305    }    }
2306    
2307  }  }
# Line 1256  void DataTaggedTestCase::testSetTaggedVa Line 2378  void DataTaggedTestCase::testSetTaggedVa
2378      assert(myDataView(1)==6);      assert(myDataView(1)==6);
2379      assert(myDataView(2)==7);      assert(myDataView(2)==7);
2380    
2381        // use a non-existent tag so we get a pointer to
2382        // the first element of the data array
2383        double* sampleData=myData.getSampleDataByTag(9);
2384        for (int i=0; i<myData.getLength(); i++) {
2385          if (i<3) {
2386            assert(sampleData[i]==i);
2387          } else if ((i>=3) && (i<6)) {
2388            assert(sampleData[i]==i-2);
2389          } else if ((i>=6) && (i<9)) {
2390            assert(sampleData[i]==i-1);
2391          } else {
2392            assert(sampleData[i]==i-6);
2393          }
2394        }
2395    
2396    }    }
2397    
2398  }  }
# Line 1315  void DataTaggedTestCase::testAll() { Line 2452  void DataTaggedTestCase::testAll() {
2452      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2453      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2454    
2455        // use a non-existent tag so we get a pointer to
2456        // the first element of the data array
2457        double* sampleData=myData.getSampleDataByTag(9);
2458        for (int i=0; i<myData.getLength(); i++) {
2459          assert(sampleData[i]==i);
2460        }
2461        sampleData=myData.getSampleData(0);
2462        for (int i=0; i<myDataView.noValues(); i++) {
2463          assert(sampleData[i]==i);
2464        }
2465    
2466    }    }
2467    
2468    {    {
# Line 1391  void DataTaggedTestCase::testAll() { Line 2539  void DataTaggedTestCase::testAll() {
2539      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2540      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2541    
2542        // use a non-existent tag so we get a pointer to
2543        // the first element of the data array
2544        double* sampleData=myData.getSampleDataByTag(9);
2545        for (int i=0; i<myData.getLength(); i++) {
2546          assert(sampleData[i]==i);
2547        }
2548        sampleData=myData.getSampleDataByTag(0);
2549        for (int i=0; i<myDataView.noValues(); i++) {
2550          assert(sampleData[i]==i);
2551        }
2552    
2553    }    }
2554    
2555    {    {
# Line 1468  void DataTaggedTestCase::testAll() { Line 2627  void DataTaggedTestCase::testAll() {
2627      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2628    
2629      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2630      myDataView = myData.getDataPointByTag(0);      myDataView = myData.getDataPointByTag(9);
2631      assert(myDataView==myView);      assert(myDataView==myView);
2632      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2633      assert(myDataView.getOffset()==0);      assert(myDataView.getOffset()==0);
# Line 1490  void DataTaggedTestCase::testAll() { Line 2649  void DataTaggedTestCase::testAll() {
2649      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2650      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2651    
2652        // use a non-existent tag so we get a pointer to
2653        // the first element of the data array
2654        double* sampleData=myData.getSampleDataByTag(9);
2655        for (int i=0; i<myData.getLength(); i++) {
2656          if (i<3) {
2657            assert(sampleData[i]==i);
2658          } else {
2659            assert(sampleData[i]==i-2);
2660          }
2661        }
2662        sampleData=myData.getSampleData(0);
2663        for (int i=0; i<myDataView.noValues(); i++) {
2664          assert(sampleData[i]==i+1);
2665        }
2666    
2667    }    }
2668    
2669    {    {
# Line 1630  void DataTaggedTestCase::testAll() { Line 2804  void DataTaggedTestCase::testAll() {
2804      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2805      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2806    
2807        // use a non-existent tag so we get a pointer to
2808        // the first element of the data array
2809        double* sampleData=myData.getSampleDataByTag(9);
2810        for (int i=0; i<myData.getLength(); i++) {
2811          if (i<3) {
2812            assert(sampleData[i]==i);
2813          } else if ((i>=3) && (i<6)) {
2814            assert(sampleData[i]==i-2);
2815          } else if ((i>=6) && (i<9)) {
2816            assert(sampleData[i]==i-4);
2817          } else {
2818            assert(sampleData[i]==i-6);
2819          }
2820        }
2821        sampleData=myData.getSampleData(0);
2822        for (int i=0; i<myDataView.noValues(); i++) {
2823          assert(sampleData[i]==i+1);
2824        }
2825    
2826    }    }
2827    
2828  }  }
# Line 1778  void DataTaggedTestCase::testCopyConstru Line 2971  void DataTaggedTestCase::testCopyConstru
2971      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2972      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2973    
2974        // use a non-existent tag so we get a pointer to
2975        // the first element of the data array
2976        double* sampleData=myDataCopy.getSampleDataByTag(9);
2977        for (int i=0; i<myData.getLength(); i++) {
2978          if (i<3) {
2979            assert(sampleData[i]==i);
2980          } else if ((i>=3) && (i<6)) {
2981            assert(sampleData[i]==i-2);
2982          } else if ((i>=6) && (i<9)) {
2983            assert(sampleData[i]==i-4);
2984          } else {
2985            assert(sampleData[i]==i-6);
2986          }
2987        }
2988    
2989    }    }
2990    
2991    {    {
# Line 1840  void DataTaggedTestCase::testCopyConstru Line 3048  void DataTaggedTestCase::testCopyConstru
3048      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
3049      assert(myDataView()==1.0);      assert(myDataView()==1.0);
3050    
3051        // use a non-existent tag so we get a pointer to
3052        // the first element of the data array
3053        double* sampleData=myData.getSampleDataByTag(9);
3054        for (int i=0; i<myData.getLength(); i++) {
3055          assert(sampleData[i]==i+1);
3056        }
3057    
3058      }
3059    
3060    }
3061    
3062    void DataTaggedTestCase::testGetSlice() {
3063    
3064      cout << endl;
3065    
3066      {
3067    
3068        cout << "\tTest slicing default DataTagged." << endl;
3069    
3070        DataTagged myData;
3071    
3072        DataArrayView::RegionType region;
3073    
3074        DataAbstract* slicedDefault = myData.getSlice(region);
3075    
3076        // cout << slicedDefault->toString() << endl;
3077    
3078        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3079    
3080        assert(myDataSliced->getTagLookup().size()==0);
3081    
3082        assert(myDataSliced->getLength()==1);
3083    
3084        DataArrayView myDataView = myDataSliced->getDefaultValue();
3085        assert(!myDataView.isEmpty());
3086        assert(myDataView.getOffset()==0);
3087        assert(myDataView.getRank()==0);
3088        assert(myDataView.noValues()==1);
3089        assert(myDataView.getShape().size()==0);
3090        assert(myDataView()==0.0);
3091    
3092      }
3093    
3094      {
3095    
3096        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
3097    
3098        DataArrayView::ShapeType viewShape;
3099        viewShape.push_back(3);
3100    
3101        DataTagged::TagListType keys;
3102    
3103        DataTagged::ValueListType values;
3104    
3105        DataArrayView::ValueType viewData(3);
3106        for (int i=0;i<viewShape[0];i++) {
3107          viewData[i]=i;
3108        }
3109        DataArrayView myView(viewData,viewShape);
3110    
3111        DataTagged myData(keys,values,myView,FunctionSpace());
3112    
3113        // full slice
3114    
3115        std::pair<int, int> region_element;
3116        region_element.first=0;
3117        region_element.second=3;
3118        DataArrayView::RegionType region;
3119        region.push_back(region_element);
3120    
3121        DataAbstract* slicedDefault = myData.getSlice(region);
3122    
3123        //cout << slicedDefault->toString() << endl;
3124    
3125        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3126    
3127        assert(myDataSliced->getTagLookup().size()==0);
3128    
3129        assert(myDataSliced->getLength()==3);
3130    
3131        DataArrayView myDataView = myDataSliced->getDefaultValue();
3132        assert(!myDataView.isEmpty());
3133        assert(myDataView.getOffset()==0);
3134        assert(myDataView.getRank()==1);
3135        assert(myDataView.noValues()==3);
3136        assert(myDataView.getShape().size()==1);
3137        assert(myDataView(0)==0.0);
3138        assert(myDataView(1)==1.0);
3139        assert(myDataView(2)==2.0);
3140    
3141        // scalar slice
3142    
3143        region.clear();
3144        region_element.first=0;
3145        region_element.second=0;
3146        region.push_back(region_element);
3147    
3148        slicedDefault = myData.getSlice(region);
3149    
3150        //cout << slicedDefault->toString() << endl;
3151    
3152        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3153    
3154        assert(myDataSliced->getTagLookup().size()==0);
3155    
3156        assert(myDataSliced->getLength()==1);
3157    
3158        myDataView = myDataSliced->getDefaultValue();
3159        assert(!myDataView.isEmpty());
3160        assert(myDataView.getOffset()==0);
3161        assert(myDataView.getRank()==0);
3162        assert(myDataView.noValues()==1);
3163        assert(myDataView.getShape().size()==0);
3164        assert(myDataView()==0.0);
3165    
3166      }
3167    
3168      {
3169    
3170        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
3171    
3172        DataArrayView::ShapeType viewShape;
3173        viewShape.push_back(3);
3174        viewShape.push_back(3);
3175        viewShape.push_back(3);
3176    
3177        DataTagged::TagListType keys;
3178    
3179        DataTagged::ValueListType values;
3180    
3181        DataArrayView::ValueType viewData(27);
3182        for (int i=0;i<viewData.size();i++) {
3183          viewData[i]=i;
3184        }
3185        DataArrayView myView(viewData,viewShape);
3186    
3187        DataTagged myData(keys,values,myView,FunctionSpace());
3188    
3189        //cout << myData.toString() << endl;
3190    
3191        // full slice
3192    
3193        std::pair<int, int> region_element;
3194        region_element.first=0;
3195        region_element.second=3;
3196        DataArrayView::RegionType region;
3197        region.push_back(region_element);
3198        region.push_back(region_element);
3199        region.push_back(region_element);
3200    
3201        DataAbstract* slicedDefault = myData.getSlice(region);
3202    
3203        //cout << slicedDefault->toString() << endl;
3204    
3205        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3206    
3207        assert(myDataSliced->getTagLookup().size()==0);
3208    
3209        assert(myDataSliced->getLength()==27);
3210    
3211        DataArrayView myDataView = myDataSliced->getDefaultValue();
3212        assert(!myDataView.isEmpty());
3213        assert(myDataView.getOffset()==0);
3214        assert(myDataView.getRank()==3);
3215        assert(myDataView.noValues()==27);
3216        assert(myDataView.getShape().size()==3);
3217    
3218        // rank 1 slice
3219    
3220        region.clear();
3221        region.push_back(region_element);
3222        region_element.second=0;
3223        region.push_back(region_element);
3224        region.push_back(region_element);
3225    
3226        slicedDefault = myData.getSlice(region);
3227    
3228        //cout << slicedDefault->toString() << endl;
3229    
3230        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3231    
3232        assert(myDataSliced->getTagLookup().size()==0);
3233    
3234        assert(myDataSliced->getLength()==3);
3235    
3236        myDataView = myDataSliced->getDefaultValue();
3237        assert(!myDataView.isEmpty());
3238        assert(myDataView.getOffset()==0);
3239        assert(myDataView.getRank()==1);
3240        assert(myDataView.noValues()==3);
3241        assert(myDataView.getShape().size()==1);
3242        assert(myDataView(0)==0.0);
3243        assert(myDataView(1)==1.0);
3244        assert(myDataView(2)==2.0);
3245    
3246        // scalar slice
3247    
3248        region.clear();
3249        region_element.first=2;
3250        region_element.second=2;
3251        region.push_back(region_element);
3252        region.push_back(region_element);
3253        region.push_back(region_element);
3254    
3255        slicedDefault = myData.getSlice(region);
3256    
3257        //cout << slicedDefault->toString() << endl;
3258    
3259        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3260    
3261        assert(myDataSliced->getTagLookup().size()==0);
3262    
3263        assert(myDataSliced->getLength()==1);
3264    
3265        myDataView = myDataSliced->getDefaultValue();
3266        assert(!myDataView.isEmpty());
3267        assert(myDataView.getOffset()==0);
3268        assert(myDataView.getRank()==0);
3269        assert(myDataView.noValues()==1);
3270        assert(myDataView.getShape().size()==0);
3271        assert(myDataView()==26);
3272    
3273      }
3274    
3275      {
3276    
3277        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
3278    
3279        DataTagged::TagListType keys;
3280        keys.push_back(1);
3281    
3282        DataTagged::ValueListType values;
3283    
3284        DataArrayView::ShapeType viewShape;
3285    
3286        // default value
3287        DataArrayView::ValueType viewData(1);
3288        viewData[0]=0.0;
3289        DataArrayView myView(viewData,viewShape);
3290    
3291        // value for tag "1"
3292        DataArray eOne(myView);
3293        eOne.getView()()=1.0;
3294        values.push_back(eOne.getView());
3295    
3296        DataTagged myData(keys,values,myView,FunctionSpace());
3297    
3298        //cout << myData.toString() << endl;
3299    
3300        // full slice
3301    
3302        DataArrayView::RegionType region;
3303    
3304        DataAbstract* slicedDefault = myData.getSlice(region);
3305    
3306        //cout << slicedDefault->toString() << endl;
3307    
3308        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3309    
3310        assert(myDataSliced->getTagLookup().size()==1);
3311    
3312        assert(myDataSliced->getLength()==2);
3313    
3314        DataArrayView myDataView = myDataSliced->getDefaultValue();
3315        assert(!myDataView.isEmpty());
3316        assert(myDataView.getOffset()==0);
3317        assert(myDataView.getRank()==0);
3318        assert(myDataView.noValues()==1);
3319        assert(myDataView.getShape().size()==0);
3320        assert(myDataView()==0);
3321    
3322        myDataView = myDataSliced->getDataPointByTag(1);
3323        assert(!myDataView.isEmpty());
3324        assert(myDataView.getOffset()==1);
3325        assert(myDataView.getRank()==0);
3326        assert(myDataView.noValues()==1);
3327        assert(myDataView.getShape().size()==0);
3328        assert(myDataView()==1);
3329    
3330      }
3331    
3332      {
3333    
3334        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
3335    
3336        DataArrayView::ShapeType viewShape;
3337        viewShape.push_back(3);
3338    
3339        DataTagged::TagListType keys;
3340        keys.push_back(1);
3341    
3342        DataTagged::ValueListType values;
3343    
3344        // default value
3345        DataArrayView::ValueType viewData(3);
3346        for (int i=0;i<viewShape[0];i++) {
3347          viewData[i]=i;
3348        }
3349        DataArrayView myView(viewData,viewShape);
3350    
3351        // value for tag "1"
3352        DataArray eOne(myView);
3353        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3354          eOne.getView()(i)=i+3.0;
3355        }
3356        values.push_back(eOne.getView());
3357    
3358        DataTagged myData(keys,values,myView,FunctionSpace());
3359    
3360        //cout << myData.toString() << endl;
3361    
3362        // full slice
3363    
3364        std::pair<int, int> region_element;
3365        region_element.first=0;
3366        region_element.second=3;
3367        DataArrayView::RegionType region;
3368        region.push_back(region_element);
3369    
3370        DataAbstract* slicedDefault = myData.getSlice(region);
3371    
3372        //cout << slicedDefault->toString() << endl;
3373    
3374        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3375    
3376        assert(myDataSliced->getTagLookup().size()==1);
3377    
3378        assert(myDataSliced->getLength()==6);
3379    
3380        DataArrayView myDataView = myDataSliced->getDefaultValue();
3381        assert(!myDataView.isEmpty());
3382        assert(myDataView.getOffset()==0);
3383        assert(myDataView.getRank()==1);
3384        assert(myDataView.noValues()==3);
3385        assert(myDataView.getShape().size()==1);
3386        assert(myDataView(0)==0);
3387        assert(myDataView(1)==1);
3388        assert(myDataView(2)==2);
3389    
3390        myDataView = myDataSliced->getDataPointByTag(1);
3391        assert(!myDataView.isEmpty());
3392        assert(myDataView.getOffset()==3);
3393        assert(myDataView.getRank()==1);
3394        assert(myDataView.noValues()==3);
3395        assert(myDataView.getShape().size()==1);
3396        assert(myDataView(0)==3);
3397        assert(myDataView(1)==4);
3398        assert(myDataView(2)==5);
3399    
3400        // scalar slice
3401    
3402        region_element.first=1;
3403        region_element.second=1;
3404        region.clear();
3405        region.push_back(region_element);
3406    
3407        slicedDefault = myData.getSlice(region);
3408    
3409        //cout << slicedDefault->toString() << endl;
3410    
3411        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3412    
3413        assert(myDataSliced->getTagLookup().size()==1);
3414    
3415        assert(myDataSliced->getLength()==2);
3416    
3417        myDataView = myDataSliced->getDefaultValue();
3418        assert(!myDataView.isEmpty());
3419        assert(myDataView.getOffset()==0);
3420        assert(myDataView.getRank()==0);
3421        assert(myDataView.noValues()==1);
3422        assert(myDataView.getShape().size()==0);
3423        assert(myDataView()==1);
3424    
3425        myDataView = myDataSliced->getDataPointByTag(1);
3426        assert(!myDataView.isEmpty());
3427        assert(myDataView.getOffset()==1);
3428        assert(myDataView.getRank()==0);
3429        assert(myDataView.noValues()==1);
3430        assert(myDataView.getShape().size()==0);
3431        assert(myDataView()==4);
3432    
3433      }
3434    
3435      {
3436    
3437        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
3438    
3439        DataArrayView::ShapeType viewShape;
3440        viewShape.push_back(3);
3441        viewShape.push_back(3);
3442        viewShape.push_back(3);
3443    
3444        DataTagged::TagListType keys;
3445        keys.push_back(1);
3446    
3447        DataTagged::ValueListType values;
3448    
3449        // default value
3450        DataArrayView::ValueType viewData(27);
3451        for (int i=0;i<viewData.size();i++) {
3452          viewData[i]=i;
3453        }
3454        DataArrayView myView(viewData,viewShape);
3455    
3456        // value for tag "1"
3457        DataArrayView::ValueType viewData1(27);
3458        for (int i=0;i<viewData1.size();i++) {
3459          viewData1[i]=i+27.0;
3460        }
3461        DataArrayView myView1(viewData1,viewShape);
3462        values.push_back(myView1);
3463    
3464        DataTagged myData(keys,values,myView,FunctionSpace());
3465    
3466        //cout << myData.toString() << endl;
3467    
3468        // full slice
3469    
3470        std::pair<int, int> region_element;
3471        region_element.first=0;
3472        region_element.second=3;
3473        DataArrayView::RegionType region;
3474        region.push_back(region_element);
3475        region.push_back(region_element);
3476        region.push_back(region_element);
3477    
3478        DataAbstract* slicedDefault = myData.getSlice(region);
3479    
3480        //cout << slicedDefault->toString() << endl;
3481    
3482        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3483    
3484        assert(myDataSliced->getTagLookup().size()==1);
3485    
3486        assert(myDataSliced->getLength()==54);
3487    
3488        DataArrayView myDataView = myDataSliced->getDefaultValue();
3489        assert(!myDataView.isEmpty());
3490        assert(myDataView.getOffset()==0);
3491        assert(myDataView.getRank()==3);
3492        assert(myDataView.noValues()==27);
3493        assert(myDataView.getShape().size()==3);
3494    
3495        myDataView = myDataSliced->getDataPointByTag(1);
3496        assert(!myDataView.isEmpty());
3497        assert(myDataView.getOffset()==27);
3498        assert(myDataView.getRank()==3);
3499        assert(myDataView.noValues()==27);
3500        assert(myDataView.getShape().size()==3);
3501    
3502        // rank 1 slice
3503    
3504        region.clear();
3505        region.push_back(region_element);
3506        region_element.second=0;
3507        region.push_back(region_element);
3508        region.push_back(region_element);
3509    
3510        slicedDefault = myData.getSlice(region);
3511    
3512        //cout << slicedDefault->toString() << endl;
3513    
3514        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3515    
3516        assert(myDataSliced->getTagLookup().size()==1);
3517    
3518        assert(myDataSliced->getLength()==6);
3519    
3520        myDataView = myDataSliced->getDefaultValue();
3521        assert(!myDataView.isEmpty());
3522        assert(myDataView.getOffset()==0);
3523        assert(myDataView.getRank()==1);
3524        assert(myDataView.noValues()==3);
3525        assert(myDataView.getShape().size()==1);
3526        assert(myDataView(0)==0);
3527        assert(myDataView(1)==1);
3528        assert(myDataView(2)==2);
3529    
3530        myDataView = myDataSliced->getDataPointByTag(1);
3531        assert(!myDataView.isEmpty());
3532        assert(myDataView.getOffset()==3);
3533        assert(myDataView.getRank()==1);
3534        assert(myDataView.noValues()==3);
3535        assert(myDataView.getShape().size()==1);
3536        assert(myDataView(0)==27);
3537        assert(myDataView(1)==28);
3538        assert(myDataView(2)==29);
3539    
3540        // scalar slice
3541    
3542        region_element.first=1;
3543        region_element.second=1;
3544        region.clear();
3545        region.push_back(region_element);
3546        region.push_back(region_element);
3547        region.push_back(region_element);
3548    
3549        slicedDefault = myData.getSlice(region);
3550    
3551        //cout << slicedDefault->toString() << endl;
3552    
3553        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3554    
3555        assert(myDataSliced->getTagLookup().size()==1);
3556    
3557        assert(myDataSliced->getLength()==2);
3558    
3559        myDataView = myDataSliced->getDefaultValue();
3560        assert(!myDataView.isEmpty());
3561        assert(myDataView.getOffset()==0);
3562        assert(myDataView.getRank()==0);
3563        assert(myDataView.noValues()==1);
3564        assert(myDataView.getShape().size()==0);
3565        assert(myDataView()==13);
3566    
3567        myDataView = myDataSliced->getDataPointByTag(1);
3568        assert(!myDataView.isEmpty());
3569        assert(myDataView.getOffset()==1);
3570        assert(myDataView.getRank()==0);
3571        assert(myDataView.noValues()==1);
3572        assert(myDataView.getShape().size()==0);
3573        assert(myDataView()==40);
3574    
3575      }
3576    
3577      {
3578    
3579        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
3580    
3581        DataTagged::TagListType keys;
3582        keys.push_back(1);
3583        keys.push_back(2);
3584        keys.push_back(3);
3585    
3586        DataTagged::ValueListType values;
3587    
3588        DataArrayView::ShapeType viewShape;
3589    
3590        // default value
3591        DataArrayView::ValueType viewData(1);
3592        viewData[0]=0.0;
3593        DataArrayView myView(viewData,viewShape);
3594    
3595        // value for tag "1"
3596        DataArray eOne(myView);
3597        eOne.getView()()=1.0;
3598        values.push_back(eOne.getView());
3599    
3600        // value for tag "2"
3601        DataArray eTwo(myView);
3602        eTwo.getView()()=2.0;
3603        values.push_back(eTwo.getView());
3604    
3605        // value for tag "3"
3606        DataArray eThree(myView);
3607        eThree.getView()()=3.0;
3608        values.push_back(eThree.getView());
3609    
3610        DataTagged myData(keys,values,myView,FunctionSpace());
3611    
3612        // cout << myData.toString() << endl;
3613    
3614        // full slice
3615    
3616        DataArrayView::RegionType region;
3617    
3618        DataAbstract* slicedDefault = myData.getSlice(region);
3619    
3620        //cout << slicedDefault->toString() << endl;
3621    
3622        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3623    
3624        assert(myDataSliced->getTagLookup().size()==3);
3625    
3626        assert(myDataSliced->getLength()==4);
3627    
3628        DataArrayView myDataView = myDataSliced->getDefaultValue();
3629        assert(!myDataView.isEmpty());
3630        assert(myDataView.getOffset()==0);
3631        assert(myDataView.getRank()==0);
3632        assert(myDataView.noValues()==1);
3633        assert(myDataView.getShape().size()==0);
3634        assert(myDataView()==0);
3635    
3636        myDataView = myDataSliced->getDataPointByTag(1);
3637        assert(!myDataView.isEmpty());
3638        assert(myDataView.getOffset()==1);
3639        assert(myDataView.getRank()==0);
3640        assert(myDataView.noValues()==1);
3641        assert(myDataView.getShape().size()==0);
3642        assert(myDataView()==1);
3643    
3644        myDataView = myDataSliced->getDataPointByTag(2);
3645        assert(!myDataView.isEmpty());
3646        assert(myDataView.getOffset()==2);
3647        assert(myDataView.getRank()==0);
3648        assert(myDataView.noValues()==1);
3649        assert(myDataView.getShape().size()==0);
3650        assert(myDataView()==2);
3651    
3652        myDataView = myDataSliced->getDataPointByTag(3);
3653        assert(!myDataView.isEmpty());
3654        assert(myDataView.getOffset()==3);
3655        assert(myDataView.getRank()==0);
3656        assert(myDataView.noValues()==1);
3657        assert(myDataView.getShape().size()==0);
3658        assert(myDataView()==3);
3659    
3660      }
3661    
3662      {
3663    
3664        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
3665    
3666        DataArrayView::ShapeType viewShape;
3667        viewShape.push_back(3);
3668    
3669        DataTagged::TagListType keys;
3670        keys.push_back(1);
3671        keys.push_back(2);
3672        keys.push_back(3);
3673    
3674        DataTagged::ValueListType values;
3675    
3676        // default value
3677        DataArrayView::ValueType viewData(3);
3678        for (int i=0;i<viewShape[0];i++) {
3679          viewData[i]=i;
3680        }
3681        DataArrayView myView(viewData,viewShape);
3682    
3683        // value for tag "1"
3684        DataArray eOne(myView);
3685        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3686          eOne.getView()(i)=i+3.0;
3687        }
3688        values.push_back(eOne.getView());
3689    
3690        // value for tag "2"
3691        DataArray eTwo(myView);
3692        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
3693          eTwo.getView()(i)=i+6.0;
3694        }
3695        values.push_back(eTwo.getView());
3696    
3697        // value for tag "3"
3698        DataArray eThree(myView);
3699        for (int i=0;i<eThree.getView().getShape()[0];i++) {
3700          eThree.getView()(i)=i+9.0;
3701        }
3702        values.push_back(eThree.getView());
3703    
3704        DataTagged myData(keys,values,myView,FunctionSpace());
3705    
3706        //cout << myData.toString() << endl;
3707    
3708        // full slice
3709    
3710        std::pair<int, int> region_element;
3711        region_element.first=0;
3712        region_element.second=3;
3713        DataArrayView::RegionType region;
3714        region.push_back(region_element);
3715    
3716        DataAbstract* slicedDefault = myData.getSlice(region);
3717    
3718        //cout << slicedDefault->toString() << endl;
3719    
3720        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3721    
3722        assert(myDataSliced->getTagLookup().size()==3);
3723    
3724        assert(myDataSliced->getLength()==12);
3725    
3726        DataArrayView myDataView = myDataSliced->getDefaultValue();
3727        assert(!myDataView.isEmpty());
3728        assert(myDataView.getOffset()==0);
3729        assert(myDataView.getRank()==1);
3730        assert(myDataView.noValues()==3);
3731        assert(myDataView.getShape().size()==1);
3732        assert(myDataView(0)==0);
3733        assert(myDataView(1)==1);
3734        assert(myDataView(2)==2);
3735    
3736        myDataView = myDataSliced->getDataPointByTag(1);
3737        assert(!myDataView.isEmpty());
3738        assert(myDataView.getOffset()==3);
3739        assert(myDataView.getRank()==1);
3740        assert(myDataView.noValues()==3);
3741        assert(myDataView.getShape().size()==1);
3742        assert(myDataView(0)==3);
3743        assert(myDataView(1)==4);
3744        assert(myDataView(2)==5);
3745    
3746        myDataView = myDataSliced->getDataPointByTag(2);
3747        assert(!myDataView.isEmpty());
3748        assert(myDataView.getOffset()==6);
3749        assert(myDataView.getRank()==1);
3750        assert(myDataView.noValues()==3);
3751        assert(myDataView.getShape().size()==1);
3752        assert(myDataView(0)==6);
3753        assert(myDataView(1)==7);
3754        assert(myDataView(2)==8);
3755    
3756        myDataView = myDataSliced->getDataPointByTag(3);
3757        assert(!myDataView.isEmpty());
3758        assert(myDataView.getOffset()==9);
3759        assert(myDataView.getRank()==1);
3760        assert(myDataView.noValues()==3);
3761        assert(myDataView.getShape().size()==1);
3762        assert(myDataView(0)==9);
3763        assert(myDataView(1)==10);
3764        assert(myDataView(2)==11);
3765    
3766        // scalar slice
3767    
3768        region.clear();
3769        region_element.first=1;
3770        region_element.second=1;
3771        region.push_back(region_element);
3772    
3773        slicedDefault = myData.getSlice(region);
3774    
3775        //cout << slicedDefault->toString() << endl;
3776    
3777        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3778    
3779        assert(myDataSliced->getTagLookup().size()==3);
3780    
3781        assert(myDataSliced->getLength()==4);
3782    
3783        myDataView = myDataSliced->getDefaultValue();
3784        assert(!myDataView.isEmpty());
3785        assert(myDataView.getOffset()==0);
3786        assert(myDataView.getRank()==0);
3787        assert(myDataView.noValues()==1);
3788        assert(myDataView.getShape().size()==0);
3789        assert(myDataView()==1);
3790    
3791        myDataView = myDataSliced->getDataPointByTag(1);
3792        assert(!myDataView.isEmpty());
3793        assert(myDataView.getOffset()==1);
3794        assert(myDataView.getRank()==0);
3795        assert(myDataView.noValues()==1);
3796        assert(myDataView.getShape().size()==0);
3797        assert(myDataView()==4);
3798    
3799        myDataView = myDataSliced->getDataPointByTag(2);
3800        assert(!myDataView.isEmpty());
3801        assert(myDataView.getOffset()==2);
3802        assert(myDataView.getRank()==0);
3803        assert(myDataView.noValues()==1);
3804        assert(myDataView.getShape().size()==0);
3805        assert(myDataView()==7);
3806    
3807        myDataView = myDataSliced->getDataPointByTag(3);
3808        assert(!myDataView.isEmpty());
3809        assert(myDataView.getOffset()==3);
3810        assert(myDataView.getRank()==0);
3811        assert(myDataView.noValues()==1);
3812        assert(myDataView.getShape().size()==0);
3813        assert(myDataView()==10);
3814    
3815      }
3816    
3817      {
3818    
3819        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
3820    
3821        DataArrayView::ShapeType viewShape;
3822        viewShape.push_back(3);
3823        viewShape.push_back(3);
3824        viewShape.push_back(3);
3825    
3826        DataTagged::TagListType keys;
3827        keys.push_back(1);
3828        keys.push_back(2);
3829        keys.push_back(3);
3830    
3831        DataTagged::ValueListType values;
3832    
3833        // default value
3834        DataArrayView::ValueType viewData(27);
3835        for (int i=0;i<viewData.size();i++) {
3836          viewData[i]=i;
3837        }
3838        DataArrayView myView(viewData,viewShape);
3839    
3840        // value for tag "1"
3841        DataArrayView::ValueType viewData1(27);
3842        for (int i=0;i<viewData1.size();i++) {
3843          viewData1[i]=i+27.0;
3844        }
3845        DataArrayView myView1(viewData1,viewShape);
3846        values.push_back(myView1);
3847    
3848        // value for tag "2"
3849        DataArrayView::ValueType viewData2(27);
3850        for (int i=0;i<viewData2.size();i++) {
3851          viewData2[i]=i+54.0;
3852        }
3853        DataArrayView myView2(viewData2,viewShape);
3854        values.push_back(myView2);
3855    
3856        // value for tag "3"
3857        DataArrayView::ValueType viewData3(27);
3858        for (int i=0;i<viewData3.size();i++) {
3859          viewData3[i]=i+81.0;
3860        }
3861        DataArrayView myView3(viewData3,viewShape);
3862        values.push_back(myView3);
3863    
3864        DataTagged myData(keys,values,myView,FunctionSpace());
3865    
3866        //cout << myData.toString() << endl;
3867    
3868        // full slice
3869    
3870        std::pair<int, int> region_element;
3871        region_element.first=0;
3872        region_element.second=3;
3873        DataArrayView::RegionType region;
3874        region.push_back(region_element);
3875        region.push_back(region_element);
3876        region.push_back(region_element);
3877    
3878        DataAbstract* slicedDefault = myData.getSlice(region);
3879    
3880        //cout << slicedDefault->toString() << endl;
3881    
3882        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3883    
3884        assert(myDataSliced->getTagLookup().size()==3);
3885    
3886        assert(myDataSliced->getLength()==108);
3887    
3888        DataArrayView myDataView = myDataSliced->getDefaultValue();
3889        assert(!myDataView.isEmpty());
3890        assert(myDataView.getOffset()==0);
3891        assert(myDataView.getRank()==3);
3892        assert(myDataView.noValues()==27);
3893        assert(myDataView.getShape().size()==3);
3894    
3895        myDataView = myDataSliced->getDataPointByTag(1);
3896        assert(!myDataView.isEmpty());
3897        assert(myDataView.getOffset()==27);
3898        assert(myDataView.getRank()==3);
3899        assert(myDataView.noValues()==27);
3900        assert(myDataView.getShape().size()==3);
3901    
3902        myDataView = myDataSliced->getDataPointByTag(2);
3903        assert(!myDataView.isEmpty());
3904        assert(myDataView.getOffset()==54);
3905        assert(myDataView.getRank()==3);
3906        assert(myDataView.noValues()==27);
3907        assert(myDataView.getShape().size()==3);
3908    
3909        myDataView = myDataSliced->getDataPointByTag(3);
3910        assert(!myDataView.isEmpty());
3911        assert(myDataView.getOffset()==81);
3912        assert(myDataView.getRank()==3);
3913        assert(myDataView.noValues()==27);
3914        assert(myDataView.getShape().size()==3);
3915    
3916        // rank 1 slice
3917    
3918        region.clear();
3919        region.push_back(region_element);
3920        region_element.second=0;
3921        region.push_back(region_element);
3922        region.push_back(region_element);
3923    
3924        slicedDefault = myData.getSlice(region);
3925    
3926        // cout << slicedDefault->toString() << endl;
3927    
3928        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3929    
3930        assert(myDataSliced->getTagLookup().size()==3);
3931    
3932        assert(myDataSliced->getLength()==12);
3933    
3934        myDataView = myDataSliced->getDefaultValue();
3935        assert(!myDataView.isEmpty());
3936        assert(myDataView.getOffset()==0);
3937        assert(myDataView.getRank()==1);
3938        assert(myDataView.noValues()==3);
3939        assert(myDataView.getShape().size()==1);
3940        assert(myDataView(0)==0);
3941        assert(myDataView(1)==1);
3942        assert(myDataView(2)==2);
3943    
3944        myDataView = myDataSliced->getDataPointByTag(1);
3945        assert(!myDataView.isEmpty());
3946        assert(myDataView.getOffset()==3);
3947        assert(myDataView.getRank()==1);
3948        assert(myDataView.noValues()==3);
3949        assert(myDataView.getShape().size()==1);
3950        assert(myDataView(0)==27);
3951        assert(myDataView(1)==28);
3952        assert(myDataView(2)==29);
3953    
3954        myDataView = myDataSliced->getDataPointByTag(2);
3955        assert(!myDataView.isEmpty());
3956        assert(myDataView.getOffset()==6);
3957        assert(myDataView.getRank()==1);
3958        assert(myDataView.noValues()==3);
3959        assert(myDataView.getShape().size()==1);
3960        assert(myDataView(0)==54);
3961        assert(myDataView(1)==55);
3962        assert(myDataView(2)==56);
3963    
3964        myDataView = myDataSliced->getDataPointByTag(3);
3965        assert(!myDataView.isEmpty());
3966        assert(myDataView.getOffset()==9);
3967        assert(myDataView.getRank()==1);
3968        assert(myDataView.noValues()==3);
3969        assert(myDataView.getShape().size()==1);
3970        assert(myDataView(0)==81);
3971        assert(myDataView(1)==82);
3972        assert(myDataView(2)==83);
3973    
3974        // scalar slice
3975    
3976        region_element.first=1;
3977        region_element.second=1;
3978        region.clear();
3979        region.push_back(region_element);
3980        region.push_back(region_element);
3981        region.push_back(region_element);
3982    
3983        slicedDefault = myData.getSlice(region);
3984    
3985        //cout << slicedDefault->toString() << endl;
3986    
3987        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3988    
3989        assert(myDataSliced->getTagLookup().size()==3);
3990    
3991        assert(myDataSliced->getLength()==4);
3992    
3993        myDataView = myDataSliced->getDefaultValue();
3994        assert(!myDataView.isEmpty());
3995        assert(myDataView.getOffset()==0);
3996        assert(myDataView.getRank()==0);
3997        assert(myDataView.noValues()==1);
3998        assert(myDataView.getShape().size()==0);
3999        assert(myDataView()==13);
4000    
4001        myDataView = myDataSliced->getDataPointByTag(1);
4002        assert(!myDataView.isEmpty());
4003        assert(myDataView.getOffset()==1);
4004        assert(myDataView.getRank()==0);
4005        assert(myDataView.noValues()==1);
4006        assert(myDataView.getShape().size()==0);
4007        assert(myDataView()==40);
4008    
4009        myDataView = myDataSliced->getDataPointByTag(2);
4010        assert(!myDataView.isEmpty());
4011        assert(myDataView.getOffset()==2);
4012        assert(myDataView.getRank()==0);
4013        assert(myDataView.noValues()==1);
4014        assert(myDataView.getShape().size()==0);
4015        assert(myDataView()==67);
4016    
4017        myDataView = myDataSliced->getDataPointByTag(3);
4018        assert(!myDataView.isEmpty());
4019        assert(myDataView.getOffset()==3);
4020        assert(myDataView.getRank()==0);
4021        assert(myDataView.noValues()==1);
4022        assert(myDataView.getShape().size()==0);
4023        assert(myDataView()==94);
4024    
4025      }
4026    
4027    }
4028    
4029    void DataTaggedTestCase::testSetSlice() {
4030    
4031      cout << endl;
4032    
4033      {
4034    
4035        cout << "\tTest slicing default DataTagged." << endl;
4036    
4037        DataTagged myData1;
4038        DataTagged myData2;
4039    
4040        DataArrayView::RegionType region;
4041    
4042        myData2.getDefaultValue()()=1.0;
4043    
4044        myData1.setSlice(&myData2, region);
4045    
4046        //cout << myData1.toString() << endl;
4047    
4048        assert(myData1.getTagLookup().size()==0);
4049    
4050        assert(myData1.getLength()==1);
4051    
4052        DataArrayView myDataView = myData1.getDefaultValue();
4053        assert(!myDataView.isEmpty());
4054        assert(myDataView.getOffset()==0);
4055        assert(myDataView.getRank()==0);
4056        assert(myDataView.noValues()==1);
4057        assert(myDataView.getShape().size()==0);
4058        assert(myDataView()==1.0);
4059    
4060      }
4061    
4062      {
4063    
4064        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
4065    
4066        DataTagged::TagListType keys;
4067    
4068        DataTagged::ValueListType values;
4069    
4070        DataArrayView::ShapeType viewShape;
4071        viewShape.push_back(3);
4072    
4073        DataArrayView::ValueType viewData1(3);
4074        for (int i=0;i<viewShape[0];i++) {
4075          viewData1[i]=i;
4076        }
4077        DataArrayView myView1(viewData1,viewShape);
4078        DataTagged myData1(keys,values,myView1,FunctionSpace());
4079    
4080        DataArrayView::ValueType viewData2(3);
4081        for (int i=0;i<viewShape[0];i++) {
4082          viewData2[i]=i+3;
4083        }
4084        DataArrayView myView2(viewData2,viewShape);
4085        DataTagged myData2(keys,values,myView2,FunctionSpace());
4086    
4087        // full slice
4088    
4089        std::pair<int, int> region_element;
4090        region_element.first=0;
4091        region_element.second=3;
4092        DataArrayView::RegionType region;
4093        region.push_back(region_element);
4094    
4095        myData1.setSlice(&myData2, region);
4096    
4097        //cout << myData1.toString() << endl;
4098    
4099        assert(myData1.getTagLookup().size()==0);
4100    
4101        assert(myData1.getLength()==3);
4102    
4103        DataArrayView myDataView = myData1.getDefaultValue();
4104        assert(!myDataView.isEmpty());
4105        assert(myDataView.getOffset()==0);
4106        assert(myDataView.getRank()==1);
4107        assert(myDataView.noValues()==3);
4108        assert(myDataView.getShape().size()==1);
4109        assert(myDataView(0)==3.0);
4110        assert(myDataView(1)==4.0);
4111        assert(myDataView(2)==5.0);
4112    
4113        // rank 1 slice
4114    
4115        viewShape.clear();
4116        viewShape.push_back(1);
4117    
4118        DataArrayView::ValueType viewData3(1);
4119        viewData3[0]=6.0;
4120        DataArrayView myView3(viewData3,viewShape);
4121        DataTagged myData3(keys,values,myView3,FunctionSpace());
4122    
4123        region.clear();
4124        region_element.first=1;
4125        region_element.second=2;
4126        region.push_back(region_element);
4127    
4128        myData1.setSlice(&myData3, region);
4129    
4130        //cout << myData1.toString() << endl;
4131    
4132        assert(myData1.getTagLookup().size()==0);
4133    
4134        assert(myData1.getLength()==3);
4135    
4136        myDataView = myData1.getDefaultValue();
4137        assert(!myDataView.isEmpty());
4138        assert(myDataView.getOffset()==0);
4139        assert(myDataView.getRank()==1);
4140        assert(myDataView.noValues()==3);
4141        assert(myDataView.getShape().size()==1);
4142        assert(myDataView(0)==3.0);
4143        assert(myDataView(1)==6.0);
4144        assert(myDataView(2)==5.0);
4145    
4146        // scalar slice
4147    
4148        region.clear();
4149        region_element.first=0;
4150        region_element.second=0;
4151        region.push_back(region_element);
4152    
4153        DataTagged myData4;
4154        myData4.getDefaultValue()()=7.0;
4155    
4156        myData1.setSlice(&myData4, region);
4157    
4158        //cout << myData3.toString() << endl;
4159    
4160        assert(myData1.getTagLookup().size()==0);
4161    
4162        assert(myData1.getLength()==3);
4163    
4164        myDataView = myData1.getDefaultValue();
4165        assert(!myDataView.isEmpty());
4166        assert(myDataView.getOffset()==0);
4167        assert(myDataView.getRank()==1);
4168        assert(myDataView.noValues()==3);
4169        assert(myDataView.getShape().size()==1);
4170        assert(myDataView(0)==7.0);
4171        assert(myDataView(1)==6.0);
4172        assert(myDataView(2)==5.0);
4173    
4174      }
4175    
4176      {
4177    
4178        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
4179    
4180        DataTagged::TagListType keys;
4181    
4182        DataTagged::ValueListType values;
4183    
4184        DataArrayView::ShapeType viewShape;
4185        viewShape.push_back(3);
4186        viewShape.push_back(3);
4187        viewShape.push_back(3);
4188    
4189        DataArrayView::ValueType viewData1(27);
4190        for (int i=0;i<viewData1.size();i++) {
4191          viewData1[i]=i;
4192        }
4193        DataArrayView myView1(viewData1,viewShape);
4194        DataTagged myData1(keys,values,myView1,FunctionSpace());
4195    
4196        DataArrayView::ValueType viewData2(27);
4197        for (int i=0;i<viewData2.size();i++) {
4198          viewData2[i]=i+27;
4199        }
4200        DataArrayView myView2(viewData2,viewShape);
4201        DataTagged myData2(keys,values,myView2,FunctionSpace());
4202    
4203        // full slice
4204    
4205        std::pair<int, int> region_element;
4206        region_element.first=0;
4207        region_element.second=3;
4208        DataArrayView::RegionType region;
4209        region.push_back(region_element);
4210        region.push_back(region_element);
4211        region.push_back(region_element);
4212    
4213        myData1.setSlice(&myData2, region);
4214    
4215        //cout << myData1.toString() << endl;
4216    
4217        assert(myData1.getTagLookup().size()==0);
4218    
4219        assert(myData1.getLength()==27);
4220    
4221        DataArrayView myDataView = myData1.getDefaultValue();
4222        assert(!myDataView.isEmpty());
4223        assert(myDataView.getOffset()==0);
4224        assert(myDataView.getRank()==3);
4225        assert(myDataView.noValues()==27);
4226        assert(myDataView.getShape().size()==3);
4227    
4228        // rank 1 slice
4229    
4230        viewShape.clear();
4231        viewShape.push_back(3);
4232    
4233        DataArrayView::ValueType viewData3(3);
4234        for (int i=0;i<viewData3.size();i++) {
4235          viewData3[i]=i+60;
4236        }
4237        DataArrayView myView3(viewData3,viewShape);
4238        DataTagged myData3(keys,values,myView3,FunctionSpace());
4239    
4240        region.clear();
4241        region.push_back(region_element);
4242        region_element.first=0;
4243        region_element.second=0;
4244        region.push_back(region_element);
4245        region.push_back(region_element);
4246    
4247        myData1.setSlice(&myData3, region);
4248    
4249        //cout << myData1.toString() << endl;
4250    
4251        assert(myData1.getTagLookup().size()==0);
4252    
4253        assert(myData1.getLength()==27);
4254    
4255        myDataView = myData1.getDefaultValue();
4256        assert(!myDataView.isEmpty());
4257        assert(myDataView.getOffset()==0);
4258        assert(myDataView.getRank()==3);
4259        assert(myDataView.noValues()==27);
4260        assert(myDataView.getShape().size()==3);
4261        assert(myDataView(0,0,0)==60.0);
4262        assert(myDataView(1,0,0)==61.0);
4263        assert(myDataView(2,0,0)==62.0);
4264    
4265        // scalar slice
4266    
4267        region.clear();
4268        region_element.first=0;
4269        region_element.second=0;
4270        region.push_back(region_element);
4271        region.push_back(region_element);
4272        region.push_back(region_element);
4273    
4274        DataTagged myData4;
4275        myData4.getDefaultValue()()=70.0;
4276    
4277        myData1.setSlice(&myData4, region);
4278    
4279        //cout << myData1.toString() << endl;
4280    
4281        assert(myData1.getTagLookup().size()==0);
4282    
4283        assert(myData1.getLength()==27);
4284    
4285        myDataView = myData1.getDefaultValue();
4286        assert(!myDataView.isEmpty());
4287        assert(myDataView.getOffset()==0);
4288        assert(myDataView.getRank()==3);
4289        assert(myDataView.noValues()==27);
4290        assert(myDataView.getShape().size()==3);
4291        assert(myDataView(0,0,0)==70.0);
4292    
4293      }
4294    
4295      {
4296    
4297        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
4298    
4299        DataTagged::TagListType keys;
4300        keys.push_back(1);
4301    
4302        DataTagged::ValueListType values;
4303    
4304        DataArrayView::ShapeType viewShape;
4305    
4306        // default value for Data1
4307        DataArrayView::ValueType viewData1(1);
4308        viewData1[0]=0.0;
4309        DataArrayView myView1(viewData1,viewShape);
4310    
4311        // value for tag "1" for Data1
4312        DataArrayView::ValueType viewData2(1);
4313        viewData2[0]=0.0;
4314        DataArrayView myView2(viewData2,viewShape);
4315        values.push_back(myView2);
4316    
4317        DataTagged myData1(keys,values,myView1,FunctionSpace());
4318    
4319        values.clear();
4320    
4321        // default value for Data2
4322        DataArrayView::ValueType viewData3(1);
4323        viewData3[0]=1.0;
4324        DataArrayView myView3(viewData3,viewShape);
4325    
4326        // value for tag "1" for Data2
4327        DataArrayView::ValueType viewData4(1);
4328        viewData4[0]=2.0;
4329        DataArrayView myView4(viewData4,viewShape);
4330        values.push_back(myView4);
4331    
4332        DataTagged myData2(keys,values,myView3,FunctionSpace());
4333    
4334        // full slice
4335    
4336        DataArrayView::RegionType region;
4337    
4338        myData1.setSlice(&myData2, region);
4339    
4340        //cout << myData1.toString() << endl;
4341    
4342        assert(myData1.getTagLookup().size()==1);
4343    
4344        assert(myData1.getLength()==2);
4345    
4346        DataArrayView myDataView = myData1.getDefaultValue();
4347        assert(!myDataView.isEmpty());
4348        assert(myDataView.getOffset()==0);
4349        assert(myDataView.getRank()==0);
4350        assert(myDataView.noValues()==1);
4351        assert(myDataView.getShape().size()==0);
4352        assert(myDataView()==1.0);
4353    
4354        myDataView = myData1.getDataPointByTag(1);
4355        assert(!myDataView.isEmpty());
4356        assert(myDataView.getOffset()==1);
4357        assert(myDataView.getRank()==0);
4358        assert(myDataView.noValues()==1);
4359        assert(myDataView.getShape().size()==0);
4360        assert(myDataView()==2.0);
4361    
4362      }
4363    
4364      {
4365    
4366        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
4367    
4368        DataTagged::TagListType keys;
4369        keys.push_back(1);
4370    
4371        DataTagged::ValueListType values;
4372    
4373        DataArrayView::ShapeType viewShape;
4374        viewShape.push_back(3);
4375    
4376        // default value for Data1
4377        DataArrayView::ValueType viewData1(3);
4378        for (int i=0;i<viewData1.size();i++) {
4379          viewData1[i]=0.0;
4380        }
4381        DataArrayView myView1(viewData1,viewShape);
4382    
4383        // value for tag "1" for Data1
4384        DataArrayView::ValueType viewData2(3);
4385        for (int i=0;i<viewData2.size();i++) {
4386          viewData2[i]=0.0;
4387        }
4388        DataArrayView myView2(viewData2,viewShape);
4389        values.push_back(myView2);
4390    
4391        DataTagged myData1(keys,values,myView1,FunctionSpace());
4392    
4393        values.clear();
4394    
4395        // default value for Data2
4396        DataArrayView::ValueType viewData3(3);
4397        for (int i=0;i<viewData3.size();i++) {
4398          viewData3[i]=1.0;
4399        }
4400        DataArrayView myView3(viewData3,viewShape);
4401    
4402        // value for tag "1" for Data2
4403        DataArrayView::ValueType viewData4(3);
4404        for (int i=0;i<viewData4.size();i++) {
4405          viewData4[i]=2.0;
4406        }
4407        DataArrayView myView4(viewData4,viewShape);
4408        values.push_back(myView4);
4409    
4410        DataTagged myData2(keys,values,myView3,FunctionSpace());
4411    
4412        // full slice
4413    
4414        std::pair<int, int> region_element;
4415        region_element.first=0;
4416        region_element.second=3;
4417        DataArrayView::RegionType region;
4418        region.push_back(region_element);
4419    
4420        myData1.setSlice(&myData2, region);
4421    
4422        //cout << myData1.toString() << endl;
4423    
4424        assert(myData1.getTagLookup().size()==1);
4425    
4426        assert(myData1.getLength()==6);
4427    
4428        DataArrayView myDataView = myData1.getDefaultValue();
4429        assert(!myDataView.isEmpty());
4430        assert(myDataView.getOffset()==0);
4431        assert(myDataView.getRank()==1);
4432        assert(myDataView.noValues()==3);
4433        assert(myDataView.getShape().size()==1);
4434        assert(myDataView(0)==1.0);
4435        assert(myDataView(1)==1.0);
4436        assert(myDataView(2)==1.0);
4437    
4438        myDataView = myData1.getDataPointByTag(1);
4439        assert(!myDataView.isEmpty());
4440        assert(myDataView.getOffset()==3);
4441        assert(myDataView.getRank()==1);
4442        assert(myDataView.noValues()==3);
4443        assert(myDataView.getShape().size()==1);
4444        assert(myDataView(0)==2.0);
4445        assert(myDataView(1)==2.0);
4446        assert(myDataView(2)==2.0);
4447    
4448        // rank 1 slice
4449    
4450        viewShape.clear();
4451        viewShape.push_back(1);
4452    
4453        DataArrayView::ValueType viewData5(1);
4454        viewData5[0]=3.0;
4455        DataArrayView myView5(viewData5,viewShape);
4456    
4457        values.clear();
4458    
4459        DataArrayView::ValueType viewData6(1);
4460        viewData6[0]=4.0;
4461        DataArrayView myView6(viewData6,viewShape);
4462        values.push_back(myView6);
4463    
4464        DataTagged myData3(keys,values,myView5,FunctionSpace());
4465    
4466        region.clear();
4467        region_element.first=1;
4468        region_element.second=2;
4469        region.push_back(region_element);
4470    
4471        myData1.setSlice(&myData3, region);
4472    
4473        //cout << myData1.toString() << endl;
4474    
4475        assert(myData1.getTagLookup().size()==1);
4476    
4477        assert(myData1.getLength()==6);
4478    
4479        myDataView = myData1.getDefaultValue();
4480        assert(!myDataView.isEmpty());
4481        assert(myDataView.getOffset()==0);
4482        assert(myDataView.getRank()==1);
4483        assert(myDataView.noValues()==3);
4484        assert(myDataView.getShape().size()==1);
4485        assert(myDataView(0)==1.0);
4486        assert(myDataView(1)==3.0);
4487        assert(myDataView(2)==1.0);
4488    
4489        myDataView = myData1.getDataPointByTag(1);
4490        assert(!myDataView.isEmpty());
4491        assert(myDataView.getOffset()==3);
4492        assert(myDataView.getRank()==1);
4493        assert(myDataView.noValues()==3);
4494        assert(myDataView.getShape().size()==1);
4495        assert(myDataView(0)==2.0);
4496        assert(myDataView(1)==4.0);
4497        assert(myDataView(2)==2.0);
4498    
4499        // scalar slice
4500    
4501        viewShape.clear();
4502    
4503        DataArrayView::ValueType viewData7(1);
4504        viewData7[0]=5.0;
4505        DataArrayView myView7(viewData7,viewShape);
4506    
4507        values.clear();
4508    
4509        DataArrayView::ValueType viewData8(1);
4510        viewData8[0]=6.0;
4511        DataArrayView myView8(viewData8,viewShape);
4512        values.push_back(myView8);
4513    
4514        DataTagged myData4(keys,values,myView7,FunctionSpace());
4515    
4516        region.clear();
4517        region_element.first=0;
4518        region_element.second=0;
4519        region.push_back(region_element);
4520    
4521        myData1.setSlice(&myData4, region);
4522    
4523        //cout << myData1.toString() << endl;
4524    
4525        myDataView = myData1.getDefaultValue();
4526        assert(!myDataView.isEmpty());
4527        assert(myDataView.getOffset()==0);
4528        assert(myDataView.getRank()==1);
4529        assert(myDataView.noValues()==3);
4530        assert(myDataView.getShape().size()==1);
4531        assert(myDataView(0)==5.0);
4532        assert(myDataView(1)==3.0);
4533        assert(myDataView(2)==1.0);
4534    
4535        myDataView = myData1.getDataPointByTag(1);
4536        assert(!myDataView.isEmpty());
4537        assert(myDataView.getOffset()==3);
4538        assert(myDataView.getRank()==1);
4539        assert(myDataView.noValues()==3);
4540        assert(myDataView.getShape().size()==1);
4541        assert(myDataView(0)==6.0);
4542        assert(myDataView(1)==4.0);
4543        assert(myDataView(2)==2.0);
4544    
4545      }
4546    
4547      {
4548    
4549        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
4550    
4551        DataTagged::TagListType keys;
4552        keys.push_back(1);
4553    
4554        DataTagged::ValueListType values;
4555    
4556        DataArrayView::ShapeType viewShape;
4557        viewShape.push_back(3);
4558        viewShape.push_back(3);
4559        viewShape.push_back(3);
4560    
4561        // default value for Data1
4562        DataArrayView::ValueType viewData1(27);
4563        for (int i=0;i<viewData1.size();i++) {
4564          viewData1[i]=0.0;
4565        }
4566        DataArrayView myView1(viewData1,viewShape);
4567    
4568        // value for tag "1" for Data1
4569        DataArrayView::ValueType viewData2(27);
4570        for (int i=0;i<viewData2.size();i++) {
4571          viewData2[i]=0.0;
4572        }
4573        DataArrayView myView2(viewData2,viewShape);
4574        values.push_back(myView2);
4575    
4576        DataTagged myData1(keys,values,myView1,FunctionSpace());
4577    
4578        values.clear();
4579    
4580        // default value for Data2
4581        DataArrayView::ValueType viewData3(27);
4582        for (int i=0;i<viewData3.size();i++) {
4583          viewData3[i]=1.0;
4584        }
4585        DataArrayView myView3(viewData3,viewShape);
4586    
4587        // value for tag "1" for Data2
4588        DataArrayView::ValueType viewData4(27);
4589        for (int i=0;i<viewData4.size();i++) {
4590          viewData4[i]=2.0;
4591        }
4592        DataArrayView myView4(viewData4,viewShape);
4593        values.push_back(myView4);
4594    
4595        DataTagged myData2(keys,values,myView3,FunctionSpace());
4596    
4597        // full slice
4598    
4599        std::pair<int, int> region_element;
4600        region_element.first=0;
4601        region_element.second=3;
4602        DataArrayView::RegionType region;
4603        region.push_back(region_element);
4604        region.push_back(region_element);
4605        region.push_back(region_element);
4606    
4607        myData1.setSlice(&myData2, region);
4608    
4609        //cout << myData1.toString() << endl;
4610    
4611        assert(myData1.getTagLookup().size()==1);
4612    
4613        assert(myData1.getLength()==54);
4614    
4615        DataArrayView myDataView = myData1.getDefaultValue();
4616        assert(!myDataView.isEmpty());
4617        assert(myDataView.getOffset()==0);
4618        assert(myDataView.getRank()==3);
4619        assert(myDataView.noValues()==27);
4620        assert(myDataView.getShape().size()==3);
4621        assert(myDataView(0,0,0)==1.0);
4622        assert(myDataView(1,1,1)==1.0);
4623        assert(myDataView(2,2,2)==1.0);
4624    
4625        myDataView = myData1.getDataPointByTag(1);
4626        assert(!myDataView.isEmpty());
4627        assert(myDataView.getOffset()==27);
4628        assert(myDataView.getRank()==3);
4629        assert(myDataView.noValues()==27);
4630        assert(myDataView.getShape().size()==3);
4631        assert(myDataView(0,0,0)==2.0);
4632        assert(myDataView(1,1,1)==2.0);
4633        assert(myDataView(2,2,2)==2.0);