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

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

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

revision 499 by jgs, Tue Feb 7 04:40:44 2006 UTC revision 534 by jgs, Fri Feb 17 01:03:53 2006 UTC
# Line 16  Line 16 
16  #include "EsysException.h"  #include "EsysException.h"
17    
18  #include "DataTagged.h"  #include "DataTagged.h"
19    #include "DataConstant.h"
20    
21  #include "DataTaggedTestCase.h"  #include "DataTaggedTestCase.h"
22    
# Line 50  void DataTaggedTestCase::testReshape() { Line 51  void DataTaggedTestCase::testReshape() {
51    cout << endl;    cout << endl;
52    
53    {    {
54      cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;  
55      DataTagged value;      cout << "\tTest rank 1 reshape of default DataTagged." << endl;
56      value.getPointDataView()()=1.0;  
57        DataTagged myData;
58        myData.getPointDataView()()=1.0;
59    
60      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
61      shape.push_back(2);      shape.push_back(2);
62      value.reshapeDataPoint(shape);  
63      for (int i=0;i<shape[0];++i) {      myData.reshapeDataPoint(shape);
64        assert(value.getDefaultValue()(i)==1);  
65        for (int i=0;i<shape[0];i++) {
66          assert(myData.getDefaultValue()(i)==1);
67      }      }
68    
69        //cout << myData.toString() << endl;
70    
71        assert(myData.getNumSamples()==1);
72        assert(myData.getNumDPPSample()==1);
73    
74        assert(myData.validSamplePointNo(0));
75        assert(myData.validSampleNo(0));
76        assert(!myData.validSamplePointNo(1));
77        assert(!myData.validSampleNo(1));
78    
79        // data-point 0 has tag number 1 by default
80        assert(myData.getTagNumber(0)==1);
81    
82        assert(!myData.isCurrentTag(1));
83    
84        assert(myData.getTagLookup().size()==0);
85    
86        assert(myData.getLength()==2);
87    
88        assert(myData.getPointOffset(0,0)==0);
89    
90        DataArrayView myDataView = myData.getDataPoint(0,0);
91        assert(!myDataView.isEmpty());
92        assert(myDataView.getOffset()==0);
93        assert(myDataView.getRank()==1);
94        assert(myDataView.noValues()==2);
95        assert(myDataView.getShape().size()==1);
96        assert(myDataView(0)==1.0);
97        assert(myDataView(1)==1.0);
98    
99        // Test non-existent tag returns the default value.
100        myDataView = myData.getDataPointByTag(1);
101        assert(!myDataView.isEmpty());
102        assert(myDataView.getOffset()==0);
103        assert(myDataView.getRank()==1);
104        assert(myDataView.noValues()==2);
105        assert(myDataView.getShape().size()==1);
106        assert(myDataView(0)==1.0);
107        assert(myDataView(1)==1.0);
108    
109        myDataView = myData.getDefaultValue();
110        assert(!myDataView.isEmpty());
111        assert(myDataView.getOffset()==0);
112        assert(myDataView.getRank()==1);
113        assert(myDataView.noValues()==2);
114        assert(myDataView.getShape().size()==1);
115        assert(myDataView(0)==1.0);
116        assert(myDataView(1)==1.0);
117    
118        // use a non-existent tag so we get a pointer to
119        // the first element of the data array
120        double* sampleData=myData.getSampleDataByTag(9);
121        for (int i=0; i<myData.getLength(); i++) {
122          assert(sampleData[i]==1.0);
123        }
124    
125    }    }
126    
127    {    {
128      cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;  
129      DataTagged value;      cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;
130      value.getPointDataView()()=0.0;  
131      DataArray vOne(1.0);      DataTagged::TagListType keys;
132      DataArray vTwo(2.0);      keys.push_back(1);
133      value.addTaggedValue(1,vOne.getView());  
134      value.addTaggedValue(2,vTwo.getView());      DataTagged::ValueListType values;
135    
136        DataArrayView::ShapeType viewShape;
137    
138        // default value
139        DataArrayView::ValueType viewData(1);
140        viewData[0]=1.0;
141        DataArrayView myView(viewData,viewShape);
142    
143        // value for tag "1"
144        DataArray eOne(myView);
145        eOne.getView()()=2.0;
146        values.push_back(eOne.getView());
147    
148        DataTagged myData(keys,values,myView,FunctionSpace());
149    
150      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
151      shape.push_back(2);      shape.push_back(2);
152      shape.push_back(5);      shape.push_back(5);
153      value.reshapeDataPoint(shape);  
154      for (int j=0;j<shape[1];++j) {      myData.reshapeDataPoint(shape);
155        for (int i=0;i<shape[0];++i) {  
156      assert(value.getDefaultValue()(i,j)==0.0);      //cout << myData.toString() << endl;
157      assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());  
158      assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());      assert(myData.getNumSamples()==1);
159        assert(myData.getNumDPPSample()==1);
160    
161        assert(myData.validSamplePointNo(0));
162        assert(myData.validSampleNo(0));
163        assert(!myData.validSamplePointNo(1));
164        assert(!myData.validSampleNo(1));
165    
166        // data-point 0 has tag number 1 by default
167        assert(myData.getTagNumber(0)==1);
168    
169        assert(myData.isCurrentTag(1));
170    
171        assert(myData.getTagLookup().size()==1);
172    
173        assert(myData.getLength()==20);
174    
175        assert(myData.getPointOffset(0,0)==10);
176    
177        DataArrayView myDataView = myData.getDataPoint(0,0);
178        assert(!myDataView.isEmpty());
179        assert(myDataView.getOffset()==10);
180        assert(myDataView.getRank()==2);
181        assert(myDataView.noValues()==10);
182        assert(myDataView.getShape().size()==2);
183        for (int j=0;j<shape[1];j++) {
184          for (int i=0;i<shape[0];i++) {
185            assert(myDataView(i,j)==2.0);
186          }
187        }
188    
189        myDataView = myData.getDataPointByTag(1);
190        assert(!myDataView.isEmpty());
191        assert(myDataView.getOffset()==10);
192        assert(myDataView.getRank()==2);
193        assert(myDataView.noValues()==10);
194        assert(myDataView.getShape().size()==2);
195        for (int j=0;j<shape[1];j++) {
196          for (int i=0;i<shape[0];i++) {
197            assert(myDataView(i,j)==2.0);
198          }
199        }
200    
201        myDataView = myData.getDefaultValue();
202        assert(!myDataView.isEmpty());
203        assert(myDataView.getOffset()==0);
204        assert(myDataView.getRank()==2);
205        assert(myDataView.noValues()==10);
206        assert(myDataView.getShape().size()==2);
207        for (int j=0;j<shape[1];j++) {
208          for (int i=0;i<shape[0];i++) {
209            assert(myDataView(i,j)==1.0);
210          }
211        }
212    
213        // use a non-existent tag so we get a pointer to
214        // the first element of the data array
215        double* sampleData=myData.getSampleDataByTag(9);
216        for (int i=0; i<myData.getLength(); i++) {
217          if (i<10) {
218            assert(sampleData[i]==1.0);
219          } else {
220            assert(sampleData[i]==2.0);
221          }
222        }
223    
224      }
225    
226      {
227    
228        cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;
229    
230        DataTagged::TagListType keys;
231        keys.push_back(1);
232        keys.push_back(2);
233        keys.push_back(3);
234    
235        DataTagged::ValueListType values;
236    
237        DataArrayView::ShapeType viewShape;
238    
239        // default value
240        DataArrayView::ValueType viewData(1);
241        viewData[0]=0.0;
242        DataArrayView myView(viewData,viewShape);
243    
244        // value for tag "1"
245        DataArray eOne(myView);
246        eOne.getView()()=1.0;
247        values.push_back(eOne.getView());
248    
249        // value for tag "2"
250        DataArray eTwo(myView);
251        eTwo.getView()()=2.0;
252        values.push_back(eTwo.getView());
253    
254        // value for tag "3"
255        DataArray eThree(myView);
256        eThree.getView()()=3.0;
257        values.push_back(eThree.getView());
258    
259        DataTagged myData(keys,values,myView,FunctionSpace());
260    
261        DataArrayView::ShapeType shape;
262        shape.push_back(2);
263        shape.push_back(2);
264        shape.push_back(2);
265    
266        myData.reshapeDataPoint(shape);
267    
268        //cout << myData.toString() << endl;
269    
270        assert(myData.getNumSamples()==1);
271        assert(myData.getNumDPPSample()==1);
272    
273        assert(myData.validSamplePointNo(0));
274        assert(myData.validSampleNo(0));
275        assert(!myData.validSamplePointNo(1));
276        assert(!myData.validSampleNo(1));
277    
278        // data-point 0 has tag number 1 by default
279        assert(myData.getTagNumber(0)==1);
280    
281        assert(myData.isCurrentTag(1));
282        assert(myData.isCurrentTag(2));
283        assert(myData.isCurrentTag(3));
284    
285        assert(myData.getTagLookup().size()==3);
286    
287        assert(myData.getLength()==32);
288    
289        assert(myData.getPointOffset(0,0)==8);
290    
291        DataArrayView myDataView = myData.getDataPoint(0,0);
292        assert(!myDataView.isEmpty());
293        assert(myDataView.getOffset()==8);
294        assert(myDataView.getRank()==3);
295        assert(myDataView.noValues()==8);
296        assert(myDataView.getShape().size()==3);
297        for (int k=0;k<shape[2];k++) {
298          for (int j=0;j<shape[1];j++) {
299            for (int i=0;i<shape[0];i++) {
300              assert(myDataView(i,j,k)==1.0);
301            }
302          }
303        }
304    
305        myDataView = myData.getDataPointByTag(1);
306        assert(!myDataView.isEmpty());
307        assert(myDataView.getOffset()==8);
308        assert(myDataView.getRank()==3);
309        assert(myDataView.noValues()==8);
310        assert(myDataView.getShape().size()==3);
311        for (int k=0;k<shape[2];k++) {
312          for (int j=0;j<shape[1];j++) {
313            for (int i=0;i<shape[0];i++) {
314              assert(myDataView(i,j,k)==1.0);
315            }
316          }
317        }
318    
319        myDataView = myData.getDataPointByTag(2);
320        assert(!myDataView.isEmpty());
321        assert(myDataView.getOffset()==16);
322        assert(myDataView.getRank()==3);
323        assert(myDataView.noValues()==8);
324        assert(myDataView.getShape().size()==3);
325        for (int k=0;k<shape[2];k++) {
326          for (int j=0;j<shape[1];j++) {
327            for (int i=0;i<shape[0];i++) {
328              assert(myDataView(i,j,k)==2.0);
329            }
330          }
331        }
332    
333        myDataView = myData.getDataPointByTag(3);
334        assert(!myDataView.isEmpty());
335        assert(myDataView.getOffset()==24);
336        assert(myDataView.getRank()==3);
337        assert(myDataView.noValues()==8);
338        assert(myDataView.getShape().size()==3);
339        for (int k=0;k<shape[2];k++) {
340          for (int j=0;j<shape[1];j++) {
341            for (int i=0;i<shape[0];i++) {
342              assert(myDataView(i,j,k)==3.0);
343            }
344          }
345        }
346    
347        myDataView = myData.getDefaultValue();
348        assert(!myDataView.isEmpty());
349        assert(myDataView.getOffset()==0);
350        assert(myDataView.getRank()==3);
351        assert(myDataView.noValues()==8);
352        assert(myDataView.getShape().size()==3);
353        for (int k=0;k<shape[2];k++) {
354          for (int j=0;j<shape[1];j++) {
355            for (int i=0;i<shape[0];i++) {
356              assert(myDataView(i,j,k)==0.0);
357            }
358          }
359        }
360    
361        // use a non-existent tag so we get a pointer to
362        // the first element of the data array
363        double* sampleData=myData.getSampleDataByTag(9);
364        for (int i=0; i<myData.getLength(); i++) {
365          if (i<8) {
366            assert(sampleData[i]==0.0);
367          } else if ((i>=8) && (i<16)) {
368            assert(sampleData[i]==1.0);
369          } else if ((i>=16) && (i<24)) {
370            assert(sampleData[i]==2.0);
371          } else {
372            assert(sampleData[i]==3.0);
373        }        }
374      }      }
375    
376    }    }
377    
378  }  }
379    
380  void DataTaggedTestCase::testOperations() {  void DataTaggedTestCase::testOperations() {
# Line 87  void DataTaggedTestCase::testOperations( Line 382  void DataTaggedTestCase::testOperations(
382    cout << endl;    cout << endl;
383    
384    {    {
385      DataTagged left;      cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
386    
387        DataTagged myData;
388        DataTagged right;
389    
390        binaryOp(myData,right,plus<double>());
391    
392        //cout << myData.toString() << endl;
393    
394        assert(myData.getNumSamples()==1);
395        assert(myData.getNumDPPSample()==1);
396    
397        assert(myData.validSamplePointNo(0));
398        assert(myData.validSampleNo(0));
399        assert(!myData.validSamplePointNo(1));
400        assert(!myData.validSampleNo(1));
401    
402        // data-point 0 has tag number 1 by default
403        assert(myData.getTagNumber(0)==1);
404    
405        assert(!myData.isCurrentTag(1));
406    
407        assert(myData.getTagLookup().size()==0);
408    
409        assert(myData.getLength()==1);
410    
411        assert(myData.getPointOffset(0,0)==0);
412    
413        DataArrayView myDataView = myData.getDataPoint(0,0);
414        assert(!myDataView.isEmpty());
415        assert(myDataView.getOffset()==0);
416        assert(myDataView.getRank()==0);
417        assert(myDataView.noValues()==1);
418        assert(myDataView.getShape().size()==0);
419        assert(myDataView()==0.0);
420    
421        // Test non-existent tag returns the default value.
422        myDataView = myData.getDataPointByTag(1);
423        assert(!myDataView.isEmpty());
424        assert(myDataView.getOffset()==0);
425        assert(myDataView.getRank()==0);
426        assert(myDataView.noValues()==1);
427        assert(myDataView.getShape().size()==0);
428        assert(myDataView()==0.0);
429    
430        myDataView = myData.getDefaultValue();
431        assert(!myDataView.isEmpty());
432        assert(myDataView.getOffset()==0);
433        assert(myDataView.getRank()==0);
434        assert(myDataView.noValues()==1);
435        assert(myDataView.getShape().size()==0);
436        assert(myDataView()==0.0);
437    
438        // use a non-existent tag so we get a pointer to
439        // the first element of the data array
440        double* sampleData=myData.getSampleDataByTag(9);
441        for (int i=0; i<myData.getLength(); i++) {
442          assert(sampleData[i]==i);
443        }
444    
445      }
446    
447      {
448        cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
449    
450        DataArrayView::ShapeType viewShape;
451        viewShape.push_back(3);
452    
453        DataTagged::TagListType keys;
454    
455        DataTagged::ValueListType values;
456    
457        DataArrayView::ValueType viewData(3);
458        for (int i=0;i<viewShape[0];i++) {
459          viewData[i]=i;
460        }
461        DataArrayView myView(viewData,viewShape);
462    
463        DataTagged myData(keys,values,myView,FunctionSpace());
464        DataTagged right(keys,values,myView,FunctionSpace());
465    
466        binaryOp(myData,right,plus<double>());
467    
468        //cout << myData.toString() << endl;
469    
470        assert(myData.getNumSamples()==1);
471        assert(myData.getNumDPPSample()==1);
472    
473        assert(myData.validSamplePointNo(0));
474        assert(myData.validSampleNo(0));
475        assert(!myData.validSamplePointNo(1));
476        assert(!myData.validSampleNo(1));
477    
478        // data-point 0 has tag number 1 by default
479        assert(myData.getTagNumber(0)==1);
480    
481        assert(!myData.isCurrentTag(1));
482    
483        assert(myData.getTagLookup().size()==0);
484    
485        assert(myData.getLength()==3);
486    
487        assert(myData.getPointOffset(0,0)==0);
488    
489        DataArrayView myDataView = myData.getDefaultValue();
490        assert(!myDataView.isEmpty());
491        assert(myDataView.getOffset()==0);
492        assert(myDataView.getRank()==1);
493        assert(myDataView.noValues()==3);
494        assert(myDataView.getShape().size()==1);
495        assert(myDataView(0)==0);
496        assert(myDataView(1)==2);
497        assert(myDataView(2)==4);
498    
499        // use a non-existent tag so we get a pointer to
500        // the first element of the data array
501        double* sampleData=myData.getSampleDataByTag(9);
502        for (int i=0; i<myData.getLength(); i++) {
503          assert(sampleData[i]==i*2);
504        }
505    
506      }
507    
508      {
509        cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
510    
511        DataTagged myData;
512      DataTagged right;      DataTagged right;
513    
514      cout << "\tTest default DataTagged contains only a default value." << endl;      DataArray vOne(1.0);
515      binaryOp(left,right,plus<double>());      myData.addTaggedValue(1,vOne.getView());
516      assert(left.getPointDataView()()==0);      right.addTaggedValue(1,vOne.getView());
517      assert(right.getPointDataView()()==0);  
518        binaryOp(myData,right,plus<double>());
519    
520        assert(myData.getNumSamples()==1);
521        assert(myData.getNumDPPSample()==1);
522    
523        assert(myData.validSamplePointNo(0));
524        assert(myData.validSampleNo(0));
525        assert(!myData.validSamplePointNo(1));
526        assert(!myData.validSampleNo(1));
527    
528        // data-point 0 has tag number 1 by default
529        assert(myData.getTagNumber(0)==1);
530    
531        assert(myData.isCurrentTag(1));
532    
533        assert(myData.getTagLookup().size()==1);
534    
535        assert(myData.getLength()==2);
536    
537        assert(myData.getPointOffset(0,0)==1);
538    
539        // check result value for tag "1"
540        DataArrayView myDataView = myData.getDataPointByTag(1);
541        assert(!myDataView.isEmpty());
542        assert(myDataView.getOffset()==1);
543        assert(myDataView.getRank()==0);
544        assert(myDataView.noValues()==1);
545        assert(myDataView.getShape().size()==0);
546        assert(myDataView()==2.0);
547    
548        // check result for default value
549        myDataView = myData.getDefaultValue();
550        assert(!myDataView.isEmpty());
551        assert(myDataView.getOffset()==0);
552        assert(myDataView.getRank()==0);
553        assert(myDataView.noValues()==1);
554        assert(myDataView.getShape().size()==0);
555        assert(myDataView()==0.0);
556    
557        // use a non-existent tag so we get a pointer to
558        // the first element of the data array
559        double* sampleData=myData.getSampleDataByTag(9);
560        for (int i=0; i<myData.getLength(); i++) {
561          assert(sampleData[i]==i*2);
562        }
563    
564      }
565    
566      {
567        cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
568    
569        DataTagged myData;
570        DataTagged right;
571    
     cout << "\tTest binaryOp(plus)." << endl;  
572      DataArray vOne(1.0);      DataArray vOne(1.0);
573      DataArray vTwo(2.0);      DataArray vTwo(2.0);
574      right.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
575      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
     binaryOp(left,right,plus<double>());  
     assert(left.getPointDataView()()==0);  
     assert(left.getDataPointByTag(1)==vOne.getView());  
     assert(left.getDataPointByTag(2)==vTwo.getView());  
576    
577      cout << "\tTest binaryOp(multiplies)." << endl;      binaryOp(myData,right,plus<double>());
578      DataArray vZero(0.0);  
579      right.setTaggedValue(1,vZero.getView());      assert(myData.getNumSamples()==1);
580      right.setTaggedValue(2,vZero.getView());      assert(myData.getNumDPPSample()==1);
581      binaryOp(left,right,multiplies<double>());  
582      assert(left.getPointDataView()()==0);      assert(myData.validSamplePointNo(0));
583      assert(left.getDataPointByTag(1)==vZero.getView());      assert(myData.validSampleNo(0));
584      assert(left.getDataPointByTag(2)==vZero.getView());      assert(!myData.validSamplePointNo(1));
585        assert(!myData.validSampleNo(1));
586    
587        // data-point 0 has tag number 1 by default
588        assert(myData.getTagNumber(0)==1);
589    
590        assert(myData.isCurrentTag(1));
591        assert(myData.isCurrentTag(2));
592    
593        assert(myData.getTagLookup().size()==2);
594    
595        assert(myData.getLength()==3);
596    
597        assert(myData.getPointOffset(0,0)==1);
598    
599        // check result value for tag "1"
600        DataArrayView myDataView = myData.getDataPointByTag(1);
601        assert(!myDataView.isEmpty());
602        assert(myDataView.getOffset()==1);
603        assert(myDataView.getRank()==0);
604        assert(myDataView.noValues()==1);
605        assert(myDataView.getShape().size()==0);
606        assert(myDataView()==1.0);
607    
608        // check result value for tag "2"
609        myDataView = myData.getDataPointByTag(2);
610        assert(!myDataView.isEmpty());
611        assert(myDataView.getOffset()==2);
612        assert(myDataView.getRank()==0);
613        assert(myDataView.noValues()==1);
614        assert(myDataView.getShape().size()==0);
615        assert(myDataView()==2.0);
616    
617        // check result for default value
618        myDataView = myData.getDefaultValue();
619        assert(!myDataView.isEmpty());
620        assert(myDataView.getOffset()==0);
621        assert(myDataView.getRank()==0);
622        assert(myDataView.noValues()==1);
623        assert(myDataView.getShape().size()==0);
624        assert(myDataView()==0.0);
625    
626        // use a non-existent tag so we get a pointer to
627        // the first element of the data array
628        double* sampleData=myData.getSampleDataByTag(9);
629        for (int i=0; i<myData.getLength(); i++) {
630          assert(sampleData[i]==i);
631        }
632    
633    }    }
634    
635    {    {
636        cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
637    
638        DataTagged myData;
639        DataTagged right;
640    
641        DataArray vOne(1.0);
642        myData.addTaggedValue(1,vOne.getView());
643        myData.addTaggedValue(2,vOne.getView());
644        right.addTaggedValue(2,vOne.getView());
645        right.addTaggedValue(3,vOne.getView());
646    
647        binaryOp(myData,right,plus<double>());
648    
649        assert(myData.getNumSamples()==1);
650        assert(myData.getNumDPPSample()==1);
651    
652        assert(myData.validSamplePointNo(0));
653        assert(myData.validSampleNo(0));
654        assert(!myData.validSamplePointNo(1));
655        assert(!myData.validSampleNo(1));
656    
657        // data-point 0 has tag number 1 by default
658        assert(myData.getTagNumber(0)==1);
659    
660        assert(myData.isCurrentTag(1));
661        assert(myData.isCurrentTag(2));
662        assert(myData.isCurrentTag(3));
663    
664        assert(myData.getTagLookup().size()==3);
665    
666        assert(myData.getLength()==4);
667    
668        assert(myData.getPointOffset(0,0)==1);
669    
670        // check result value for tag "1"
671        DataArrayView myDataView = myData.getDataPointByTag(1);
672        assert(!myDataView.isEmpty());
673        assert(myDataView.getOffset()==1);
674        assert(myDataView.getRank()==0);
675        assert(myDataView.noValues()==1);
676        assert(myDataView.getShape().size()==0);
677        assert(myDataView()==1.0);
678    
679        // check result value for tag "2"
680        myDataView = myData.getDataPointByTag(2);
681        assert(!myDataView.isEmpty());
682        assert(myDataView.getOffset()==2);
683        assert(myDataView.getRank()==0);
684        assert(myDataView.noValues()==1);
685        assert(myDataView.getShape().size()==0);
686        assert(myDataView()==2.0);
687    
688        // check result value for tag "3"
689        myDataView = myData.getDataPointByTag(3);
690        assert(!myDataView.isEmpty());
691        assert(myDataView.getOffset()==3);
692        assert(myDataView.getRank()==0);
693        assert(myDataView.noValues()==1);
694        assert(myDataView.getShape().size()==0);
695        assert(myDataView()==1.0);
696    
697        // check result for default value
698        myDataView = myData.getDefaultValue();
699        assert(!myDataView.isEmpty());
700        assert(myDataView.getOffset()==0);
701        assert(myDataView.getRank()==0);
702        assert(myDataView.noValues()==1);
703        assert(myDataView.getShape().size()==0);
704        assert(myDataView()==0.0);
705    
706        // use a non-existent tag so we get a pointer to
707        // the first element of the data array
708        double* sampleData=myData.getSampleDataByTag(9);
709        for (int i=0; i<myData.getLength(); i++) {
710          if (i<3) {
711            assert(sampleData[i]==i);
712          } else {
713            assert(sampleData[i]==i-2);
714          }
715        }
716    
717      }
718    
719      {
720        cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
721    
722      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
723      viewShape.push_back(3);      viewShape.push_back(3);
724      DataArrayView::ValueType viewData(3);  
725      DataTagged::TagListType keys;      DataTagged::TagListType keys;
726    
727      DataTagged::ValueListType values;      DataTagged::ValueListType values;
728      for (int i=0;i<viewShape[0];++i) {  
729        DataArrayView::ValueType viewData(3);
730        for (int i=0;i<viewShape[0];i++) {
731        viewData[i]=i;        viewData[i]=i;
732      }      }
733      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
734      cout << "\tCreate tagged data with no tag values just a default." << endl;  
735      DataTagged left(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
736      DataTagged right(keys,values,myView,FunctionSpace());      DataTagged right(keys,values,myView,FunctionSpace());
737      binaryOp(left,right,minus<double>());  
738      for (int i=0;i<viewShape[0];++i) {      binaryOp(myData,right,multiplies<double>());
739        assert(left.getDefaultValue()(i)==0);  
740      }      //cout << myData.toString() << endl;
741      double mVal=10.0;  
742      for (int i=0;i<viewShape[0];++i) {      assert(myData.getNumSamples()==1);
743        viewData[i]=i*mVal;      assert(myData.getNumDPPSample()==1);
744      }  
745      cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      assert(myData.validSamplePointNo(0));
746      binaryOp(left,myView,minus<double>());      assert(myData.validSampleNo(0));
747      for (int i=0;i<viewShape[0];++i) {      assert(!myData.validSamplePointNo(1));
748        assert(left.getDefaultValue()(i)==-(i*mVal));      assert(!myData.validSampleNo(1));
749    
750        // data-point 0 has tag number 1 by default
751        assert(myData.getTagNumber(0)==1);
752    
753        assert(!myData.isCurrentTag(1));
754    
755        assert(myData.getTagLookup().size()==0);
756    
757        assert(myData.getLength()==3);
758    
759        assert(myData.getPointOffset(0,0)==0);
760    
761        DataArrayView myDataView = myData.getDefaultValue();
762        assert(!myDataView.isEmpty());
763        assert(myDataView.getOffset()==0);
764        assert(myDataView.getRank()==1);
765        assert(myDataView.noValues()==3);
766        assert(myDataView.getShape().size()==1);
767        assert(myDataView(0)==0);
768        assert(myDataView(1)==1);
769        assert(myDataView(2)==4);
770    
771        // use a non-existent tag so we get a pointer to
772        // the first element of the data array
773        double* sampleData=myData.getSampleDataByTag(9);
774        for (int i=0; i<myData.getLength(); i++) {
775          assert(sampleData[i]==i*i);
776        }
777    
778      }
779    
780      {
781        cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
782    
783        DataTagged myData;
784        DataTagged right;
785    
786        DataArray vOne(1.0);
787        DataArray vTwo(2.0);
788        myData.addTaggedValue(1,vOne.getView());
789        myData.addTaggedValue(2,vOne.getView());
790        right.addTaggedValue(2,vTwo.getView());
791        right.addTaggedValue(3,vTwo.getView());
792    
793        binaryOp(myData,right,multiplies<double>());
794    
795        assert(myData.getNumSamples()==1);
796        assert(myData.getNumDPPSample()==1);
797    
798        assert(myData.validSamplePointNo(0));
799        assert(myData.validSampleNo(0));
800        assert(!myData.validSamplePointNo(1));
801        assert(!myData.validSampleNo(1));
802    
803        // data-point 0 has tag number 1 by default
804        assert(myData.getTagNumber(0)==1);
805    
806        assert(myData.isCurrentTag(1));
807        assert(myData.isCurrentTag(2));
808        assert(myData.isCurrentTag(3));
809    
810        assert(myData.getTagLookup().size()==3);
811    
812        assert(myData.getLength()==4);
813    
814        assert(myData.getPointOffset(0,0)==1);
815    
816        // check result value for tag "1"
817        DataArrayView myDataView = myData.getDataPointByTag(1);
818        assert(!myDataView.isEmpty());
819        assert(myDataView.getOffset()==1);
820        assert(myDataView.getRank()==0);
821        assert(myDataView.noValues()==1);
822        assert(myDataView.getShape().size()==0);
823        assert(myDataView()==0.0);
824    
825        // check result value for tag "2"
826        myDataView = myData.getDataPointByTag(2);
827        assert(!myDataView.isEmpty());
828        assert(myDataView.getOffset()==2);
829        assert(myDataView.getRank()==0);
830        assert(myDataView.noValues()==1);
831        assert(myDataView.getShape().size()==0);
832        assert(myDataView()==2.0);
833    
834        // check result value for tag "3"
835        myDataView = myData.getDataPointByTag(3);
836        assert(!myDataView.isEmpty());
837        assert(myDataView.getOffset()==3);
838        assert(myDataView.getRank()==0);
839        assert(myDataView.noValues()==1);
840        assert(myDataView.getShape().size()==0);
841        assert(myDataView()==0.0);
842    
843        // check result for default value
844        myDataView = myData.getDefaultValue();
845        assert(!myDataView.isEmpty());
846        assert(myDataView.getOffset()==0);
847        assert(myDataView.getRank()==0);
848        assert(myDataView.noValues()==1);
849        assert(myDataView.getShape().size()==0);
850        assert(myDataView()==0.0);
851    
852        // use a non-existent tag so we get a pointer to
853        // the first element of the data array
854        double* sampleData=myData.getSampleDataByTag(9);
855        for (int i=0; i<myData.getLength(); i++) {
856          if (i==2) {
857            assert(sampleData[i]==2);
858          } else {
859            assert(sampleData[i]==0);
860          }
861        }
862    
863      }
864    
865      {
866        cout << "\tTest unaryOp negate on default DataTagged object." << endl;
867    
868        DataTagged myData;
869    
870        unaryOp(myData,negate<double>());
871    
872        //cout << myData.toString() << endl;
873    
874        assert(myData.getNumSamples()==1);
875        assert(myData.getNumDPPSample()==1);
876    
877        assert(myData.validSamplePointNo(0));
878        assert(myData.validSampleNo(0));
879        assert(!myData.validSamplePointNo(1));
880        assert(!myData.validSampleNo(1));
881    
882        // data-point 0 has tag number 1 by default
883        assert(myData.getTagNumber(0)==1);
884    
885        assert(!myData.isCurrentTag(1));
886    
887        assert(myData.getTagLookup().size()==0);
888    
889        assert(myData.getLength()==1);
890    
891        assert(myData.getPointOffset(0,0)==0);
892    
893        DataArrayView myDataView = myData.getDataPoint(0,0);
894        assert(!myDataView.isEmpty());
895        assert(myDataView.getOffset()==0);
896        assert(myDataView.getRank()==0);
897        assert(myDataView.noValues()==1);
898        assert(myDataView.getShape().size()==0);
899        assert(myDataView()==0.0);
900    
901        // Test non-existent tag returns the default value.
902        myDataView = myData.getDataPointByTag(1);
903        assert(!myDataView.isEmpty());
904        assert(myDataView.getOffset()==0);
905        assert(myDataView.getRank()==0);
906        assert(myDataView.noValues()==1);
907        assert(myDataView.getShape().size()==0);
908        assert(myDataView()==0.0);
909    
910        myDataView = myData.getDefaultValue();
911        assert(!myDataView.isEmpty());
912        assert(myDataView.getOffset()==0);
913        assert(myDataView.getRank()==0);
914        assert(myDataView.noValues()==1);
915        assert(myDataView.getShape().size()==0);
916        assert(myDataView()==0.0);
917    
918        // use a non-existent tag so we get a pointer to
919        // the first element of the data array
920        double* sampleData=myData.getSampleDataByTag(9);
921        for (int i=0; i<myData.getLength(); i++) {
922          assert(sampleData[i]==i);
923      }      }
924    
925    }    }
926    
927    {    {
928      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;      cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
929      DataTagged data;  
930      unaryOp(data,negate<double>());      DataArrayView::ShapeType viewShape;
931      assert(data.getDefaultValue()()==0);      viewShape.push_back(3);
932      DataArray vOne(1);  
     binaryOp(data,vOne.getView(),plus<double>());  
     assert(data.getDefaultValue()()==1);  
     unaryOp(data,negate<double>());  
     assert(data.getDefaultValue()()==-1);  
   }  
   {  
     cout << "\tTest unaryOp(negate) on DataTagged with 3 tags." << endl;  
     DataArrayView::ShapeType vShape;  
     vShape.push_back(3);  
     vShape.push_back(2);  
     vShape.push_back(1);  
     DataArray defData(vShape,0.0);  
     DataArrayView& defView=defData.getView();  
     DataArray tOneData(vShape,1.0);  
     DataArrayView& tOneView=tOneData.getView();  
     DataArray tTwoData(vShape,2.0);  
     DataArrayView& tTwoView=tTwoData.getView();  
     DataArray tThreeData(vShape,3.0);  
     DataArrayView& tThreeView=tThreeData.getView();  
933      DataTagged::TagListType keys;      DataTagged::TagListType keys;
934    
935      DataTagged::ValueListType values;      DataTagged::ValueListType values;
936    
937        DataArrayView::ValueType viewData(3);
938        for (int i=0;i<viewShape[0];i++) {
939          viewData[i]=i;
940        }
941        DataArrayView myView(viewData,viewShape);
942    
943        DataTagged myData(keys,values,myView,FunctionSpace());
944    
945        unaryOp(myData,negate<double>());
946    
947        //cout << myData.toString() << endl;
948    
949        assert(myData.getNumSamples()==1);
950        assert(myData.getNumDPPSample()==1);
951    
952        assert(myData.validSamplePointNo(0));
953        assert(myData.validSampleNo(0));
954        assert(!myData.validSamplePointNo(1));
955        assert(!myData.validSampleNo(1));
956    
957        // data-point 0 has tag number 1 by default
958        assert(myData.getTagNumber(0)==1);
959    
960        assert(!myData.isCurrentTag(1));
961    
962        assert(myData.getTagLookup().size()==0);
963    
964        assert(myData.getLength()==3);
965    
966        assert(myData.getPointOffset(0,0)==0);
967    
968        DataArrayView myDataView = myData.getDefaultValue();
969        assert(!myDataView.isEmpty());
970        assert(myDataView.getOffset()==0);
971        assert(myDataView.getRank()==1);
972        assert(myDataView.noValues()==3);
973        assert(myDataView.getShape().size()==1);
974        assert(myDataView(0)==0);
975        assert(myDataView(1)==-1);
976        assert(myDataView(2)==-2);
977    
978        // use a non-existent tag so we get a pointer to
979        // the first element of the data array
980        double* sampleData=myData.getSampleDataByTag(9);
981        for (int i=0; i<myData.getLength(); i++) {
982          assert(sampleData[i]==0-i);
983        }
984    
985      }
986    
987      {
988        cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;
989    
990        DataTagged myData;
991    
992        DataArray vOne(1.0);
993        DataArray vTwo(2.0);
994        myData.addTaggedValue(1,vOne.getView());
995        myData.addTaggedValue(2,vTwo.getView());
996    
997        unaryOp(myData,negate<double>());
998    
999        assert(myData.getNumSamples()==1);
1000        assert(myData.getNumDPPSample()==1);
1001    
1002        assert(myData.validSamplePointNo(0));
1003        assert(myData.validSampleNo(0));
1004        assert(!myData.validSamplePointNo(1));
1005        assert(!myData.validSampleNo(1));
1006    
1007        // data-point 0 has tag number 1 by default
1008        assert(myData.getTagNumber(0)==1);
1009    
1010        assert(myData.isCurrentTag(1));
1011        assert(myData.isCurrentTag(2));
1012    
1013        assert(myData.getTagLookup().size()==2);
1014    
1015        assert(myData.getLength()==3);
1016    
1017        assert(myData.getPointOffset(0,0)==1);
1018    
1019        // check result value for tag "1"
1020        DataArrayView myDataView = myData.getDataPointByTag(1);
1021        assert(!myDataView.isEmpty());
1022        assert(myDataView.getOffset()==1);
1023        assert(myDataView.getRank()==0);
1024        assert(myDataView.noValues()==1);
1025        assert(myDataView.getShape().size()==0);
1026        assert(myDataView()==-1.0);
1027    
1028        // check result value for tag "2"
1029        myDataView = myData.getDataPointByTag(2);
1030        assert(!myDataView.isEmpty());
1031        assert(myDataView.getOffset()==2);
1032        assert(myDataView.getRank()==0);
1033        assert(myDataView.noValues()==1);
1034        assert(myDataView.getShape().size()==0);
1035        assert(myDataView()==-2.0);
1036    
1037        // check result for default value
1038        myDataView = myData.getDefaultValue();
1039        assert(!myDataView.isEmpty());
1040        assert(myDataView.getOffset()==0);
1041        assert(myDataView.getRank()==0);
1042        assert(myDataView.noValues()==1);
1043        assert(myDataView.getShape().size()==0);
1044        assert(myDataView()==0.0);
1045    
1046        // use a non-existent tag so we get a pointer to
1047        // the first element of the data array
1048        double* sampleData=myData.getSampleDataByTag(9);
1049        for (int i=0; i<myData.getLength(); i++) {
1050          assert(sampleData[i]==0-i);
1051        }
1052    
1053      }
1054    
1055    }
1056    
1057    void DataTaggedTestCase::testAddTaggedValues() {
1058    
1059      cout << endl;
1060    
1061      {
1062    
1063        cout << "\tTest adding one key with empty value list to default DataTagged." << endl;
1064        DataTagged myData;
1065    
1066        DataTagged::TagListType keys;
1067        keys.push_back(1);
1068    
1069        DataTagged::ValueListType values;
1070    
1071        myData.addTaggedValues(keys,values);
1072    
1073        assert(myData.isCurrentTag(1));
1074    
1075        assert(myData.getTagLookup().size()==1);
1076    
1077        assert(myData.getLength()==2);
1078    
1079        // data-point 0 has tag number 1 by default
1080        assert(myData.getTagNumber(0)==1);
1081    
1082        assert(myData.getPointOffset(0,0)==1);
1083    
1084        DataArrayView myDataView = myData.getDataPoint(0,0);
1085        assert(!myDataView.isEmpty());
1086        assert(myDataView.getOffset()==1);
1087        assert(myDataView.getRank()==0);
1088        assert(myDataView.noValues()==1);
1089        assert(myDataView.getShape().size()==0);
1090        assert(myDataView()==0.0);
1091    
1092        myDataView = myData.getDataPointByTag(1);
1093        assert(!myDataView.isEmpty());
1094        assert(myDataView.getOffset()==1);
1095        assert(myDataView.getRank()==0);
1096        assert(myDataView.noValues()==1);
1097        assert(myDataView.getShape().size()==0);
1098        assert(myDataView()==0.0);
1099    
1100        myDataView = myData.getDefaultValue();
1101        assert(!myDataView.isEmpty());
1102        assert(myDataView.getOffset()==0);
1103        assert(myDataView.getRank()==0);
1104        assert(myDataView.noValues()==1);
1105        assert(myDataView.getShape().size()==0);
1106        assert(myDataView()==0.0);
1107    
1108        // use a non-existent tag so we get a pointer to
1109        // the first element of the data array
1110        double* sampleData=myData.getSampleDataByTag(9);
1111        for (int i=0; i<myData.getLength(); i++) {
1112          assert(sampleData[i]==0);
1113        }
1114    
1115      }
1116    
1117      {
1118    
1119        cout << "\tTest adding one key with one value to default DataTagged." << endl;
1120        DataTagged myData;
1121    
1122        DataTagged::TagListType keys;
1123        keys.push_back(1);
1124    
1125        DataTagged::ValueListType values;
1126    
1127        DataArrayView::ShapeType viewShape;
1128        DataArrayView::ValueType viewData(1);
1129        viewData[0]=1.0;
1130        DataArrayView myView(viewData,viewShape);
1131        values.push_back(myView);
1132    
1133        myData.addTaggedValues(keys,values);
1134    
1135        assert(myData.isCurrentTag(1));
1136    
1137        assert(myData.getTagLookup().size()==1);
1138    
1139        assert(myData.getLength()==2);
1140    
1141        // data-point 0 has tag number 1 by default
1142        assert(myData.getTagNumber(0)==1);
1143    
1144        assert(myData.getPointOffset(0,0)==1);
1145    
1146        DataArrayView myDataView = myData.getDataPoint(0,0);
1147        assert(!myDataView.isEmpty());
1148        assert(myDataView.getOffset()==1);
1149        assert(myDataView.getRank()==0);
1150        assert(myDataView.noValues()==1);
1151        assert(myDataView.getShape().size()==0);
1152        assert(myDataView()==1.0);
1153    
1154        myDataView = myData.getDataPointByTag(1);
1155        assert(!myDataView.isEmpty());
1156        assert(myDataView.getOffset()==1);
1157        assert(myDataView.getRank()==0);
1158        assert(myDataView.noValues()==1);
1159        assert(myDataView.getShape().size()==0);
1160        assert(myDataView()==1.0);
1161    
1162        myDataView = myData.getDefaultValue();
1163        assert(!myDataView.isEmpty());
1164        assert(myDataView.getOffset()==0);
1165        assert(myDataView.getRank()==0);
1166        assert(myDataView.noValues()==1);
1167        assert(myDataView.getShape().size()==0);
1168        assert(myDataView()==0.0);
1169    
1170        // use a non-existent tag so we get a pointer to
1171        // the first element of the data array
1172        double* sampleData=myData.getSampleDataByTag(9);
1173        for (int i=0; i<myData.getLength(); i++) {
1174          assert(sampleData[i]==i);
1175        }
1176    
1177      }
1178    
1179      {
1180    
1181        cout << "\tTest adding three keys with one value to default DataTagged." << endl;
1182        DataTagged myData;
1183    
1184        DataTagged::TagListType keys;
1185        keys.push_back(1);
1186        keys.push_back(2);
1187        keys.push_back(3);
1188    
1189        DataTagged::ValueListType values;
1190    
1191        DataArrayView::ShapeType viewShape;
1192        DataArrayView::ValueType viewData(1);
1193        viewData[0]=1.0;
1194        DataArrayView myView(viewData,viewShape);
1195        values.push_back(myView);
1196    
1197        myData.addTaggedValues(keys,values);
1198    
1199        assert(myData.isCurrentTag(1));
1200        assert(myData.isCurrentTag(2));
1201        assert(myData.isCurrentTag(3));
1202    
1203        assert(myData.getTagLookup().size()==3);
1204    
1205        assert(myData.getLength()==4);
1206    
1207        // data-point 0 has tag number 1 by default
1208        assert(myData.getTagNumber(0)==1);
1209    
1210        assert(myData.getPointOffset(0,0)==1);
1211    
1212        DataArrayView myDataView = myData.getDataPoint(0,0);
1213        assert(!myDataView.isEmpty());
1214        assert(myDataView.getOffset()==1);
1215        assert(myDataView.getRank()==0);
1216        assert(myDataView.noValues()==1);
1217        assert(myDataView.getShape().size()==0);
1218        assert(myDataView()==1.0);
1219    
1220        myDataView = myData.getDataPointByTag(1);
1221        assert(!myDataView.isEmpty());
1222        assert(myDataView.getOffset()==1);
1223        assert(myDataView.getRank()==0);
1224        assert(myDataView.noValues()==1);
1225        assert(myDataView.getShape().size()==0);
1226        assert(myDataView()==1.0);
1227    
1228        myDataView = myData.getDataPointByTag(2);
1229        assert(!myDataView.isEmpty());
1230        assert(myDataView.getOffset()==2);
1231        assert(myDataView.getRank()==0);
1232        assert(myDataView.noValues()==1);
1233        assert(myDataView.getShape().size()==0);
1234        assert(myDataView()==1.0);
1235    
1236        myDataView = myData.getDataPointByTag(3);
1237        assert(!myDataView.isEmpty());
1238        assert(myDataView.getOffset()==3);
1239        assert(myDataView.getRank()==0);
1240        assert(myDataView.noValues()==1);
1241        assert(myDataView.getShape().size()==0);
1242        assert(myDataView()==1.0);
1243    
1244        myDataView = myData.getDefaultValue();
1245        assert(!myDataView.isEmpty());
1246        assert(myDataView.getOffset()==0);
1247        assert(myDataView.getRank()==0);
1248        assert(myDataView.noValues()==1);
1249        assert(myDataView.getShape().size()==0);
1250        assert(myDataView()==0.0);
1251    
1252        // use a non-existent tag so we get a pointer to
1253        // the first element of the data array
1254        double* sampleData=myData.getSampleDataByTag(9);
1255        for (int i=0; i<myData.getLength(); i++) {
1256          if (i==0) {
1257            assert(sampleData[i]==0);
1258          } else {
1259            assert(sampleData[i]==1);
1260          }
1261        }
1262    
1263      }
1264    
1265      {
1266    
1267        cout << "\tTest adding three keys with three values to default DataTagged." << endl;
1268        DataTagged myData;
1269    
1270        DataTagged::TagListType keys;
1271      keys.push_back(1);      keys.push_back(1);
1272      keys.push_back(2);      keys.push_back(2);
1273      keys.push_back(3);      keys.push_back(3);
1274      values.push_back(tOneView);  
1275      values.push_back(tTwoView);      DataTagged::ValueListType values;
1276      values.push_back(tThreeView);  
1277      DataTagged tData(keys,values,defView,FunctionSpace());      DataArrayView::ShapeType viewShape;
1278      unaryOp(tData,negate<double>());      DataArrayView::ValueType viewData1(1);
1279      unaryOp(tData,negate<double>());      viewData1[0]=1.0;
1280      assert(tData.getDataPointByTag(1)==tOneView);      DataArrayView::ValueType viewData2(1);
1281      assert(tData.getDataPointByTag(2)==tTwoView);      viewData2[0]=2.0;
1282      assert(tData.getDataPointByTag(3)==tThreeView);      DataArrayView::ValueType viewData3(1);
1283        viewData3[0]=3.0;
1284        DataArrayView myView1(viewData1,viewShape);
1285        DataArrayView myView2(viewData2,viewShape);
1286        DataArrayView myView3(viewData3,viewShape);
1287        values.push_back(myView1);
1288        values.push_back(myView2);
1289        values.push_back(myView3);
1290    
1291        myData.addTaggedValues(keys,values);
1292    
1293        assert(myData.isCurrentTag(1));
1294        assert(myData.isCurrentTag(2));
1295        assert(myData.isCurrentTag(3));
1296    
1297        assert(myData.getTagLookup().size()==3);
1298    
1299        assert(myData.getLength()==4);
1300    
1301        // data-point 0 has tag number 1 by default
1302        assert(myData.getTagNumber(0)==1);
1303    
1304        assert(myData.getPointOffset(0,0)==1);
1305    
1306        DataArrayView myDataView = myData.getDataPoint(0,0);
1307        assert(!myDataView.isEmpty());
1308        assert(myDataView.getOffset()==1);
1309        assert(myDataView.getRank()==0);
1310        assert(myDataView.noValues()==1);
1311        assert(myDataView.getShape().size()==0);
1312        assert(myDataView()==1.0);
1313    
1314        myDataView = myData.getDataPointByTag(1);
1315        assert(!myDataView.isEmpty());
1316        assert(myDataView.getOffset()==1);
1317        assert(myDataView.getRank()==0);
1318        assert(myDataView.noValues()==1);
1319        assert(myDataView.getShape().size()==0);
1320        assert(myDataView()==1.0);
1321    
1322        myDataView = myData.getDataPointByTag(2);
1323        assert(!myDataView.isEmpty());
1324        assert(myDataView.getOffset()==2);
1325        assert(myDataView.getRank()==0);
1326        assert(myDataView.noValues()==1);
1327        assert(myDataView.getShape().size()==0);
1328        assert(myDataView()==2.0);
1329    
1330        myDataView = myData.getDataPointByTag(3);
1331        assert(!myDataView.isEmpty());
1332        assert(myDataView.getOffset()==3);
1333        assert(myDataView.getRank()==0);
1334        assert(myDataView.noValues()==1);
1335        assert(myDataView.getShape().size()==0);
1336        assert(myDataView()==3.0);
1337    
1338        myDataView = myData.getDefaultValue();
1339        assert(!myDataView.isEmpty());
1340        assert(myDataView.getOffset()==0);
1341        assert(myDataView.getRank()==0);
1342        assert(myDataView.noValues()==1);
1343        assert(myDataView.getShape().size()==0);
1344        assert(myDataView()==0.0);
1345    
1346        // use a non-existent tag so we get a pointer to
1347        // the first element of the data array
1348        double* sampleData=myData.getSampleDataByTag(9);
1349        for (int i=0; i<myData.getLength(); i++) {
1350          assert(sampleData[i]==i);
1351        }
1352    
1353      }
1354    
1355      {
1356    
1357        cout << "\tTest adding one key with empty value list to DataTagged with default value only." << endl;
1358    
1359        DataArrayView::ShapeType viewShape;
1360        viewShape.push_back(3);
1361    
1362        DataTagged::TagListType keys;
1363    
1364        DataTagged::ValueListType values;
1365    
1366        DataArrayView::ValueType viewData(3);
1367        for (int i=0;i<viewShape[0];i++) {
1368          viewData[i]=i;
1369        }
1370        DataArrayView myView(viewData,viewShape);
1371    
1372        DataTagged myData(keys,values,myView,FunctionSpace());
1373    
1374        keys.push_back(1);
1375        values.clear();
1376    
1377        myData.addTaggedValues(keys,values);
1378    
1379        assert(myData.isCurrentTag(1));
1380    
1381        assert(myData.getTagLookup().size()==1);
1382    
1383        assert(myData.getLength()==6);
1384    
1385        // data-point 0 has tag number 1 by default
1386        assert(myData.getTagNumber(0)==1);
1387    
1388        assert(myData.getPointOffset(0,0)==3);
1389    
1390        DataArrayView myDataView = myData.getDataPoint(0,0);
1391        assert(myDataView==myView);
1392        assert(!myDataView.isEmpty());
1393        assert(myDataView.getOffset()==3);
1394        assert(myDataView.getRank()==1);
1395        assert(myDataView.noValues()==3);
1396        assert(myDataView.getShape().size()==1);
1397        assert(myDataView(0)==0);
1398        assert(myDataView(1)==1);
1399        assert(myDataView(2)==2);
1400    
1401        myDataView = myData.getDataPointByTag(1);
1402        assert(myDataView==myView);
1403        assert(!myDataView.isEmpty());
1404        assert(myDataView.getOffset()==3);
1405        assert(myDataView.getRank()==1);
1406        assert(myDataView.noValues()==3);
1407        assert(myDataView.getShape().size()==1);
1408        assert(myDataView(0)==0);
1409        assert(myDataView(1)==1);
1410        assert(myDataView(2)==2);
1411    
1412        myDataView = myData.getDefaultValue();
1413        assert(myDataView==myView);
1414        assert(!myDataView.isEmpty());
1415        assert(myDataView.getOffset()==0);
1416        assert(myDataView.getRank()==1);
1417        assert(myDataView.noValues()==3);
1418        assert(myDataView.getShape().size()==1);
1419        assert(myDataView(0)==0);
1420        assert(myDataView(1)==1);
1421        assert(myDataView(2)==2);
1422    
1423        // use a non-existent tag so we get a pointer to
1424        // the first element of the data array
1425        double* sampleData=myData.getSampleDataByTag(9);
1426        for (int i=0; i<myData.getLength(); i++) {
1427          assert(sampleData[i]==i%3);
1428        }
1429    
1430      }
1431    
1432      {
1433    
1434        cout << "\tTest adding one key with one value to DataTagged with default value only." << endl;
1435    
1436        DataArrayView::ShapeType viewShape;
1437        viewShape.push_back(3);
1438    
1439        DataTagged::TagListType keys;
1440    
1441        DataTagged::ValueListType values;
1442    
1443        DataArrayView::ValueType viewData(3);
1444        for (int i=0;i<viewShape[0];i++) {
1445          viewData[i]=i;
1446        }
1447        DataArrayView myView(viewData,viewShape);
1448    
1449        DataTagged myData(keys,values,myView,FunctionSpace());
1450    
1451        keys.push_back(1);
1452    
1453        DataArrayView::ValueType viewData1(3);
1454        for (int i=0;i<viewShape[0];i++) {
1455          viewData1[i]=i+3;
1456        }
1457        DataArrayView myView1(viewData1,viewShape);
1458        values.push_back(myView1);
1459    
1460        myData.addTaggedValues(keys,values);
1461    
1462        assert(myData.isCurrentTag(1));
1463    
1464        assert(myData.getTagLookup().size()==1);
1465    
1466        assert(myData.getLength()==6);
1467    
1468        // data-point 0 has tag number 1 by default
1469        assert(myData.getTagNumber(0)==1);
1470    
1471        assert(myData.getPointOffset(0,0)==3);
1472    
1473        DataArrayView myDataView = myData.getDataPoint(0,0);
1474        assert(myDataView==myView1);
1475        assert(!myDataView.isEmpty());
1476        assert(myDataView.getOffset()==3);
1477        assert(myDataView.getRank()==1);
1478        assert(myDataView.noValues()==3);
1479        assert(myDataView.getShape().size()==1);
1480        assert(myDataView(0)==3);
1481        assert(myDataView(1)==4);
1482        assert(myDataView(2)==5);
1483    
1484        myDataView = myData.getDataPointByTag(1);
1485        assert(myDataView==myView1);
1486        assert(!myDataView.isEmpty());
1487        assert(myDataView.getOffset()==3);
1488        assert(myDataView.getRank()==1);
1489        assert(myDataView.noValues()==3);
1490        assert(myDataView.getShape().size()==1);
1491        assert(myDataView(0)==3);
1492        assert(myDataView(1)==4);
1493        assert(myDataView(2)==5);
1494    
1495        myDataView = myData.getDefaultValue();
1496        assert(myDataView==myView);
1497        assert(!myDataView.isEmpty());
1498        assert(myDataView.getOffset()==0);
1499        assert(myDataView.getRank()==1);
1500        assert(myDataView.noValues()==3);
1501        assert(myDataView.getShape().size()==1);
1502        assert(myDataView(0)==0);
1503        assert(myDataView(1)==1);
1504        assert(myDataView(2)==2);
1505    
1506        // use a non-existent tag so we get a pointer to
1507        // the first element of the data array
1508        double* sampleData=myData.getSampleDataByTag(9);
1509        for (int i=0; i<myData.getLength(); i++) {
1510          assert(sampleData[i]==i);
1511        }
1512    
1513    }    }
1514    
1515      {
1516    
1517        cout << "\tTest adding three keys with one value to DataTagged with default value only." << endl;
1518    
1519        DataArrayView::ShapeType viewShape;
1520        viewShape.push_back(3);
1521    
1522        DataTagged::TagListType keys;
1523    
1524        DataTagged::ValueListType values;
1525    
1526        DataArrayView::ValueType viewData(3);
1527        for (int i=0;i<viewShape[0];i++) {
1528          viewData[i]=i;
1529        }
1530        DataArrayView myView(viewData,viewShape);
1531    
1532        DataTagged myData(keys,values,myView,FunctionSpace());
1533    
1534        keys.push_back(1);
1535        keys.push_back(2);
1536        keys.push_back(3);
1537    
1538        DataArrayView::ValueType viewData1(3);
1539        for (int i=0;i<viewShape[0];i++) {
1540          viewData1[i]=3;
1541        }
1542        DataArrayView myView1(viewData1,viewShape);
1543        values.push_back(myView1);
1544    
1545        myData.addTaggedValues(keys,values);
1546    
1547        assert(myData.isCurrentTag(1));
1548        assert(myData.isCurrentTag(2));
1549        assert(myData.isCurrentTag(3));
1550    
1551        assert(myData.getTagLookup().size()==3);
1552    
1553        assert(myData.getLength()==12);
1554    
1555        // data-point 0 has tag number 1 by default
1556        assert(myData.getTagNumber(0)==1);
1557    
1558        assert(myData.getPointOffset(0,0)==3);
1559    
1560        DataArrayView myDataView = myData.getDataPoint(0,0);
1561        assert(myDataView==myView1);
1562        assert(!myDataView.isEmpty());
1563        assert(myDataView.getOffset()==3);
1564        assert(myDataView.getRank()==1);
1565        assert(myDataView.noValues()==3);
1566        assert(myDataView.getShape().size()==1);
1567        assert(myDataView(0)==3);
1568        assert(myDataView(1)==3);
1569        assert(myDataView(2)==3);
1570    
1571        myDataView = myData.getDataPointByTag(1);
1572        assert(myDataView==myView1);
1573        assert(!myDataView.isEmpty());
1574        assert(myDataView.getOffset()==3);
1575        assert(myDataView.getRank()==1);
1576        assert(myDataView.noValues()==3);
1577        assert(myDataView.getShape().size()==1);
1578        assert(myDataView(0)==3);
1579        assert(myDataView(1)==3);
1580        assert(myDataView(2)==3);
1581    
1582        myDataView = myData.getDataPointByTag(2);
1583        assert(myDataView==myView1);
1584        assert(!myDataView.isEmpty());
1585        assert(myDataView.getOffset()==6);
1586        assert(myDataView.getRank()==1);
1587        assert(myDataView.noValues()==3);
1588        assert(myDataView.getShape().size()==1);
1589        assert(myDataView(0)==3);
1590        assert(myDataView(1)==3);
1591        assert(myDataView(2)==3);
1592    
1593        myDataView = myData.getDataPointByTag(3);
1594        assert(myDataView==myView1);
1595        assert(!myDataView.isEmpty());
1596        assert(myDataView.getOffset()==9);
1597        assert(myDataView.getRank()==1);
1598        assert(myDataView.noValues()==3);
1599        assert(myDataView.getShape().size()==1);
1600        assert(myDataView(0)==3);
1601        assert(myDataView(1)==3);
1602        assert(myDataView(2)==3);
1603    
1604        myDataView = myData.getDefaultValue();
1605        assert(myDataView==myView);
1606        assert(!myDataView.isEmpty());
1607        assert(myDataView.getOffset()==0);
1608        assert(myDataView.getRank()==1);
1609        assert(myDataView.noValues()==3);
1610        assert(myDataView.getShape().size()==1);
1611        assert(myDataView(0)==0);
1612        assert(myDataView(1)==1);
1613        assert(myDataView(2)==2);
1614    
1615        // use a non-existent tag so we get a pointer to
1616        // the first element of the data array
1617        double* sampleData=myData.getSampleDataByTag(9);
1618        for (int i=0; i<myData.getLength(); i++) {
1619          if (i<3) {
1620            assert(sampleData[i]==i);
1621          } else {
1622            assert(sampleData[i]==3);
1623          }
1624        }
1625    
1626      }
1627    
1628      {
1629    
1630        cout << "\tTest adding three keys with three values to DataTagged with default value only." << endl;
1631    
1632        DataArrayView::ShapeType viewShape;
1633        viewShape.push_back(3);
1634    
1635        DataTagged::TagListType keys;
1636    
1637        DataTagged::ValueListType values;
1638    
1639        DataArrayView::ValueType viewData(3);
1640        for (int i=0;i<viewShape[0];i++) {
1641          viewData[i]=i;
1642        }
1643        DataArrayView myView(viewData,viewShape);
1644    
1645        DataTagged myData(keys,values,myView,FunctionSpace());
1646    
1647        keys.push_back(1);
1648        keys.push_back(2);
1649        keys.push_back(3);
1650    
1651        DataArrayView::ValueType viewData1(3);
1652        for (int i=0;i<viewShape[0];i++) {
1653          viewData1[i]=i+1;
1654        }
1655        DataArrayView myView1(viewData1,viewShape);
1656        values.push_back(myView1);
1657    
1658        DataArrayView::ValueType viewData2(3);
1659        for (int i=0;i<viewShape[0];i++) {
1660          viewData2[i]=i+2;
1661        }
1662        DataArrayView myView2(viewData2,viewShape);
1663        values.push_back(myView2);
1664    
1665        DataArrayView::ValueType viewData3(3);
1666        for (int i=0;i<viewShape[0];i++) {
1667          viewData3[i]=i+3;
1668        }
1669        DataArrayView myView3(viewData3,viewShape);
1670        values.push_back(myView3);
1671    
1672        myData.addTaggedValues(keys,values);
1673    
1674        assert(myData.isCurrentTag(1));
1675        assert(myData.isCurrentTag(2));
1676        assert(myData.isCurrentTag(3));
1677    
1678        assert(myData.getTagLookup().size()==3);
1679    
1680        assert(myData.getLength()==12);
1681    
1682        // data-point 0 has tag number 1 by default
1683        assert(myData.getTagNumber(0)==1);
1684    
1685        assert(myData.getPointOffset(0,0)==3);
1686    
1687        DataArrayView myDataView = myData.getDataPoint(0,0);
1688        assert(myDataView==myView1);
1689        assert(!myDataView.isEmpty());
1690        assert(myDataView.getOffset()==3);
1691        assert(myDataView.getRank()==1);
1692        assert(myDataView.noValues()==3);
1693        assert(myDataView.getShape().size()==1);
1694        assert(myDataView(0)==1);
1695        assert(myDataView(1)==2);
1696        assert(myDataView(2)==3);
1697    
1698        myDataView = myData.getDataPointByTag(1);
1699        assert(myDataView==myView1);
1700        assert(!myDataView.isEmpty());
1701        assert(myDataView.getOffset()==3);
1702        assert(myDataView.getRank()==1);
1703        assert(myDataView.noValues()==3);
1704        assert(myDataView.getShape().size()==1);
1705        assert(myDataView(0)==1);
1706        assert(myDataView(1)==2);
1707        assert(myDataView(2)==3);
1708    
1709        myDataView = myData.getDataPointByTag(2);
1710        assert(myDataView==myView2);
1711        assert(!myDataView.isEmpty());
1712        assert(myDataView.getOffset()==6);
1713        assert(myDataView.getRank()==1);
1714        assert(myDataView.noValues()==3);
1715        assert(myDataView.getShape().size()==1);
1716        assert(myDataView(0)==2);
1717        assert(myDataView(1)==3);
1718        assert(myDataView(2)==4);
1719    
1720        myDataView = myData.getDataPointByTag(3);
1721        assert(myDataView==myView3);
1722        assert(!myDataView.isEmpty());
1723        assert(myDataView.getOffset()==9);
1724        assert(myDataView.getRank()==1);
1725        assert(myDataView.noValues()==3);
1726        assert(myDataView.getShape().size()==1);
1727        assert(myDataView(0)==3);
1728        assert(myDataView(1)==4);
1729        assert(myDataView(2)==5);
1730    
1731        myDataView = myData.getDefaultValue();
1732        assert(myDataView==myView);
1733        assert(!myDataView.isEmpty());
1734        assert(myDataView.getOffset()==0);
1735        assert(myDataView.getRank()==1);
1736        assert(myDataView.noValues()==3);
1737        assert(myDataView.getShape().size()==1);
1738        assert(myDataView(0)==0);
1739        assert(myDataView(1)==1);
1740        assert(myDataView(2)==2);
1741    
1742        // use a non-existent tag so we get a pointer to
1743        // the first element of the data array
1744        double* sampleData=myData.getSampleDataByTag(9);
1745        for (int i=0; i<myData.getLength(); i++) {
1746          if (i<3) {
1747            assert(sampleData[i]==i);
1748          } else if ((i>=3) && (i<6)) {
1749            assert(sampleData[i]==i-2);
1750          } else if ((i>=6) && (i<9)) {
1751            assert(sampleData[i]==i-4);
1752          } else  {
1753            assert(sampleData[i]==i-6);
1754          }
1755        }
1756    
1757      }
1758    
1759      {
1760    
1761        cout << "\tTest adding one key with empty value list to DataTagged with three tags." << endl;
1762    
1763        DataTagged::TagListType keys;
1764        keys.push_back(1);
1765        keys.push_back(2);
1766        keys.push_back(3);
1767    
1768        DataTagged::ValueListType values;
1769    
1770        DataArrayView::ShapeType viewShape;
1771        viewShape.push_back(3);
1772    
1773        // default value
1774        DataArrayView::ValueType viewData(3);
1775        for (int i=0;i<viewShape[0];i++) {
1776          viewData[i]=i;
1777        }
1778        DataArrayView myView(viewData,viewShape);
1779    
1780        // value for tag "1"
1781        DataArray eOne(myView);
1782        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1783          eOne.getView()(i)=i+1.0;
1784        }
1785        values.push_back(eOne.getView());
1786    
1787        // value for tag "2"
1788        DataArray eTwo(myView);
1789        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1790          eTwo.getView()(i)=i+2.0;
1791        }
1792        values.push_back(eTwo.getView());
1793    
1794        // value for tag "3"
1795        DataArray eThree(myView);
1796        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1797          eThree.getView()(i)=i+3.0;
1798        }
1799        values.push_back(eThree.getView());
1800    
1801        DataTagged myData(keys,values,myView,FunctionSpace());
1802    
1803        keys.clear();
1804        keys.push_back(4);
1805        values.clear();
1806    
1807        myData.addTaggedValues(keys,values);
1808    
1809        assert(myData.isCurrentTag(4));
1810    
1811        assert(myData.getTagLookup().size()==4);
1812    
1813        assert(myData.getLength()==15);
1814    
1815        DataArrayView myDataView = myData.getDataPointByTag(4);
1816        assert(myDataView==myView);
1817        assert(!myDataView.isEmpty());
1818        assert(myDataView.getOffset()==12);
1819        assert(myDataView.getRank()==1);
1820        assert(myDataView.noValues()==3);
1821        assert(myDataView.getShape().size()==1);
1822        assert(myDataView(0)==0);
1823        assert(myDataView(1)==1);
1824        assert(myDataView(2)==2);
1825    
1826        // use a non-existent tag so we get a pointer to
1827        // the first element of the data array
1828        double* sampleData=myData.getSampleDataByTag(9);
1829        for (int i=0; i<myData.getLength(); i++) {
1830          if (i<3) {
1831            assert(sampleData[i]==i);
1832          } else if ((i>=3) && (i<6)) {
1833            assert(sampleData[i]==i-2);
1834          } else if ((i>=6) && (i<9)) {
1835            assert(sampleData[i]==i-4);
1836          } else if ((i>=9) && (i<12)) {
1837            assert(sampleData[i]==i-6);
1838          } else {
1839            assert(sampleData[i]==i-12);
1840          }
1841        }
1842    
1843      }
1844    
1845      {
1846    
1847        cout << "\tTest adding one key with one value to DataTagged with three tags." << endl;
1848    
1849        DataTagged::TagListType keys;
1850        keys.push_back(1);
1851        keys.push_back(2);
1852        keys.push_back(3);
1853    
1854        DataTagged::ValueListType values;
1855    
1856        DataArrayView::ShapeType viewShape;
1857        viewShape.push_back(3);
1858    
1859        // default value
1860        DataArrayView::ValueType viewData(3);
1861        for (int i=0;i<viewShape[0];i++) {
1862          viewData[i]=i;
1863        }
1864        DataArrayView myView(viewData,viewShape);
1865    
1866        // value for tag "1"
1867        DataArray eOne(myView);
1868        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1869          eOne.getView()(i)=i+1.0;
1870        }
1871        values.push_back(eOne.getView());
1872    
1873        // value for tag "2"
1874        DataArray eTwo(myView);
1875        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1876          eTwo.getView()(i)=i+2.0;
1877        }
1878        values.push_back(eTwo.getView());
1879    
1880        // value for tag "3"
1881        DataArray eThree(myView);
1882        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1883          eThree.getView()(i)=i+3.0;
1884        }
1885        values.push_back(eThree.getView());
1886    
1887        DataTagged myData(keys,values,myView,FunctionSpace());
1888    
1889        keys.clear();
1890        keys.push_back(4);
1891    
1892        values.clear();
1893        // value for tag "4"
1894        DataArray eFour(myView);
1895        for (int i=0;i<eFour.getView().getShape()[0];i++) {
1896          eFour.getView()(i)=i+4.0;
1897        }
1898        values.push_back(eFour.getView());
1899    
1900        myData.addTaggedValues(keys,values);
1901    
1902        assert(myData.isCurrentTag(4));
1903    
1904        assert(myData.getTagLookup().size()==4);
1905    
1906        assert(myData.getLength()==15);
1907    
1908        DataArrayView myDataView = myData.getDataPointByTag(4);
1909        assert(myDataView==eFour.getView());
1910        assert(!myDataView.isEmpty());
1911        assert(myDataView.getOffset()==12);
1912        assert(myDataView.getRank()==1);
1913        assert(myDataView.noValues()==3);
1914        assert(myDataView.getShape().size()==1);
1915        assert(myDataView(0)==4);
1916        assert(myDataView(1)==5);
1917        assert(myDataView(2)==6);
1918    
1919        // use a non-existent tag so we get a pointer to
1920        // the first element of the data array
1921        double* sampleData=myData.getSampleDataByTag(9);
1922        for (int i=0; i<myData.getLength(); i++) {
1923          if (i<3) {
1924            assert(sampleData[i]==i);
1925          } else if ((i>=3) && (i<6)) {
1926            assert(sampleData[i]==i-2);
1927          } else if ((i>=6) && (i<9)) {
1928            assert(sampleData[i]==i-4);
1929          } else if ((i>=9) && (i<12)) {
1930            assert(sampleData[i]==i-6);
1931          } else {
1932            assert(sampleData[i]==i-8);
1933          }
1934        }
1935    
1936      }
1937    
1938      {
1939    
1940        cout << "\tTest adding three keys with one value to DataTagged with three tags." << endl;
1941    
1942        DataTagged::TagListType keys;
1943        keys.push_back(1);
1944        keys.push_back(2);
1945        keys.push_back(3);
1946    
1947        DataTagged::ValueListType values;
1948    
1949        DataArrayView::ShapeType viewShape;
1950        viewShape.push_back(3);
1951    
1952        // default value
1953        DataArrayView::ValueType viewData(3);
1954        for (int i=0;i<viewShape[0];i++) {
1955          viewData[i]=i;
1956        }
1957        DataArrayView myView(viewData,viewShape);
1958    
1959        // value for tag "1"
1960        DataArray eOne(myView);
1961        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1962          eOne.getView()(i)=i+1.0;
1963        }
1964        values.push_back(eOne.getView());
1965    
1966        // value for tag "2"
1967        DataArray eTwo(myView);
1968        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1969          eTwo.getView()(i)=i+2.0;
1970        }
1971        values.push_back(eTwo.getView());
1972    
1973        // value for tag "3"
1974        DataArray eThree(myView);
1975        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1976          eThree.getView()(i)=i+3.0;
1977        }
1978        values.push_back(eThree.getView());
1979    
1980        DataTagged myData(keys,values,myView,FunctionSpace());
1981    
1982        keys.clear();
1983        keys.push_back(4);
1984        keys.push_back(5);
1985        keys.push_back(6);
1986    
1987        values.clear();
1988        // value for tags "4", "5" and "6"
1989        DataArray eFour(myView);
1990        for (int i=0;i<eFour.getView().getShape()[0];i++) {
1991          eFour.getView()(i)=i+4.0;
1992        }
1993        values.push_back(eFour.getView());
1994    
1995        myData.addTaggedValues(keys,values);
1996    
1997        assert(myData.isCurrentTag(4));
1998        assert(myData.isCurrentTag(5));
1999        assert(myData.isCurrentTag(6));
2000    
2001        assert(myData.getTagLookup().size()==6);
2002    
2003        assert(myData.getLength()==21);
2004    
2005        DataArrayView myDataView = myData.getDataPointByTag(4);
2006        assert(myDataView==eFour.getView());
2007        assert(!myDataView.isEmpty());
2008        assert(myDataView.getOffset()==12);
2009        assert(myDataView.getRank()==1);
2010        assert(myDataView.noValues()==3);
2011        assert(myDataView.getShape().size()==1);
2012        assert(myDataView(0)==4);
2013        assert(myDataView(1)==5);
2014        assert(myDataView(2)==6);
2015    
2016        myDataView = myData.getDataPointByTag(5);
2017        assert(myDataView==eFour.getView());
2018        assert(!myDataView.isEmpty());
2019        assert(myDataView.getOffset()==15);
2020        assert(myDataView.getRank()==1);
2021        assert(myDataView.noValues()==3);
2022        assert(myDataView.getShape().size()==1);
2023        assert(myDataView(0)==4);
2024        assert(myDataView(1)==5);
2025        assert(myDataView(2)==6);
2026    
2027        myDataView = myData.getDataPointByTag(6);
2028        assert(myDataView==eFour.getView());
2029        assert(!myDataView.isEmpty());
2030        assert(myDataView.getOffset()==18);
2031        assert(myDataView.getRank()==1);
2032        assert(myDataView.noValues()==3);
2033        assert(myDataView.getShape().size()==1);
2034        assert(myDataView(0)==4);
2035        assert(myDataView(1)==5);
2036        assert(myDataView(2)==6);
2037    
2038        // use a non-existent tag so we get a pointer to
2039        // the first element of the data array
2040        double* sampleData=myData.getSampleDataByTag(9);
2041        for (int i=0; i<myData.getLength(); i++) {
2042          if (i<3) {
2043            assert(sampleData[i]==i);
2044          } else if ((i>=3) && (i<6)) {
2045            assert(sampleData[i]==i-2);
2046          } else if ((i>=6) && (i<9)) {
2047            assert(sampleData[i]==i-4);
2048          } else if ((i>=9) && (i<12)) {
2049            assert(sampleData[i]==i-6);
2050          } else if ((i>=12) && (i<15)) {
2051            assert(sampleData[i]==i-8);
2052          } else if ((i>=15) && (i<18)) {
2053            assert(sampleData[i]==i-11);
2054          } else {
2055            assert(sampleData[i]==i-14);
2056          }
2057        }
2058    
2059      }
2060    
2061      {
2062    
2063        cout << "\tTest adding three keys with three values to DataTagged with three tags." << endl;
2064    
2065        DataTagged::TagListType keys;
2066        keys.push_back(1);
2067        keys.push_back(2);
2068        keys.push_back(3);
2069    
2070        DataTagged::ValueListType values;
2071    
2072        DataArrayView::ShapeType viewShape;
2073        viewShape.push_back(3);
2074    
2075        // default value
2076        DataArrayView::ValueType viewData(3);
2077        for (int i=0;i<viewShape[0];i++) {
2078          viewData[i]=i;
2079        }
2080        DataArrayView myView(viewData,viewShape);
2081    
2082        // value for tag "1"
2083        DataArray eOne(myView);
2084        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2085          eOne.getView()(i)=i+1.0;
2086        }
2087        values.push_back(eOne.getView());
2088    
2089        // value for tag "2"
2090        DataArray eTwo(myView);
2091        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2092          eTwo.getView()(i)=i+2.0;
2093        }
2094        values.push_back(eTwo.getView());
2095    
2096        // value for tag "3"
2097        DataArray eThree(myView);
2098        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2099          eThree.getView()(i)=i+3.0;
2100        }
2101        values.push_back(eThree.getView());
2102    
2103        DataTagged myData(keys,values,myView,FunctionSpace());
2104    
2105        keys.clear();
2106        keys.push_back(4);
2107        keys.push_back(5);
2108        keys.push_back(6);
2109    
2110        values.clear();
2111    
2112        // value for tag "4"
2113        DataArray eFour(myView);
2114        for (int i=0;i<eFour.getView().getShape()[0];i++) {
2115          eFour.getView()(i)=i+4.0;
2116        }
2117        values.push_back(eFour.getView());
2118    
2119        // value for tag "5"
2120        DataArray eFive(myView);
2121        for (int i=0;i<eFive.getView().getShape()[0];i++) {
2122          eFive.getView()(i)=i+5.0;
2123        }
2124        values.push_back(eFive.getView());
2125    
2126        // value for tag "6"
2127        DataArray eSix(myView);
2128        for (int i=0;i<eSix.getView().getShape()[0];i++) {
2129          eSix.getView()(i)=i+6.0;
2130        }
2131        values.push_back(eSix.getView());
2132    
2133        myData.addTaggedValues(keys,values);
2134    
2135        assert(myData.isCurrentTag(4));
2136        assert(myData.isCurrentTag(5));
2137        assert(myData.isCurrentTag(6));
2138    
2139        assert(myData.getTagLookup().size()==6);
2140    
2141        assert(myData.getLength()==21);
2142    
2143        DataArrayView myDataView = myData.getDataPointByTag(4);
2144        assert(myDataView==eFour.getView());
2145        assert(!myDataView.isEmpty());
2146        assert(myDataView.getOffset()==12);
2147        assert(myDataView.getRank()==1);
2148        assert(myDataView.noValues()==3);
2149        assert(myDataView.getShape().size()==1);
2150        assert(myDataView(0)==4);
2151        assert(myDataView(1)==5);
2152        assert(myDataView(2)==6);
2153    
2154        myDataView = myData.getDataPointByTag(5);
2155        assert(myDataView==eFive.getView());
2156        assert(!myDataView.isEmpty());
2157        assert(myDataView.getOffset()==15);
2158        assert(myDataView.getRank()==1);
2159        assert(myDataView.noValues()==3);
2160        assert(myDataView.getShape().size()==1);
2161        assert(myDataView(0)==5);
2162        assert(myDataView(1)==6);
2163        assert(myDataView(2)==7);
2164    
2165        myDataView = myData.getDataPointByTag(6);
2166        assert(myDataView==eSix.getView());
2167        assert(!myDataView.isEmpty());
2168        assert(myDataView.getOffset()==18);
2169        assert(myDataView.getRank()==1);
2170        assert(myDataView.noValues()==3);
2171        assert(myDataView.getShape().size()==1);
2172        assert(myDataView(0)==6);
2173        assert(myDataView(1)==7);
2174        assert(myDataView(2)==8);
2175    
2176        // use a non-existent tag so we get a pointer to
2177        // the first element of the data array
2178        double* sampleData=myData.getSampleDataByTag(9);
2179        for (int i=0; i<myData.getLength(); i++) {
2180          if (i<3) {
2181            assert(sampleData[i]==i);
2182          } else if ((i>=3) && (i<6)) {
2183            assert(sampleData[i]==i-2);
2184          } else if ((i>=6) && (i<9)) {
2185            assert(sampleData[i]==i-4);
2186          } else if ((i>=9) && (i<12)) {
2187            assert(sampleData[i]==i-6);
2188          } else if ((i>=12) && (i<15)) {
2189            assert(sampleData[i]==i-8);
2190          } else if ((i>=15) && (i<18)) {
2191            assert(sampleData[i]==i-10);
2192          } else {
2193            assert(sampleData[i]==i-12);
2194          }
2195        }
2196    
2197      }
2198    
2199    }
2200    
2201    void DataTaggedTestCase::testSetTaggedValue() {
2202    
2203      cout << endl;
2204    
2205      {
2206    
2207        cout << "\tTest setting key in DataTagged with three tags." << endl;
2208    
2209        DataTagged::TagListType keys;
2210        keys.push_back(1);
2211        keys.push_back(2);
2212        keys.push_back(3);
2213    
2214        DataTagged::ValueListType values;
2215    
2216        DataArrayView::ShapeType viewShape;
2217        viewShape.push_back(3);
2218    
2219        // default value
2220        DataArrayView::ValueType viewData(3);
2221        for (int i=0;i<viewShape[0];i++) {
2222          viewData[i]=i;
2223        }
2224        DataArrayView myView(viewData,viewShape);
2225    
2226        // value for tag "1"
2227        DataArray eOne(myView);
2228        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2229          eOne.getView()(i)=i+1.0;
2230        }
2231        values.push_back(eOne.getView());
2232    
2233        // value for tag "2"
2234        DataArray eTwo(myView);
2235        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2236          eTwo.getView()(i)=i+2.0;
2237        }
2238        values.push_back(eTwo.getView());
2239    
2240        // value for tag "3"
2241        DataArray eThree(myView);
2242        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2243          eThree.getView()(i)=i+3.0;
2244        }
2245        values.push_back(eThree.getView());
2246    
2247        DataTagged myData(keys,values,myView,FunctionSpace());
2248    
2249        // new value for tag "2"
2250        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2251          eTwo.getView()(i)=i+5.0;
2252        }
2253    
2254        myData.setTaggedValue(2,eTwo.getView());
2255    
2256        assert(myData.isCurrentTag(2));
2257    
2258        assert(myData.getTagLookup().size()==3);
2259    
2260        assert(myData.getLength()==12);
2261    
2262        DataArrayView myDataView = myData.getDataPointByTag(2);
2263        assert(myDataView==eTwo.getView());
2264        assert(!myDataView.isEmpty());
2265        assert(myDataView.getOffset()==6);
2266        assert(myDataView.getRank()==1);
2267        assert(myDataView.noValues()==3);
2268        assert(myDataView.getShape().size()==1);
2269        assert(myDataView(0)==5);
2270        assert(myDataView(1)==6);
2271        assert(myDataView(2)==7);
2272    
2273        // use a non-existent tag so we get a pointer to
2274        // the first element of the data array
2275        double* sampleData=myData.getSampleDataByTag(9);
2276        for (int i=0; i<myData.getLength(); i++) {
2277          if (i<3) {
2278            assert(sampleData[i]==i);
2279          } else if ((i>=3) && (i<6)) {
2280            assert(sampleData[i]==i-2);
2281          } else if ((i>=6) && (i<9)) {
2282            assert(sampleData[i]==i-1);
2283          } else {
2284            assert(sampleData[i]==i-6);
2285          }
2286        }
2287    
2288      }
2289    
2290  }  }
2291    
2292  void DataTaggedTestCase::testAll() {  void DataTaggedTestCase::testAll() {
# Line 202  void DataTaggedTestCase::testAll() { Line 2308  void DataTaggedTestCase::testAll() {
2308      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
2309      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
2310    
2311        // data-point 0 has tag number 1 by default
2312      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
2313    
2314      assert(!myData.isCurrentTag(1));      assert(!myData.isCurrentTag(1));
# Line 237  void DataTaggedTestCase::testAll() { Line 2344  void DataTaggedTestCase::testAll() {
2344      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2345      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2346    
2347      //cout << "\tTest adding two keys with empty value list." << endl;      // use a non-existent tag so we get a pointer to
2348      //DataTagged::TagListType keys;      // the first element of the data array
2349      //DataTagged::ValueListType values;      double* sampleData=myData.getSampleDataByTag(9);
2350      //keys.push_back(1);      for (int i=0; i<myData.getLength(); i++) {
2351      //keys.push_back(2);        assert(sampleData[i]==i);
2352      //myData.addTaggedValues(keys,values);      }
2353      //for (int i=0;i<keys.size();++i) {      sampleData=myData.getSampleData(0);
2354      //  assert(myData.getPointDataView()()==0);      for (int i=0; i<myDataView.noValues(); i++) {
2355      //}        assert(sampleData[i]==i);
2356        }
2357    
2358    }    }
2359    
# Line 278  void DataTaggedTestCase::testAll() { Line 2386  void DataTaggedTestCase::testAll() {
2386      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
2387      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
2388    
2389        // data-point 0 has tag number 1 by default
2390      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
2391    
2392      assert(!myData.isCurrentTag(1));      assert(!myData.isCurrentTag(1));
# Line 322  void DataTaggedTestCase::testAll() { Line 2431  void DataTaggedTestCase::testAll() {
2431      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2432      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2433    
2434      //cout << "\tTest adding a single tag value." << endl;      // use a non-existent tag so we get a pointer to
2435      //for (int i=0;i<myView.getShape()[0];++i) {      // the first element of the data array
2436      //  myView(i)=i;      double* sampleData=myData.getSampleDataByTag(9);
2437      //}      for (int i=0; i<myData.getLength(); i++) {
2438      //values.push_back(myView);        assert(sampleData[i]==i);
2439      //keys.push_back(1);      }
2440      //myData.addTaggedValues(keys,values);      sampleData=myData.getSampleDataByTag(0);
2441      //assert(myData.getDataPointByTag(1)==myView);      for (int i=0; i<myDataView.noValues(); i++) {
2442      //cout << "\tTest addition of further tags." << endl;        assert(sampleData[i]==i);
2443      //keys.resize(0);      }
     //keys.push_back(3);  
     //for (int i=0;i<myView.getShape()[0];++i) {  
     //  myView(i)=i+1.5;  
     //}  
     //myData.addTaggedValues(keys,values);  
     //assert(myData.getDataPointByTag(3)==myView);  
     //assert(myData.getDataPointByTag(1)!=myView);  
     //cout << "\tTrigger the size mismatch exception." << endl;  
     //try {  
     //  values.push_back(myView);  
     //  myData.addTaggedValues(keys,values);  
     //  assert(false);  
     //}  
     //catch (EsysException& e) {  
     // assert(true);  
     //}  
2444    
2445    }    }
2446    
# Line 391  void DataTaggedTestCase::testAll() { Line 2484  void DataTaggedTestCase::testAll() {
2484      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
2485      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
2486    
2487        // data-point 0 has tag number 1 by default
2488      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
2489    
2490      assert(!myData.isCurrentTag(0));      assert(!myData.isCurrentTag(0));
# Line 425  void DataTaggedTestCase::testAll() { Line 2519  void DataTaggedTestCase::testAll() {
2519      assert(myDataView(2)==3);      assert(myDataView(2)==3);
2520    
2521      // Test non-existent tag returns the default value.      // Test non-existent tag returns the default value.
2522      myDataView = myData.getDataPointByTag(0);      myDataView = myData.getDataPointByTag(9);
2523      assert(myDataView==myView);      assert(myDataView==myView);
2524      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2525      assert(myDataView.getOffset()==0);      assert(myDataView.getOffset()==0);
# Line 447  void DataTaggedTestCase::testAll() { Line 2541  void DataTaggedTestCase::testAll() {
2541      assert(myDataView(1)==1);      assert(myDataView(1)==1);
2542      assert(myDataView(2)==2);      assert(myDataView(2)==2);
2543    
2544        // use a non-existent tag so we get a pointer to
2545        // the first element of the data array
2546        double* sampleData=myData.getSampleDataByTag(9);
2547        for (int i=0; i<myData.getLength(); i++) {
2548          if (i<3) {
2549            assert(sampleData[i]==i);
2550          } else {
2551            assert(sampleData[i]==i-2);
2552          }
2553        }
2554        sampleData=myData.getSampleData(0);
2555        for (int i=0; i<myDataView.noValues(); i++) {
2556          assert(sampleData[i]==i+1);
2557        }
2558    
2559    }    }
2560    
2561    {    {
# Line 505  void DataTaggedTestCase::testAll() { Line 2614  void DataTaggedTestCase::testAll() {
2614      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
2615      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
2616    
2617        // data-point 0 has tag number 1 by default
2618      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
2619    
2620      assert(!myData.isCurrentTag(0));      assert(!myData.isCurrentTag(0));
# Line 586  void DataTaggedTestCase::testAll() { Line 2696  void DataTaggedTestCase::testAll() {
2696      assert(myDataView(1)==4);      assert(myDataView(1)==4);
2697      assert(myDataView(2)==5);      assert(myDataView(2)==5);
2698    
2699      //cout << "\tTrigger bad shape in input values exception." << endl;      // use a non-existent tag so we get a pointer to
2700      //viewShape.clear();      // the first element of the data array
2701      //viewShape.push_back(1);      double* sampleData=myData.getSampleDataByTag(9);
2702      //keys.clear();      for (int i=0; i<myData.getLength(); i++) {
2703      //values.clear();        if (i<3) {
2704      //viewData.resize(1,0.0);          assert(sampleData[i]==i);
2705      //DataArrayView myView2(viewData,viewShape);        } else if ((i>=3) && (i<6)) {
2706      //try {          assert(sampleData[i]==i-2);
2707      //  myData.addTaggedValue(5,myView2);        } else if ((i>=6) && (i<9)) {
2708      //  assert(false);          assert(sampleData[i]==i-4);
2709      //}        } else {
2710      //catch (EsysException& e) {          assert(sampleData[i]==i-6);
2711      //  assert(true);        }
2712      //}      }
2713      //cout << "\tTest addTaggedValues." << endl;      sampleData=myData.getSampleData(0);
2714      //DataTagged myData2;      for (int i=0; i<myDataView.noValues(); i++) {
2715      //myData2.reshapeDataPoint(myView.getShape());        assert(sampleData[i]==i+1);
2716      //keys.clear();      }
2717      //values.clear();  
2718      //keys.push_back(1);    }
2719      //keys.push_back(2);  
2720      //keys.push_back(3);  }
2721      //values.push_back(eOne.getView());  
2722      //values.push_back(eTwo.getView());  void DataTaggedTestCase::testCopyConstructors() {
2723      //values.push_back(eThree.getView());  
2724      //myData2.addTaggedValues(keys,values);    cout << endl;
2725      //assert(myData2.getDataPointByTag(1)==eOne.getView());  
2726      //assert(myData2.getDataPointByTag(2)==eTwo.getView());    {
2727      //assert(myData2.getDataPointByTag(3)==eThree.getView());  
2728      //cout << "\tTest setTaggedValue." << endl;      cout << "\tTest DataTagged copy constructor for DataTagged with multiple tags." << endl;
2729      //DataTagged myData3;  
2730      //myData3.reshapeDataPoint(myView.getShape());      // the one data-point has tag value "1"
2731      //myData3.addTaggedValue(1,eThree.getView());  
2732      //myData3.addTaggedValue(2,eOne.getView());      DataTagged::TagListType keys;
2733      //myData3.addTaggedValue(3,eTwo.getView());      keys.push_back(1);
2734      //myData3.setTaggedValue(1,eOne.getView());      keys.push_back(2);
2735      //myData3.setTaggedValue(2,eTwo.getView());      keys.push_back(3);
2736      //myData3.setTaggedValue(3,eThree.getView());  
2737      //assert(myData3.getDataPointByTag(1)==eOne.getView());      DataTagged::ValueListType values;
2738      //assert(myData3.getDataPointByTag(2)==eTwo.getView());  
2739      //assert(myData3.getDataPointByTag(3)==eThree.getView());      DataArrayView::ShapeType viewShape;
2740        viewShape.push_back(3);
2741    
2742        // default value
2743        DataArrayView::ValueType viewData(3);
2744        for (int i=0;i<viewShape[0];i++) {
2745          viewData[i]=i;
2746        }
2747        DataArrayView myView(viewData,viewShape);
2748    
2749        // value for tag "1"
2750        DataArray eOne(myView);
2751        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2752          eOne.getView()(i)=i+1.0;
2753        }
2754        values.push_back(eOne.getView());
2755    
2756        // value for tag "2"
2757        DataArray eTwo(myView);
2758        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2759          eTwo.getView()(i)=i+2.0;
2760        }
2761        values.push_back(eTwo.getView());
2762    
2763        // value for tag "3"
2764        DataArray eThree(myView);
2765        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2766          eThree.getView()(i)=i+3.0;
2767        }
2768        values.push_back(eThree.getView());
2769    
2770        DataTagged myData(keys,values,myView,FunctionSpace());
2771    
2772        DataTagged myDataCopy(myData);
2773    
2774        //cout << myDataCopy.toString() << endl;
2775    
2776        assert(myDataCopy.getNumSamples()==1);
2777        assert(myDataCopy.getNumDPPSample()==1);
2778    
2779        assert(myDataCopy.validSamplePointNo(0));
2780        assert(myDataCopy.validSampleNo(0));
2781        assert(!myDataCopy.validSamplePointNo(1));
2782        assert(!myDataCopy.validSampleNo(1));
2783    
2784        // data-point 0 has tag number 1 by default
2785        assert(myDataCopy.getTagNumber(0)==1);
2786    
2787        assert(!myDataCopy.isCurrentTag(0));
2788        assert(myDataCopy.isCurrentTag(1));
2789        assert(myDataCopy.isCurrentTag(2));
2790        assert(myDataCopy.isCurrentTag(3));
2791    
2792        assert(myDataCopy.getTagLookup().size()==3);
2793    
2794        assert(myDataCopy.getLength()==12);
2795    
2796        assert(myDataCopy.getPointOffset(0,0)==3);
2797    
2798        DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
2799        assert(myDataView==eOne.getView());
2800        assert(!myDataView.isEmpty());
2801        assert(myDataView.getOffset()==3);
2802        assert(myDataView.getRank()==1);
2803        assert(myDataView.noValues()==3);
2804        assert(myDataView.getShape().size()==1);
2805        assert(myDataView(0)==1);
2806        assert(myDataView(1)==2);
2807        assert(myDataView(2)==3);
2808    
2809        myDataView = myDataCopy.getDataPointByTag(1);
2810        assert(myDataView==eOne.getView());
2811        assert(!myDataView.isEmpty());
2812        assert(myDataView.getOffset()==3);
2813        assert(myDataView.getRank()==1);
2814        assert(myDataView.noValues()==3);
2815        assert(myDataView.getShape().size()==1);
2816        assert(myDataView(0)==1);
2817        assert(myDataView(1)==2);
2818        assert(myDataView(2)==3);
2819    
2820        // Test non-existent tag returns the default value.
2821        myDataView = myDataCopy.getDataPointByTag(0);
2822        assert(myDataView==myView);
2823        assert(!myDataView.isEmpty());
2824        assert(myDataView.getOffset()==0);
2825        assert(myDataView.getRank()==1);
2826        assert(myDataView.noValues()==3);
2827        assert(myDataView.getShape().size()==1);
2828        assert(myDataView(0)==0);
2829        assert(myDataView(1)==1);
2830        assert(myDataView(2)==2);
2831    
2832        myDataView = myDataCopy.getDefaultValue();
2833        assert(myDataView==myView);
2834        assert(!myDataView.isEmpty());
2835        assert(myDataView.getOffset()==0);
2836        assert(myDataView.getRank()==1);
2837        assert(myDataView.noValues()==3);
2838        assert(myDataView.getShape().size()==1);
2839        assert(myDataView(0)==0);
2840        assert(myDataView(1)==1);
2841        assert(myDataView(2)==2);
2842    
2843        // Test data-points held for remaining tags
2844        myDataView = myDataCopy.getDataPointByTag(2);
2845        assert(myDataView==eTwo.getView());
2846        assert(!myDataView.isEmpty());
2847        assert(myDataView.getOffset()==6);
2848        assert(myDataView.getRank()==1);
2849        assert(myDataView.noValues()==3);
2850        assert(myDataView.getShape().size()==1);
2851        assert(myDataView(0)==2);
2852        assert(myDataView(1)==3);
2853        assert(myDataView(2)==4);
2854    
2855        myDataView = myDataCopy.getDataPointByTag(3);
2856        assert(myDataView==eThree.getView());
2857        assert(!myDataView.isEmpty());
2858        assert(myDataView.getOffset()==9);
2859        assert(myDataView.getRank()==1);
2860        assert(myDataView.noValues()==3);
2861        assert(myDataView.getShape().size()==1);
2862        assert(myDataView(0)==3);
2863        assert(myDataView(1)==4);
2864        assert(myDataView(2)==5);
2865    
2866        // use a non-existent tag so we get a pointer to
2867        // the first element of the data array
2868        double* sampleData=myDataCopy.getSampleDataByTag(9);
2869        for (int i=0; i<myData.getLength(); i++) {
2870          if (i<3) {
2871            assert(sampleData[i]==i);
2872          } else if ((i>=3) && (i<6)) {
2873            assert(sampleData[i]==i-2);
2874          } else if ((i>=6) && (i<9)) {
2875            assert(sampleData[i]==i-4);
2876          } else {
2877            assert(sampleData[i]==i-6);
2878          }
2879        }
2880    
2881      }
2882    
2883      {
2884    
2885        cout << "\tTest DataTagged copy constructor for DataConstant." << endl;
2886    
2887        // Create a DataConstant
2888        DataArrayView::ShapeType shape;
2889        DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
2890        DataArrayView pointData(data,shape);
2891        pointData()=1.0;
2892        DataConstant myConstantData(pointData, FunctionSpace());
2893    
2894        // use this DataConstant to initialise a DataTagged
2895        DataTagged myData(myConstantData);
2896    
2897        //cout << myData.toString() << endl;
2898    
2899        assert(myData.getNumSamples()==1);
2900        assert(myData.getNumDPPSample()==1);
2901    
2902        assert(myData.validSamplePointNo(0));
2903        assert(myData.validSampleNo(0));
2904        assert(!myData.validSamplePointNo(1));
2905        assert(!myData.validSampleNo(1));
2906    
2907        // data-point 0 has tag number 1 by default
2908        assert(myData.getTagNumber(0)==1);
2909    
2910        assert(!myData.isCurrentTag(1));
2911    
2912        assert(myData.getTagLookup().size()==0);
2913    
2914        assert(myData.getLength()==1);
2915    
2916        assert(myData.getPointOffset(0,0)==0);
2917    
2918        DataArrayView myDataView = myData.getDataPoint(0,0);
2919        assert(!myDataView.isEmpty());
2920        assert(myDataView.getOffset()==0);
2921        assert(myDataView.getRank()==0);
2922        assert(myDataView.noValues()==1);
2923        assert(myDataView.getShape().size()==0);
2924        assert(myDataView()==1.0);
2925    
2926        // Test non-existent tag returns the default value.
2927        myDataView = myData.getDataPointByTag(1);
2928        assert(!myDataView.isEmpty());
2929        assert(myDataView.getOffset()==0);
2930        assert(myDataView.getRank()==0);
2931        assert(myDataView.noValues()==1);
2932        assert(myDataView.getShape().size()==0);
2933        assert(myDataView()==1.0);
2934    
2935        myDataView = myData.getDefaultValue();
2936        assert(!myDataView.isEmpty());
2937        assert(myDataView.getOffset()==0);
2938        assert(myDataView.getRank()==0);
2939        assert(myDataView.noValues()==1);
2940        assert(myDataView.getShape().size()==0);
2941        assert(myDataView()==1.0);
2942    
2943        // use a non-existent tag so we get a pointer to
2944        // the first element of the data array
2945        double* sampleData=myData.getSampleDataByTag(9);
2946        for (int i=0; i<myData.getLength(); i++) {
2947          assert(sampleData[i]==i+1);
2948        }
2949    
2950      }
2951    
2952    }
2953    
2954    void DataTaggedTestCase::testGetSlice() {
2955    
2956      cout << endl;
2957    
2958      {
2959    
2960        cout << "\tTest slicing default DataTagged." << endl;
2961    
2962        DataTagged myData;
2963    
2964        DataArrayView::RegionType region;
2965    
2966        DataAbstract* slicedDefault = myData.getSlice(region);
2967    
2968        // cout << slicedDefault->toString() << endl;
2969    
2970        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
2971    
2972        assert(myDataSliced->getTagLookup().size()==0);
2973    
2974        assert(myDataSliced->getLength()==1);
2975    
2976        DataArrayView myDataView = myDataSliced->getDefaultValue();
2977        assert(!myDataView.isEmpty());
2978        assert(myDataView.getOffset()==0);
2979        assert(myDataView.getRank()==0);
2980        assert(myDataView.noValues()==1);
2981        assert(myDataView.getShape().size()==0);
2982        assert(myDataView()==0.0);
2983    
2984      }
2985    
2986      {
2987    
2988        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
2989    
2990        DataArrayView::ShapeType viewShape;
2991        viewShape.push_back(3);
2992    
2993        DataTagged::TagListType keys;
2994    
2995        DataTagged::ValueListType values;
2996    
2997        DataArrayView::ValueType viewData(3);
2998        for (int i=0;i<viewShape[0];i++) {
2999          viewData[i]=i;
3000        }
3001        DataArrayView myView(viewData,viewShape);
3002    
3003        DataTagged myData(keys,values,myView,FunctionSpace());
3004    
3005        // full slice
3006    
3007        std::pair<int, int> region_element;
3008        region_element.first=0;
3009        region_element.second=3;
3010        DataArrayView::RegionType region;
3011        region.push_back(region_element);
3012    
3013        DataAbstract* slicedDefault = myData.getSlice(region);
3014    
3015        //cout << slicedDefault->toString() << endl;
3016    
3017        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3018    
3019        assert(myDataSliced->getTagLookup().size()==0);
3020    
3021        assert(myDataSliced->getLength()==3);
3022    
3023        DataArrayView myDataView = myDataSliced->getDefaultValue();
3024        assert(!myDataView.isEmpty());
3025        assert(myDataView.getOffset()==0);
3026        assert(myDataView.getRank()==1);
3027        assert(myDataView.noValues()==3);
3028        assert(myDataView.getShape().size()==1);
3029        assert(myDataView(0)==0.0);
3030        assert(myDataView(1)==1.0);
3031        assert(myDataView(2)==2.0);
3032    
3033        // scalar slice
3034    
3035        region.clear();
3036        region_element.first=0;
3037        region_element.second=0;
3038        region.push_back(region_element);
3039    
3040        slicedDefault = myData.getSlice(region);
3041    
3042        //cout << slicedDefault->toString() << endl;
3043    
3044        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3045    
3046        assert(myDataSliced->getTagLookup().size()==0);
3047    
3048        assert(myDataSliced->getLength()==1);
3049    
3050        myDataView = myDataSliced->getDefaultValue();
3051        assert(!myDataView.isEmpty());
3052        assert(myDataView.getOffset()==0);
3053        assert(myDataView.getRank()==0);
3054        assert(myDataView.noValues()==1);
3055        assert(myDataView.getShape().size()==0);
3056        assert(myDataView()==0.0);
3057    
3058      }
3059    
3060      {
3061    
3062        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
3063    
3064        DataArrayView::ShapeType viewShape;
3065        viewShape.push_back(3);
3066        viewShape.push_back(3);
3067        viewShape.push_back(3);
3068    
3069        DataTagged::TagListType keys;
3070    
3071        DataTagged::ValueListType values;
3072    
3073        DataArrayView::ValueType viewData(27);
3074        for (int i=0;i<viewData.size();i++) {
3075          viewData[i]=i;
3076        }
3077        DataArrayView myView(viewData,viewShape);
3078    
3079        DataTagged myData(keys,values,myView,FunctionSpace());
3080    
3081        //cout << myData.toString() << endl;
3082    
3083        // full slice
3084    
3085        std::pair<int, int> region_element;
3086        region_element.first=0;
3087        region_element.second=3;
3088        DataArrayView::RegionType region;
3089        region.push_back(region_element);
3090        region.push_back(region_element);
3091        region.push_back(region_element);
3092    
3093        DataAbstract* slicedDefault = myData.getSlice(region);
3094    
3095        //cout << slicedDefault->toString() << endl;
3096    
3097        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3098    
3099        assert(myDataSliced->getTagLookup().size()==0);
3100    
3101        assert(myDataSliced->getLength()==27);
3102    
3103        DataArrayView myDataView = myDataSliced->getDefaultValue();
3104        assert(!myDataView.isEmpty());
3105        assert(myDataView.getOffset()==0);
3106        assert(myDataView.getRank()==3);
3107        assert(myDataView.noValues()==27);
3108        assert(myDataView.getShape().size()==3);
3109    
3110        // rank 1 slice
3111    
3112        region.clear();
3113        region.push_back(region_element);
3114        region_element.second=0;
3115        region.push_back(region_element);
3116        region.push_back(region_element);
3117    
3118        slicedDefault = myData.getSlice(region);
3119    
3120        //cout << slicedDefault->toString() << endl;
3121    
3122        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3123    
3124        assert(myDataSliced->getTagLookup().size()==0);
3125    
3126        assert(myDataSliced->getLength()==3);
3127    
3128        myDataView = myDataSliced->getDefaultValue();
3129        assert(!myDataView.isEmpty());
3130        assert(myDataView.getOffset()==0);
3131        assert(myDataView.getRank()==1);
3132        assert(myDataView.noValues()==3);
3133        assert(myDataView.getShape().size()==1);
3134        assert(myDataView(0)==0.0);
3135        assert(myDataView(1)==1.0);
3136        assert(myDataView(2)==2.0);
3137    
3138        // scalar slice
3139    
3140        region.clear();
3141        region_element.first=2;
3142        region_element.second=2;
3143        region.push_back(region_element);
3144        region.push_back(region_element);
3145        region.push_back(region_element);
3146    
3147        slicedDefault = myData.getSlice(region);
3148    
3149        //cout << slicedDefault->toString() << endl;
3150    
3151        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3152    
3153        assert(myDataSliced->getTagLookup().size()==0);
3154    
3155        assert(myDataSliced->getLength()==1);
3156    
3157        myDataView = myDataSliced->getDefaultValue();
3158        assert(!myDataView.isEmpty());
3159        assert(myDataView.getOffset()==0);
3160        assert(myDataView.getRank()==0);
3161        assert(myDataView.noValues()==1);
3162        assert(myDataView.getShape().size()==0);
3163        assert(myDataView()==26);
3164    
3165      }
3166    
3167      {
3168    
3169        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
3170    
3171        DataTagged::TagListType keys;
3172        keys.push_back(1);
3173    
3174        DataTagged::ValueListType values;
3175    
3176        DataArrayView::ShapeType viewShape;
3177    
3178        // default value
3179        DataArrayView::ValueType viewData(1);
3180        viewData[0]=0.0;
3181        DataArrayView myView(viewData,viewShape);
3182    
3183        // value for tag "1"
3184        DataArray eOne(myView);
3185        eOne.getView()()=1.0;
3186        values.push_back(eOne.getView());
3187    
3188        DataTagged myData(keys,values,myView,FunctionSpace());
3189    
3190        //cout << myData.toString() << endl;
3191    
3192        // full slice
3193    
3194        DataArrayView::RegionType region;
3195    
3196        DataAbstract* slicedDefault = myData.getSlice(region);
3197    
3198        //cout << slicedDefault->toString() << endl;
3199    
3200        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3201    
3202        assert(myDataSliced->getTagLookup().size()==1);
3203    
3204        assert(myDataSliced->getLength()==2);
3205    
3206        DataArrayView myDataView = myDataSliced->getDefaultValue();
3207        assert(!myDataView.isEmpty());
3208        assert(myDataView.getOffset()==0);
3209        assert(myDataView.getRank()==0);
3210        assert(myDataView.noValues()==1);
3211        assert(myDataView.getShape().size()==0);
3212        assert(myDataView()==0);
3213    
3214        myDataView = myDataSliced->getDataPointByTag(1);
3215        assert(!myDataView.isEmpty());
3216        assert(myDataView.getOffset()==1);
3217        assert(myDataView.getRank()==0);
3218        assert(myDataView.noValues()==1);
3219        assert(myDataView.getShape().size()==0);
3220        assert(myDataView()==1);
3221    
3222      }
3223    
3224      {
3225    
3226        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
3227    
3228        DataArrayView::ShapeType viewShape;
3229        viewShape.push_back(3);
3230    
3231        DataTagged::TagListType keys;
3232        keys.push_back(1);
3233    
3234        DataTagged::ValueListType values;
3235    
3236        // default value
3237        DataArrayView::ValueType viewData(3);
3238        for (int i=0;i<viewShape[0];i++) {
3239          viewData[i]=i;
3240        }
3241        DataArrayView myView(viewData,viewShape);
3242    
3243        // value for tag "1"
3244        DataArray eOne(myView);
3245        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3246          eOne.getView()(i)=i+3.0;
3247        }
3248        values.push_back(eOne.getView());
3249    
3250        DataTagged myData(keys,values,myView,FunctionSpace());
3251    
3252        //cout << myData.toString() << endl;
3253    
3254        // full slice
3255    
3256        std::pair<int, int> region_element;
3257        region_element.first=0;
3258        region_element.second=3;
3259        DataArrayView::RegionType region;
3260        region.push_back(region_element);
3261    
3262        DataAbstract* slicedDefault = myData.getSlice(region);
3263    
3264        //cout << slicedDefault->toString() << endl;
3265    
3266        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3267    
3268        assert(myDataSliced->getTagLookup().size()==1);
3269    
3270        assert(myDataSliced->getLength()==6);
3271    
3272        DataArrayView myDataView = myDataSliced->getDefaultValue();
3273        assert(!myDataView.isEmpty());
3274        assert(myDataView.getOffset()==0);
3275        assert(myDataView.getRank()==1);
3276        assert(myDataView.noValues()==3);
3277        assert(myDataView.getShape().size()==1);
3278        assert(myDataView(0)==0);
3279        assert(myDataView(1)==1);
3280        assert(myDataView(2)==2);
3281    
3282        myDataView = myDataSliced->getDataPointByTag(1);
3283        assert(!myDataView.isEmpty());
3284        assert(myDataView.getOffset()==3);
3285        assert(myDataView.getRank()==1);
3286        assert(myDataView.noValues()==3);
3287        assert(myDataView.getShape().size()==1);
3288        assert(myDataView(0)==3);
3289        assert(myDataView(1)==4);
3290        assert(myDataView(2)==5);
3291    
3292        // scalar slice
3293    
3294        region_element.first=1;
3295        region_element.second=1;
3296        region.clear();
3297        region.push_back(region_element);
3298    
3299        slicedDefault = myData.getSlice(region);
3300    
3301        //cout << slicedDefault->toString() << endl;
3302    
3303        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3304    
3305        assert(myDataSliced->getTagLookup().size()==1);
3306    
3307        assert(myDataSliced->getLength()==2);
3308    
3309        myDataView = myDataSliced->getDefaultValue();
3310        assert(!myDataView.isEmpty());
3311        assert(myDataView.getOffset()==0);
3312        assert(myDataView.getRank()==0);
3313        assert(myDataView.noValues()==1);
3314        assert(myDataView.getShape().size()==0);
3315        assert(myDataView()==1);
3316    
3317        myDataView = myDataSliced->getDataPointByTag(1);
3318        assert(!myDataView.isEmpty());
3319        assert(myDataView.getOffset()==1);
3320        assert(myDataView.getRank()==0);
3321        assert(myDataView.noValues()==1);
3322        assert(myDataView.getShape().size()==0);
3323        assert(myDataView()==4);
3324    
3325      }
3326    
3327      {
3328    
3329        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
3330    
3331        DataArrayView::ShapeType viewShape;
3332        viewShape.push_back(3);
3333        viewShape.push_back(3);
3334        viewShape.push_back(3);
3335    
3336        DataTagged::TagListType keys;
3337        keys.push_back(1);
3338    
3339        DataTagged::ValueListType values;
3340    
3341        // default value
3342        DataArrayView::ValueType viewData(27);
3343        for (int i=0;i<viewData.size();i++) {
3344          viewData[i]=i;
3345        }
3346        DataArrayView myView(viewData,viewShape);
3347    
3348        // value for tag "1"
3349        DataArrayView::ValueType viewData1(27);
3350        for (int i=0;i<viewData1.size();i++) {
3351          viewData1[i]=i+27.0;
3352        }
3353        DataArrayView myView1(viewData1,viewShape);
3354        values.push_back(myView1);
3355    
3356        DataTagged myData(keys,values,myView,FunctionSpace());
3357    
3358        //cout << myData.toString() << endl;
3359    
3360        // full slice
3361    
3362        std::pair<int, int> region_element;
3363        region_element.first=0;
3364        region_element.second=3;
3365        DataArrayView::RegionType region;
3366        region.push_back(region_element);
3367        region.push_back(region_element);
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()==54);
3379    
3380        DataArrayView myDataView = myDataSliced->getDefaultValue();
3381        assert(!myDataView.isEmpty());
3382        assert(myDataView.getOffset()==0);
3383        assert(myDataView.getRank()==3);
3384        assert(myDataView.noValues()==27);
3385        assert(myDataView.getShape().size()==3);
3386    
3387        myDataView = myDataSliced->getDataPointByTag(1);
3388        assert(!myDataView.isEmpty());
3389        assert(myDataView.getOffset()==27);
3390        assert(myDataView.getRank()==3);
3391        assert(myDataView.noValues()==27);
3392        assert(myDataView.getShape().size()==3);
3393    
3394        // rank 1 slice
3395    
3396        region.clear();
3397        region.push_back(region_element);
3398        region_element.second=0;
3399        region.push_back(region_element);
3400        region.push_back(region_element);
3401    
3402        slicedDefault = myData.getSlice(region);
3403    
3404        //cout << slicedDefault->toString() << endl;
3405    
3406        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3407    
3408        assert(myDataSliced->getTagLookup().size()==1);
3409    
3410        assert(myDataSliced->getLength()==6);
3411    
3412        myDataView = myDataSliced->getDefaultValue();
3413        assert(!myDataView.isEmpty());
3414        assert(myDataView.getOffset()==0);
3415        assert(myDataView.getRank()==1);
3416        assert(myDataView.noValues()==3);
3417        assert(myDataView.getShape().size()==1);
3418        assert(myDataView(0)==0);
3419        assert(myDataView(1)==1);
3420        assert(myDataView(2)==2);
3421    
3422        myDataView = myDataSliced->getDataPointByTag(1);
3423        assert(!myDataView.isEmpty());
3424        assert(myDataView.getOffset()==3);
3425        assert(myDataView.getRank()==1);
3426        assert(myDataView.noValues()==3);
3427        assert(myDataView.getShape().size()==1);
3428        assert(myDataView(0)==27);
3429        assert(myDataView(1)==28);
3430        assert(myDataView(2)==29);
3431    
3432        // scalar slice
3433    
3434        region_element.first=1;
3435        region_element.second=1;
3436        region.clear();
3437        region.push_back(region_element);
3438        region.push_back(region_element);
3439        region.push_back(region_element);
3440    
3441        slicedDefault = myData.getSlice(region);
3442    
3443        //cout << slicedDefault->toString() << endl;
3444    
3445        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3446    
3447        assert(myDataSliced->getTagLookup().size()==1);
3448    
3449        assert(myDataSliced->getLength()==2);
3450    
3451        myDataView = myDataSliced->getDefaultValue();
3452        assert(!myDataView.isEmpty());
3453        assert(myDataView.getOffset()==0);
3454        assert(myDataView.getRank()==0);
3455        assert(myDataView.noValues()==1);
3456        assert(myDataView.getShape().size()==0);
3457        assert(myDataView()==13);
3458    
3459        myDataView = myDataSliced->getDataPointByTag(1);
3460        assert(!myDataView.isEmpty());
3461        assert(myDataView.getOffset()==1);
3462        assert(myDataView.getRank()==0);
3463        assert(myDataView.noValues()==1);
3464        assert(myDataView.getShape().size()==0);
3465        assert(myDataView()==40);
3466    
3467      }
3468    
3469      {
3470    
3471        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
3472    
3473        DataTagged::TagListType keys;
3474        keys.push_back(1);
3475        keys.push_back(2);
3476        keys.push_back(3);
3477    
3478        DataTagged::ValueListType values;
3479    
3480        DataArrayView::ShapeType viewShape;
3481    
3482        // default value
3483        DataArrayView::ValueType viewData(1);
3484        viewData[0]=0.0;
3485        DataArrayView myView(viewData,viewShape);
3486    
3487        // value for tag "1"
3488        DataArray eOne(myView);
3489        eOne.getView()()=1.0;
3490        values.push_back(eOne.getView());
3491    
3492        // value for tag "2"
3493        DataArray eTwo(myView);
3494        eTwo.getView()()=2.0;
3495        values.push_back(eTwo.getView());
3496    
3497        // value for tag "3"
3498        DataArray eThree(myView);
3499        eThree.getView()()=3.0;
3500        values.push_back(eThree.getView());
3501    
3502        DataTagged myData(keys,values,myView,FunctionSpace());
3503    
3504        // cout << myData.toString() << endl;
3505    
3506        // full slice
3507    
3508        DataArrayView::RegionType region;
3509    
3510        DataAbstract* slicedDefault = myData.getSlice(region);
3511    
3512        //cout << slicedDefault->toString() << endl;
3513    
3514        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3515    
3516        assert(myDataSliced->getTagLookup().size()==3);
3517    
3518        assert(myDataSliced->getLength()==4);
3519    
3520        DataArrayView myDataView = myDataSliced->getDefaultValue();
3521        assert(!myDataView.isEmpty());
3522        assert(myDataView.getOffset()==0);
3523        assert(myDataView.getRank()==0);
3524        assert(myDataView.noValues()==1);
3525        assert(myDataView.getShape().size()==0);
3526        assert(myDataView()==0);
3527    
3528        myDataView = myDataSliced->getDataPointByTag(1);
3529        assert(!myDataView.isEmpty());
3530        assert(myDataView.getOffset()==1);
3531        assert(myDataView.getRank()==0);
3532        assert(myDataView.noValues()==1);
3533        assert(myDataView.getShape().size()==0);
3534        assert(myDataView()==1);
3535    
3536        myDataView = myDataSliced->getDataPointByTag(2);
3537        assert(!myDataView.isEmpty());
3538        assert(myDataView.getOffset()==2);
3539        assert(myDataView.getRank()==0);
3540        assert(myDataView.noValues()==1);
3541        assert(myDataView.getShape().size()==0);
3542        assert(myDataView()==2);
3543    
3544        myDataView = myDataSliced->getDataPointByTag(3);
3545        assert(!myDataView.isEmpty());
3546        assert(myDataView.getOffset()==3);
3547        assert(myDataView.getRank()==0);
3548        assert(myDataView.noValues()==1);
3549        assert(myDataView.getShape().size()==0);
3550        assert(myDataView()==3);
3551    
3552      }
3553    
3554      {
3555    
3556        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
3557    
3558        DataArrayView::ShapeType viewShape;
3559        viewShape.push_back(3);
3560    
3561        DataTagged::TagListType keys;
3562        keys.push_back(1);
3563        keys.push_back(2);
3564        keys.push_back(3);
3565    
3566        DataTagged::ValueListType values;
3567    
3568        // default value
3569        DataArrayView::ValueType viewData(3);
3570        for (int i=0;i<viewShape[0];i++) {
3571          viewData[i]=i;
3572        }
3573        DataArrayView myView(viewData,viewShape);
3574    
3575        // value for tag "1"
3576        DataArray eOne(myView);
3577        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3578          eOne.getView()(i)=i+3.0;
3579        }
3580        values.push_back(eOne.getView());
3581    
3582        // value for tag "2"
3583        DataArray eTwo(myView);
3584        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
3585          eTwo.getView()(i)=i+6.0;
3586        }
3587        values.push_back(eTwo.getView());
3588