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

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

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

trunk/escript/test/DataTagged/DataTaggedTestCase.cpp revision 497 by jgs, Tue Feb 7 01:28:01 2006 UTC branches/ROBW_XPLATFORM/escript/test/DataTagged/DataTaggedTestCase.cpp revision 622 by robwdcock, Wed Mar 22 14:00:08 2006 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2    
3  /*  /*
4   *****************************************************************************   *****************************************************************************
5   *                                                                           *   *                                                                           *
# Line 16  Line 17 
17  #include "EsysException.h"  #include "EsysException.h"
18    
19  #include "DataTagged.h"  #include "DataTagged.h"
20    #include "DataConstant.h"
21    
22  #include "DataTaggedTestCase.h"  #include "DataTaggedTestCase.h"
23    
# Line 50  void DataTaggedTestCase::testReshape() { Line 52  void DataTaggedTestCase::testReshape() {
52    cout << endl;    cout << endl;
53    
54    {    {
55      cout << "\tTest reshape of default constructed DataTagged to rank 1." << endl;  
56      DataTagged value;      cout << "\tTest rank 1 reshape of default DataTagged." << endl;
57      value.getPointDataView()()=1.0;  
58        DataTagged myData;
59        myData.getPointDataView()()=1.0;
60    
61      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
62      shape.push_back(2);      shape.push_back(2);
63      value.reshapeDataPoint(shape);  
64      for (int i=0;i<shape[0];++i) {      myData.reshapeDataPoint(shape);
65        assert(value.getDefaultValue()(i)==1);  
66        for (int i=0;i<shape[0];i++) {
67          assert(myData.getDefaultValue()(i)==1);
68      }      }
69    
70        //cout << myData.toString() << endl;
71    
72        assert(myData.getNumSamples()==1);
73        assert(myData.getNumDPPSample()==1);
74    
75        assert(myData.validSamplePointNo(0));
76        assert(myData.validSampleNo(0));
77        assert(!myData.validSamplePointNo(1));
78        assert(!myData.validSampleNo(1));
79    
80        // data-point 0 has tag number 1 by default
81        assert(myData.getTagNumber(0)==1);
82    
83        assert(!myData.isCurrentTag(1));
84    
85        assert(myData.getTagLookup().size()==0);
86    
87        assert(myData.getLength()==2);
88    
89        assert(myData.getPointOffset(0,0)==0);
90    
91        DataArrayView myDataView = myData.getDataPoint(0,0);
92        assert(!myDataView.isEmpty());
93        assert(myDataView.getOffset()==0);
94        assert(myDataView.getRank()==1);
95        assert(myDataView.noValues()==2);
96        assert(myDataView.getShape().size()==1);
97        assert(myDataView(0)==1.0);
98        assert(myDataView(1)==1.0);
99    
100        // Test non-existent tag returns the default value.
101        myDataView = myData.getDataPointByTag(1);
102        assert(!myDataView.isEmpty());
103        assert(myDataView.getOffset()==0);
104        assert(myDataView.getRank()==1);
105        assert(myDataView.noValues()==2);
106        assert(myDataView.getShape().size()==1);
107        assert(myDataView(0)==1.0);
108        assert(myDataView(1)==1.0);
109    
110        myDataView = myData.getDefaultValue();
111        assert(!myDataView.isEmpty());
112        assert(myDataView.getOffset()==0);
113        assert(myDataView.getRank()==1);
114        assert(myDataView.noValues()==2);
115        assert(myDataView.getShape().size()==1);
116        assert(myDataView(0)==1.0);
117        assert(myDataView(1)==1.0);
118    
119        // use a non-existent tag so we get a pointer to
120        // the first element of the data array
121        double* sampleData=myData.getSampleDataByTag(9);
122        for (int i=0; i<myData.getLength(); i++) {
123          assert(sampleData[i]==1.0);
124        }
125    
126    }    }
127    
128    {    {
129      cout << "\tTest reshape of default constructed DataTagged to rank 2." << endl;  
130      DataTagged value;      cout << "\tTest rank 2 reshape of DataTagged with one tag." << endl;
131      value.getPointDataView()()=0.0;  
132      DataArray vOne(1.0);      DataTagged::TagListType keys;
133      DataArray vTwo(2.0);      keys.push_back(1);
134      value.addTaggedValue(1,vOne.getView());  
135      value.addTaggedValue(2,vTwo.getView());      DataTagged::ValueListType values;
136    
137        DataArrayView::ShapeType viewShape;
138    
139        // default value
140        DataArrayView::ValueType viewData(1);
141        viewData[0]=1.0;
142        DataArrayView myView(viewData,viewShape);
143    
144        // value for tag "1"
145        DataArray eOne(myView);
146        eOne.getView()()=2.0;
147        values.push_back(eOne.getView());
148    
149        DataTagged myData(keys,values,myView,FunctionSpace());
150    
151      DataArrayView::ShapeType shape;      DataArrayView::ShapeType shape;
152      shape.push_back(2);      shape.push_back(2);
153      shape.push_back(5);      shape.push_back(5);
154      value.reshapeDataPoint(shape);  
155      for (int j=0;j<shape[1];++j) {      myData.reshapeDataPoint(shape);
156        for (int i=0;i<shape[0];++i) {  
157      assert(value.getDefaultValue()(i,j)==0.0);      //cout << myData.toString() << endl;
158      assert(value.getDataPointByTag(1)(i,j)==vOne.getView()());  
159      assert(value.getDataPointByTag(2)(i,j)==vTwo.getView()());      assert(myData.getNumSamples()==1);
160        assert(myData.getNumDPPSample()==1);
161    
162        assert(myData.validSamplePointNo(0));
163        assert(myData.validSampleNo(0));
164        assert(!myData.validSamplePointNo(1));
165        assert(!myData.validSampleNo(1));
166    
167        // data-point 0 has tag number 1 by default
168        assert(myData.getTagNumber(0)==1);
169    
170        assert(myData.isCurrentTag(1));
171    
172        assert(myData.getTagLookup().size()==1);
173    
174        assert(myData.getLength()==20);
175    
176        assert(myData.getPointOffset(0,0)==10);
177    
178        DataArrayView myDataView = myData.getDataPoint(0,0);
179        assert(!myDataView.isEmpty());
180        assert(myDataView.getOffset()==10);
181        assert(myDataView.getRank()==2);
182        assert(myDataView.noValues()==10);
183        assert(myDataView.getShape().size()==2);
184        for (int j=0;j<shape[1];j++) {
185          for (int i=0;i<shape[0];i++) {
186            assert(myDataView(i,j)==2.0);
187          }
188        }
189    
190        myDataView = myData.getDataPointByTag(1);
191        assert(!myDataView.isEmpty());
192        assert(myDataView.getOffset()==10);
193        assert(myDataView.getRank()==2);
194        assert(myDataView.noValues()==10);
195        assert(myDataView.getShape().size()==2);
196        for (int j=0;j<shape[1];j++) {
197          for (int i=0;i<shape[0];i++) {
198            assert(myDataView(i,j)==2.0);
199          }
200        }
201    
202        myDataView = myData.getDefaultValue();
203        assert(!myDataView.isEmpty());
204        assert(myDataView.getOffset()==0);
205        assert(myDataView.getRank()==2);
206        assert(myDataView.noValues()==10);
207        assert(myDataView.getShape().size()==2);
208        for (int j=0;j<shape[1];j++) {
209          for (int i=0;i<shape[0];i++) {
210            assert(myDataView(i,j)==1.0);
211        }        }
212      }      }
213    
214        // use a non-existent tag so we get a pointer to
215        // the first element of the data array
216        double* sampleData=myData.getSampleDataByTag(9);
217        for (int i=0; i<myData.getLength(); i++) {
218          if (i<10) {
219            assert(sampleData[i]==1.0);
220          } else {
221            assert(sampleData[i]==2.0);
222          }
223        }
224    
225    }    }
226    
227      {
228    
229        cout << "\tTest rank 3 reshape of DataTagged with three tags." << endl;
230    
231        DataTagged::TagListType keys;
232        keys.push_back(1);
233        keys.push_back(2);
234        keys.push_back(3);
235    
236        DataTagged::ValueListType values;
237    
238        DataArrayView::ShapeType viewShape;
239    
240        // default value
241        DataArrayView::ValueType viewData(1);
242        viewData[0]=0.0;
243        DataArrayView myView(viewData,viewShape);
244    
245        // value for tag "1"
246        DataArray eOne(myView);
247        eOne.getView()()=1.0;
248        values.push_back(eOne.getView());
249    
250        // value for tag "2"
251        DataArray eTwo(myView);
252        eTwo.getView()()=2.0;
253        values.push_back(eTwo.getView());
254    
255        // value for tag "3"
256        DataArray eThree(myView);
257        eThree.getView()()=3.0;
258        values.push_back(eThree.getView());
259    
260        DataTagged myData(keys,values,myView,FunctionSpace());
261    
262        DataArrayView::ShapeType shape;
263        shape.push_back(2);
264        shape.push_back(2);
265        shape.push_back(2);
266    
267        myData.reshapeDataPoint(shape);
268    
269        //cout << myData.toString() << endl;
270    
271        assert(myData.getNumSamples()==1);
272        assert(myData.getNumDPPSample()==1);
273    
274        assert(myData.validSamplePointNo(0));
275        assert(myData.validSampleNo(0));
276        assert(!myData.validSamplePointNo(1));
277        assert(!myData.validSampleNo(1));
278    
279        // data-point 0 has tag number 1 by default
280        assert(myData.getTagNumber(0)==1);
281    
282        assert(myData.isCurrentTag(1));
283        assert(myData.isCurrentTag(2));
284        assert(myData.isCurrentTag(3));
285    
286        assert(myData.getTagLookup().size()==3);
287    
288        assert(myData.getLength()==32);
289    
290        assert(myData.getPointOffset(0,0)==8);
291    
292        DataArrayView myDataView = myData.getDataPoint(0,0);
293        assert(!myDataView.isEmpty());
294        assert(myDataView.getOffset()==8);
295        assert(myDataView.getRank()==3);
296        assert(myDataView.noValues()==8);
297        assert(myDataView.getShape().size()==3);
298        for (int k=0;k<shape[2];k++) {
299          for (int j=0;j<shape[1];j++) {
300            for (int i=0;i<shape[0];i++) {
301              assert(myDataView(i,j,k)==1.0);
302            }
303          }
304        }
305    
306        myDataView = myData.getDataPointByTag(1);
307        assert(!myDataView.isEmpty());
308        assert(myDataView.getOffset()==8);
309        assert(myDataView.getRank()==3);
310        assert(myDataView.noValues()==8);
311        assert(myDataView.getShape().size()==3);
312        for (int k=0;k<shape[2];k++) {
313          for (int j=0;j<shape[1];j++) {
314            for (int i=0;i<shape[0];i++) {
315              assert(myDataView(i,j,k)==1.0);
316            }
317          }
318        }
319    
320        myDataView = myData.getDataPointByTag(2);
321        assert(!myDataView.isEmpty());
322        assert(myDataView.getOffset()==16);
323        assert(myDataView.getRank()==3);
324        assert(myDataView.noValues()==8);
325        assert(myDataView.getShape().size()==3);
326        for (int k=0;k<shape[2];k++) {
327          for (int j=0;j<shape[1];j++) {
328            for (int i=0;i<shape[0];i++) {
329              assert(myDataView(i,j,k)==2.0);
330            }
331          }
332        }
333    
334        myDataView = myData.getDataPointByTag(3);
335        assert(!myDataView.isEmpty());
336        assert(myDataView.getOffset()==24);
337        assert(myDataView.getRank()==3);
338        assert(myDataView.noValues()==8);
339        assert(myDataView.getShape().size()==3);
340        for (int k=0;k<shape[2];k++) {
341          for (int j=0;j<shape[1];j++) {
342            for (int i=0;i<shape[0];i++) {
343              assert(myDataView(i,j,k)==3.0);
344            }
345          }
346        }
347    
348        myDataView = myData.getDefaultValue();
349        assert(!myDataView.isEmpty());
350        assert(myDataView.getOffset()==0);
351        assert(myDataView.getRank()==3);
352        assert(myDataView.noValues()==8);
353        assert(myDataView.getShape().size()==3);
354        for (int k=0;k<shape[2];k++) {
355          for (int j=0;j<shape[1];j++) {
356            for (int i=0;i<shape[0];i++) {
357              assert(myDataView(i,j,k)==0.0);
358            }
359          }
360        }
361    
362        // use a non-existent tag so we get a pointer to
363        // the first element of the data array
364        double* sampleData=myData.getSampleDataByTag(9);
365        for (int i=0; i<myData.getLength(); i++) {
366          if (i<8) {
367            assert(sampleData[i]==0.0);
368          } else if ((i>=8) && (i<16)) {
369            assert(sampleData[i]==1.0);
370          } else if ((i>=16) && (i<24)) {
371            assert(sampleData[i]==2.0);
372          } else {
373            assert(sampleData[i]==3.0);
374          }
375        }
376    
377      }
378    
379  }  }
380    
381  void DataTaggedTestCase::testOperations() {  void DataTaggedTestCase::testOperations() {
# Line 87  void DataTaggedTestCase::testOperations( Line 383  void DataTaggedTestCase::testOperations(
383    cout << endl;    cout << endl;
384    
385    {    {
386      DataTagged left;      cout << "\tTest binaryOp addition of two default DataTagged objects." << endl;
387    
388        DataTagged myData;
389      DataTagged right;      DataTagged right;
390    
391      cout << "\tTest default DataTagged contains only a default value." << endl;      binaryOp(myData,right,plus<double>());
392      binaryOp(left,right,plus<double>());  
393      assert(left.getPointDataView()()==0);      //cout << myData.toString() << endl;
394      assert(right.getPointDataView()()==0);  
395        assert(myData.getNumSamples()==1);
396        assert(myData.getNumDPPSample()==1);
397    
398        assert(myData.validSamplePointNo(0));
399        assert(myData.validSampleNo(0));
400        assert(!myData.validSamplePointNo(1));
401        assert(!myData.validSampleNo(1));
402    
403        // data-point 0 has tag number 1 by default
404        assert(myData.getTagNumber(0)==1);
405    
406        assert(!myData.isCurrentTag(1));
407    
408        assert(myData.getTagLookup().size()==0);
409    
410        assert(myData.getLength()==1);
411    
412        assert(myData.getPointOffset(0,0)==0);
413    
414        DataArrayView myDataView = myData.getDataPoint(0,0);
415        assert(!myDataView.isEmpty());
416        assert(myDataView.getOffset()==0);
417        assert(myDataView.getRank()==0);
418        assert(myDataView.noValues()==1);
419        assert(myDataView.getShape().size()==0);
420        assert(myDataView()==0.0);
421    
422        // Test non-existent tag returns the default value.
423        myDataView = myData.getDataPointByTag(1);
424        assert(!myDataView.isEmpty());
425        assert(myDataView.getOffset()==0);
426        assert(myDataView.getRank()==0);
427        assert(myDataView.noValues()==1);
428        assert(myDataView.getShape().size()==0);
429        assert(myDataView()==0.0);
430    
431        myDataView = myData.getDefaultValue();
432        assert(!myDataView.isEmpty());
433        assert(myDataView.getOffset()==0);
434        assert(myDataView.getRank()==0);
435        assert(myDataView.noValues()==1);
436        assert(myDataView.getShape().size()==0);
437        assert(myDataView()==0.0);
438    
439        // use a non-existent tag so we get a pointer to
440        // the first element of the data array
441        double* sampleData=myData.getSampleDataByTag(9);
442        for (int i=0; i<myData.getLength(); i++) {
443          assert(sampleData[i]==i);
444        }
445    
446      }
447    
448      {
449        cout << "\tTest binaryOp addition of two DataTagged objects with default values only." << endl;
450    
451        DataArrayView::ShapeType viewShape;
452        viewShape.push_back(3);
453    
454        DataTagged::TagListType keys;
455    
456        DataTagged::ValueListType values;
457    
458        DataArrayView::ValueType viewData(3);
459        for (int i=0;i<viewShape[0];i++) {
460          viewData[i]=i;
461        }
462        DataArrayView myView(viewData,viewShape);
463    
464        DataTagged myData(keys,values,myView,FunctionSpace());
465        DataTagged right(keys,values,myView,FunctionSpace());
466    
467        binaryOp(myData,right,plus<double>());
468    
469        //cout << myData.toString() << endl;
470    
471        assert(myData.getNumSamples()==1);
472        assert(myData.getNumDPPSample()==1);
473    
474        assert(myData.validSamplePointNo(0));
475        assert(myData.validSampleNo(0));
476        assert(!myData.validSamplePointNo(1));
477        assert(!myData.validSampleNo(1));
478    
479        // data-point 0 has tag number 1 by default
480        assert(myData.getTagNumber(0)==1);
481    
482        assert(!myData.isCurrentTag(1));
483    
484        assert(myData.getTagLookup().size()==0);
485    
486        assert(myData.getLength()==3);
487    
488        assert(myData.getPointOffset(0,0)==0);
489    
490        DataArrayView myDataView = myData.getDefaultValue();
491        assert(!myDataView.isEmpty());
492        assert(myDataView.getOffset()==0);
493        assert(myDataView.getRank()==1);
494        assert(myDataView.noValues()==3);
495        assert(myDataView.getShape().size()==1);
496        assert(myDataView(0)==0);
497        assert(myDataView(1)==2);
498        assert(myDataView(2)==4);
499    
500        // use a non-existent tag so we get a pointer to
501        // the first element of the data array
502        double* sampleData=myData.getSampleDataByTag(9);
503        for (int i=0; i<myData.getLength(); i++) {
504          assert(sampleData[i]==i*2);
505        }
506    
507      }
508    
509      {
510        cout << "\tTest binaryOp addition of two DataTagged objects with one identical tag each." << endl;
511    
512        DataTagged myData;
513        DataTagged right;
514    
     cout << "\tTest binaryOp(plus)." << endl;  
515      DataArray vOne(1.0);      DataArray vOne(1.0);
516      DataArray vTwo(2.0);      myData.addTaggedValue(1,vOne.getView());
517      right.addTaggedValue(1,vOne.getView());      right.addTaggedValue(1,vOne.getView());
518    
519        binaryOp(myData,right,plus<double>());
520    
521        assert(myData.getNumSamples()==1);
522        assert(myData.getNumDPPSample()==1);
523    
524        assert(myData.validSamplePointNo(0));
525        assert(myData.validSampleNo(0));
526        assert(!myData.validSamplePointNo(1));
527        assert(!myData.validSampleNo(1));
528    
529        // data-point 0 has tag number 1 by default
530        assert(myData.getTagNumber(0)==1);
531    
532        assert(myData.isCurrentTag(1));
533    
534        assert(myData.getTagLookup().size()==1);
535    
536        assert(myData.getLength()==2);
537    
538        assert(myData.getPointOffset(0,0)==1);
539    
540        // check result value for tag "1"
541        DataArrayView myDataView = myData.getDataPointByTag(1);
542        assert(!myDataView.isEmpty());
543        assert(myDataView.getOffset()==1);
544        assert(myDataView.getRank()==0);
545        assert(myDataView.noValues()==1);
546        assert(myDataView.getShape().size()==0);
547        assert(myDataView()==2.0);
548    
549        // check result for default value
550        myDataView = myData.getDefaultValue();
551        assert(!myDataView.isEmpty());
552        assert(myDataView.getOffset()==0);
553        assert(myDataView.getRank()==0);
554        assert(myDataView.noValues()==1);
555        assert(myDataView.getShape().size()==0);
556        assert(myDataView()==0.0);
557    
558        // use a non-existent tag so we get a pointer to
559        // the first element of the data array
560        double* sampleData=myData.getSampleDataByTag(9);
561        for (int i=0; i<myData.getLength(); i++) {
562          assert(sampleData[i]==i*2);
563        }
564    
565      }
566    
567      {
568        cout << "\tTest binaryOp addition of two DataTagged objects with one different tag each." << endl;
569    
570        DataTagged myData;
571        DataTagged right;
572    
573        // it's important that default values are different, as we need to be able to
574        // verify that the tag values in each object are being added to the correct
575        // default values - since the tag lists don't match, the default values will
576        // be used for missing tags in each object
577        myData.getDefaultValue()()=1.0;
578        right.getDefaultValue()()=2.0;
579    
580        DataArray vOne(3.0);
581        DataArray vTwo(4.0);
582        myData.addTaggedValue(1,vOne.getView());
583      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
     binaryOp(left,right,plus<double>());  
     assert(left.getPointDataView()()==0);  
     assert(left.getDataPointByTag(1)==vOne.getView());  
     assert(left.getDataPointByTag(2)==vTwo.getView());  
584    
585      cout << "\tTest binaryOp(multiplies)." << endl;      //cout << myData.toString() << endl;
586      DataArray vZero(0.0);      //cout << right.toString() << endl;
587      right.setTaggedValue(1,vZero.getView());  
588      right.setTaggedValue(2,vZero.getView());      binaryOp(myData,right,plus<double>());
589      binaryOp(left,right,multiplies<double>());  
590      assert(left.getPointDataView()()==0);      //cout << myData.toString() << endl;
591      assert(left.getDataPointByTag(1)==vZero.getView());  
592      assert(left.getDataPointByTag(2)==vZero.getView());      assert(myData.getNumSamples()==1);
593        assert(myData.getNumDPPSample()==1);
594    
595        assert(myData.validSamplePointNo(0));
596        assert(myData.validSampleNo(0));
597        assert(!myData.validSamplePointNo(1));
598        assert(!myData.validSampleNo(1));
599    
600        // data-point 0 has tag number 1 by default
601        assert(myData.getTagNumber(0)==1);
602    
603        assert(myData.isCurrentTag(1));
604        assert(myData.isCurrentTag(2));
605    
606        assert(myData.getTagLookup().size()==2);
607    
608        assert(myData.getLength()==3);
609    
610        assert(myData.getPointOffset(0,0)==1);
611    
612        // check result value for tag "1"
613        DataArrayView myDataView = myData.getDataPointByTag(1);
614        assert(!myDataView.isEmpty());
615        assert(myDataView.getOffset()==1);
616        assert(myDataView.getRank()==0);
617        assert(myDataView.noValues()==1);
618        assert(myDataView.getShape().size()==0);
619        assert(myDataView()==5.0);
620    
621        // check result value for tag "2"
622        myDataView = myData.getDataPointByTag(2);
623        assert(!myDataView.isEmpty());
624        assert(myDataView.getOffset()==2);
625        assert(myDataView.getRank()==0);
626        assert(myDataView.noValues()==1);
627        assert(myDataView.getShape().size()==0);
628        assert(myDataView()==5.0);
629    
630        // check result for default value
631        myDataView = myData.getDefaultValue();
632        assert(!myDataView.isEmpty());
633        assert(myDataView.getOffset()==0);
634        assert(myDataView.getRank()==0);
635        assert(myDataView.noValues()==1);
636        assert(myDataView.getShape().size()==0);
637        assert(myDataView()==3.0);
638    
639        // use a non-existent tag so we get a pointer to
640        // the first element of the data array
641        double* sampleData=myData.getSampleDataByTag(9);
642        assert(sampleData[0]==3);
643        assert(sampleData[1]==5);
644        assert(sampleData[2]==5);
645    
646    }    }
647    
648    {    {
649        cout << "\tTest binaryOp addition of two DataTagged objects with overlapping tag sets." << endl;
650    
651        DataTagged myData;
652        DataTagged right;
653    
654        // it's important that default values are different, as we need to be able to
655        // verify that the tag values in each object are being added to the correct
656        // default values - since the tag lists don't match, the default values will
657        // be used for missing tags in each object
658        myData.getDefaultValue()()=2.0;
659        right.getDefaultValue()()=3.0;
660    
661        DataArray vOne(1.0);
662        myData.addTaggedValue(1,vOne.getView());
663        myData.addTaggedValue(2,vOne.getView());
664        right.addTaggedValue(2,vOne.getView());
665        right.addTaggedValue(3,vOne.getView());
666    
667        //cout << myData.toString() << endl;
668        //cout << right.toString() << endl;
669    
670        binaryOp(myData,right,plus<double>());
671    
672        //cout << myData.toString() << endl;
673    
674        assert(myData.getNumSamples()==1);
675        assert(myData.getNumDPPSample()==1);
676    
677        assert(myData.validSamplePointNo(0));
678        assert(myData.validSampleNo(0));
679        assert(!myData.validSamplePointNo(1));
680        assert(!myData.validSampleNo(1));
681    
682        // data-point 0 has tag number 1 by default
683        assert(myData.getTagNumber(0)==1);
684    
685        assert(myData.isCurrentTag(1));
686        assert(myData.isCurrentTag(2));
687        assert(myData.isCurrentTag(3));
688    
689        assert(myData.getTagLookup().size()==3);
690    
691        assert(myData.getLength()==4);
692    
693        assert(myData.getPointOffset(0,0)==1);
694    
695        // check result value for tag "1"
696        DataArrayView myDataView = myData.getDataPointByTag(1);
697        assert(!myDataView.isEmpty());
698        assert(myDataView.getOffset()==1);
699        assert(myDataView.getRank()==0);
700        assert(myDataView.noValues()==1);
701        assert(myDataView.getShape().size()==0);
702        assert(myDataView()==4.0);
703    
704        // check result value for tag "2"
705        myDataView = myData.getDataPointByTag(2);
706        assert(!myDataView.isEmpty());
707        assert(myDataView.getOffset()==2);
708        assert(myDataView.getRank()==0);
709        assert(myDataView.noValues()==1);
710        assert(myDataView.getShape().size()==0);
711        assert(myDataView()==2.0);
712    
713        // check result value for tag "3"
714        myDataView = myData.getDataPointByTag(3);
715        assert(!myDataView.isEmpty());
716        assert(myDataView.getOffset()==3);
717        assert(myDataView.getRank()==0);
718        assert(myDataView.noValues()==1);
719        assert(myDataView.getShape().size()==0);
720        assert(myDataView()==3.0);
721    
722        // check result for default value
723        myDataView = myData.getDefaultValue();
724        assert(!myDataView.isEmpty());
725        assert(myDataView.getOffset()==0);
726        assert(myDataView.getRank()==0);
727        assert(myDataView.noValues()==1);
728        assert(myDataView.getShape().size()==0);
729        assert(myDataView()==5.0);
730    
731        // use a non-existent tag so we get a pointer to
732        // the first element of the data array
733        double* sampleData=myData.getSampleDataByTag(9);
734        assert(sampleData[0]==5);
735        assert(sampleData[1]==4);
736        assert(sampleData[2]==2);
737        assert(sampleData[3]==3);
738    
739      }
740    
741      {
742        cout << "\tTest binaryOp multiplication of two DataTagged objects with default values only." << endl;
743    
744      DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
745      viewShape.push_back(3);      viewShape.push_back(3);
746      DataArrayView::ValueType viewData(3);  
747      DataTagged::TagListType keys;      DataTagged::TagListType keys;
748    
749      DataTagged::ValueListType values;      DataTagged::ValueListType values;
750      for (int i=0;i<viewShape[0];++i) {  
751        DataArrayView::ValueType viewData(3);
752        for (int i=0;i<viewShape[0];i++) {
753        viewData[i]=i;        viewData[i]=i;
754      }      }
755      DataArrayView myView(viewData,viewShape);      DataArrayView myView(viewData,viewShape);
756      cout << "\tCreate tagged data with no tag values just a default." << endl;  
757      DataTagged left(keys,values,myView,FunctionSpace());      DataTagged myData(keys,values,myView,FunctionSpace());
758      DataTagged right(keys,values,myView,FunctionSpace());      DataTagged right(keys,values,myView,FunctionSpace());
759      binaryOp(left,right,minus<double>());  
760      for (int i=0;i<viewShape[0];++i) {      binaryOp(myData,right,multiplies<double>());
761        assert(left.getDefaultValue()(i)==0);  
762      }      //cout << myData.toString() << endl;
763      double mVal=10.0;  
764      for (int i=0;i<viewShape[0];++i) {      assert(myData.getNumSamples()==1);
765        viewData[i]=i*mVal;      assert(myData.getNumDPPSample()==1);
766      }  
767      cout << "\tTest binaryOp(minus) with the right hand side as a view." << endl;      assert(myData.validSamplePointNo(0));
768      binaryOp(left,myView,minus<double>());      assert(myData.validSampleNo(0));
769      for (int i=0;i<viewShape[0];++i) {      assert(!myData.validSamplePointNo(1));
770        assert(left.getDefaultValue()(i)==-(i*mVal));      assert(!myData.validSampleNo(1));
771    
772        // data-point 0 has tag number 1 by default
773        assert(myData.getTagNumber(0)==1);
774    
775        assert(!myData.isCurrentTag(1));
776    
777        assert(myData.getTagLookup().size()==0);
778    
779        assert(myData.getLength()==3);
780    
781        assert(myData.getPointOffset(0,0)==0);
782    
783        DataArrayView myDataView = myData.getDefaultValue();
784        assert(!myDataView.isEmpty());
785        assert(myDataView.getOffset()==0);
786        assert(myDataView.getRank()==1);
787        assert(myDataView.noValues()==3);
788        assert(myDataView.getShape().size()==1);
789        assert(myDataView(0)==0);
790        assert(myDataView(1)==1);
791        assert(myDataView(2)==4);
792    
793        // use a non-existent tag so we get a pointer to
794        // the first element of the data array
795        double* sampleData=myData.getSampleDataByTag(9);
796        for (int i=0; i<myData.getLength(); i++) {
797          assert(sampleData[i]==i*i);
798        }
799    
800      }
801    
802      {
803    
804        cout << "\tTest binaryOp multiplication of DataTagged object with a scalar." << endl;
805    
806        DataTagged myData;
807    
808        DataArray vOne(1.0);
809        DataArray vTwo(2.0);
810        myData.addTaggedValue(1,vOne.getView());
811        myData.addTaggedValue(2,vTwo.getView());
812    
813        DataArray vThree(3.0);
814        DataArrayView right=vThree.getView();
815    
816        //cout << myData.toString() << endl;
817        //cout << right.toString() << endl;
818    
819        binaryOp(myData,right,multiplies<double>());
820    
821        //cout << myData.toString() << endl;
822    
823        assert(myData.getNumSamples()==1);
824        assert(myData.getNumDPPSample()==1);
825    
826        assert(myData.validSamplePointNo(0));
827        assert(myData.validSampleNo(0));
828        assert(!myData.validSamplePointNo(1));
829        assert(!myData.validSampleNo(1));
830    
831        // data-point 0 has tag number 1 by default
832        assert(myData.getTagNumber(0)==1);
833    
834        assert(myData.isCurrentTag(1));
835        assert(myData.isCurrentTag(2));
836    
837        assert(myData.getTagLookup().size()==2);
838    
839        assert(myData.getLength()==3);
840    
841        assert(myData.getPointOffset(0,0)==1);
842    
843        // check result value for tag "1"
844        DataArrayView myDataView = myData.getDataPointByTag(1);
845        assert(!myDataView.isEmpty());
846        assert(myDataView.getOffset()==1);
847        assert(myDataView.getRank()==0);
848        assert(myDataView.noValues()==1);
849        assert(myDataView.getShape().size()==0);
850        assert(myDataView()==3.0);
851    
852        // check result value for tag "2"
853        myDataView = myData.getDataPointByTag(2);
854        assert(!myDataView.isEmpty());
855        assert(myDataView.getOffset()==2);
856        assert(myDataView.getRank()==0);
857        assert(myDataView.noValues()==1);
858        assert(myDataView.getShape().size()==0);
859        assert(myDataView()==6.0);
860    
861        // check result for default value
862        myDataView = myData.getDefaultValue();
863        assert(!myDataView.isEmpty());
864        assert(myDataView.getOffset()==0);
865        assert(myDataView.getRank()==0);
866        assert(myDataView.noValues()==1);
867        assert(myDataView.getShape().size()==0);
868        assert(myDataView()==0.0);
869    
870        // use a non-existent tag so we get a pointer to
871        // the first element of the data array
872        double* sampleData=myData.getSampleDataByTag(9);
873        assert(sampleData[0]==0);
874        assert(sampleData[1]==3);
875        assert(sampleData[2]==6);
876    
877      }
878    
879      {
880        cout << "\tTest binaryOp multiplication of two DataTagged objects with overlapping tag sets." << endl;
881    
882        DataTagged myData;
883        DataTagged right;
884    
885        // it's important that default values are different, as we need to be able to
886        // verify that the tag values in each object are being added to the correct
887        // default values - since the tag lists don't match, the default values will
888        // be used for missing tags in each object
889        myData.getDefaultValue()()=2.0;
890        right.getDefaultValue()()=3.0;
891    
892        DataArray vOne(1.0);
893        DataArray vTwo(2.0);
894        myData.addTaggedValue(1,vOne.getView());
895        myData.addTaggedValue(2,vOne.getView());
896        right.addTaggedValue(2,vTwo.getView());
897        right.addTaggedValue(3,vTwo.getView());
898    
899        //cout << myData.toString() << endl;
900        //cout << right.toString() << endl;
901    
902        binaryOp(myData,right,multiplies<double>());
903    
904        //cout << myData.toString() << endl;
905    
906        assert(myData.getNumSamples()==1);
907        assert(myData.getNumDPPSample()==1);
908    
909        assert(myData.validSamplePointNo(0));
910        assert(myData.validSampleNo(0));
911        assert(!myData.validSamplePointNo(1));
912        assert(!myData.validSampleNo(1));
913    
914        // data-point 0 has tag number 1 by default
915        assert(myData.getTagNumber(0)==1);
916    
917        assert(myData.isCurrentTag(1));
918        assert(myData.isCurrentTag(2));
919        assert(myData.isCurrentTag(3));
920    
921        assert(myData.getTagLookup().size()==3);
922    
923        assert(myData.getLength()==4);
924    
925        assert(myData.getPointOffset(0,0)==1);
926    
927        // check result value for tag "1"
928        DataArrayView myDataView = myData.getDataPointByTag(1);
929        assert(!myDataView.isEmpty());
930        assert(myDataView.getOffset()==1);
931        assert(myDataView.getRank()==0);
932        assert(myDataView.noValues()==1);
933        assert(myDataView.getShape().size()==0);
934        assert(myDataView()==3.0);
935    
936        // check result value for tag "2"
937        myDataView = myData.getDataPointByTag(2);
938        assert(!myDataView.isEmpty());
939        assert(myDataView.getOffset()==2);
940        assert(myDataView.getRank()==0);
941        assert(myDataView.noValues()==1);
942        assert(myDataView.getShape().size()==0);
943        assert(myDataView()==2.0);
944    
945        // check result value for tag "3"
946        myDataView = myData.getDataPointByTag(3);
947        assert(!myDataView.isEmpty());
948        assert(myDataView.getOffset()==3);
949        assert(myDataView.getRank()==0);
950        assert(myDataView.noValues()==1);
951        assert(myDataView.getShape().size()==0);
952        assert(myDataView()==4.0);
953    
954        // check result for default value
955        myDataView = myData.getDefaultValue();
956        assert(!myDataView.isEmpty());
957        assert(myDataView.getOffset()==0);
958        assert(myDataView.getRank()==0);
959        assert(myDataView.noValues()==1);
960        assert(myDataView.getShape().size()==0);
961        assert(myDataView()==6.0);
962    
963        // use a non-existent tag so we get a pointer to
964        // the first element of the data array
965        double* sampleData=myData.getSampleDataByTag(9);
966        assert(sampleData[0]==6);
967        assert(sampleData[1]==3);
968        assert(sampleData[2]==2);
969        assert(sampleData[3]==4);
970    
971      }
972    
973      {
974        cout << "\tTest unaryOp negate on default DataTagged object." << endl;
975    
976        DataTagged myData;
977    
978        unaryOp(myData,negate<double>());
979    
980        //cout << myData.toString() << endl;
981    
982        assert(myData.getNumSamples()==1);
983        assert(myData.getNumDPPSample()==1);
984    
985        assert(myData.validSamplePointNo(0));
986        assert(myData.validSampleNo(0));
987        assert(!myData.validSamplePointNo(1));
988        assert(!myData.validSampleNo(1));
989    
990        // data-point 0 has tag number 1 by default
991        assert(myData.getTagNumber(0)==1);
992    
993        assert(!myData.isCurrentTag(1));
994    
995        assert(myData.getTagLookup().size()==0);
996    
997        assert(myData.getLength()==1);
998    
999        assert(myData.getPointOffset(0,0)==0);
1000    
1001        DataArrayView myDataView = myData.getDataPoint(0,0);
1002        assert(!myDataView.isEmpty());
1003        assert(myDataView.getOffset()==0);
1004        assert(myDataView.getRank()==0);
1005        assert(myDataView.noValues()==1);
1006        assert(myDataView.getShape().size()==0);
1007        assert(myDataView()==0.0);
1008    
1009        // Test non-existent tag returns the default value.
1010        myDataView = myData.getDataPointByTag(1);
1011        assert(!myDataView.isEmpty());
1012        assert(myDataView.getOffset()==0);
1013        assert(myDataView.getRank()==0);
1014        assert(myDataView.noValues()==1);
1015        assert(myDataView.getShape().size()==0);
1016        assert(myDataView()==0.0);
1017    
1018        myDataView = myData.getDefaultValue();
1019        assert(!myDataView.isEmpty());
1020        assert(myDataView.getOffset()==0);
1021        assert(myDataView.getRank()==0);
1022        assert(myDataView.noValues()==1);
1023        assert(myDataView.getShape().size()==0);
1024        assert(myDataView()==0.0);
1025    
1026        // use a non-existent tag so we get a pointer to
1027        // the first element of the data array
1028        double* sampleData=myData.getSampleDataByTag(9);
1029        for (int i=0; i<myData.getLength(); i++) {
1030          assert(sampleData[i]==i);
1031      }      }
1032    
1033    }    }
1034    
1035    {    {
1036      cout << "\tTest unaryOp(negate) on default DataTagged." << endl;      cout << "\tTest unaryOp negate on DataTagged object with default value only." << endl;
1037      DataTagged data;  
1038      unaryOp(data,negate<double>());      DataArrayView::ShapeType viewShape;
1039      assert(data.getDefaultValue()()==0);      viewShape.push_back(3);
1040      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();  
1041      DataTagged::TagListType keys;      DataTagged::TagListType keys;
1042    
1043      DataTagged::ValueListType values;      DataTagged::ValueListType values;
1044    
1045        DataArrayView::ValueType viewData(3);
1046        for (int i=0;i<viewShape[0];i++) {
1047          viewData[i]=i;
1048        }
1049        DataArrayView myView(viewData,viewShape);
1050    
1051        DataTagged myData(keys,values,myView,FunctionSpace());
1052    
1053        unaryOp(myData,negate<double>());
1054    
1055        //cout << myData.toString() << endl;
1056    
1057        assert(myData.getNumSamples()==1);
1058        assert(myData.getNumDPPSample()==1);
1059    
1060        assert(myData.validSamplePointNo(0));
1061        assert(myData.validSampleNo(0));
1062        assert(!myData.validSamplePointNo(1));
1063        assert(!myData.validSampleNo(1));
1064    
1065        // data-point 0 has tag number 1 by default
1066        assert(myData.getTagNumber(0)==1);
1067    
1068        assert(!myData.isCurrentTag(1));
1069    
1070        assert(myData.getTagLookup().size()==0);
1071    
1072        assert(myData.getLength()==3);
1073    
1074        assert(myData.getPointOffset(0,0)==0);
1075    
1076        DataArrayView myDataView = myData.getDefaultValue();
1077        assert(!myDataView.isEmpty());
1078        assert(myDataView.getOffset()==0);
1079        assert(myDataView.getRank()==1);
1080        assert(myDataView.noValues()==3);
1081        assert(myDataView.getShape().size()==1);
1082        assert(myDataView(0)==0);
1083        assert(myDataView(1)==-1);
1084        assert(myDataView(2)==-2);
1085    
1086        // use a non-existent tag so we get a pointer to
1087        // the first element of the data array
1088        double* sampleData=myData.getSampleDataByTag(9);
1089        for (int i=0; i<myData.getLength(); i++) {
1090          assert(sampleData[i]==0-i);
1091        }
1092    
1093      }
1094    
1095      {
1096        cout << "\tTest unaryOp negate on DataTagged object with two tags." << endl;
1097    
1098        DataTagged myData;
1099    
1100        DataArray vOne(1.0);
1101        DataArray vTwo(2.0);
1102        myData.addTaggedValue(1,vOne.getView());
1103        myData.addTaggedValue(2,vTwo.getView());
1104    
1105        unaryOp(myData,negate<double>());
1106    
1107        assert(myData.getNumSamples()==1);
1108        assert(myData.getNumDPPSample()==1);
1109    
1110        assert(myData.validSamplePointNo(0));
1111        assert(myData.validSampleNo(0));
1112        assert(!myData.validSamplePointNo(1));
1113        assert(!myData.validSampleNo(1));
1114    
1115        // data-point 0 has tag number 1 by default
1116        assert(myData.getTagNumber(0)==1);
1117    
1118        assert(myData.isCurrentTag(1));
1119        assert(myData.isCurrentTag(2));
1120    
1121        assert(myData.getTagLookup().size()==2);
1122    
1123        assert(myData.getLength()==3);
1124    
1125        assert(myData.getPointOffset(0,0)==1);
1126    
1127        // check result value for tag "1"
1128        DataArrayView myDataView = myData.getDataPointByTag(1);
1129        assert(!myDataView.isEmpty());
1130        assert(myDataView.getOffset()==1);
1131        assert(myDataView.getRank()==0);
1132        assert(myDataView.noValues()==1);
1133        assert(myDataView.getShape().size()==0);
1134        assert(myDataView()==-1.0);
1135    
1136        // check result value for tag "2"
1137        myDataView = myData.getDataPointByTag(2);
1138        assert(!myDataView.isEmpty());
1139        assert(myDataView.getOffset()==2);
1140        assert(myDataView.getRank()==0);
1141        assert(myDataView.noValues()==1);
1142        assert(myDataView.getShape().size()==0);
1143        assert(myDataView()==-2.0);
1144    
1145        // check result for default value
1146        myDataView = myData.getDefaultValue();
1147        assert(!myDataView.isEmpty());
1148        assert(myDataView.getOffset()==0);
1149        assert(myDataView.getRank()==0);
1150        assert(myDataView.noValues()==1);
1151        assert(myDataView.getShape().size()==0);
1152        assert(myDataView()==0.0);
1153    
1154        // use a non-existent tag so we get a pointer to
1155        // the first element of the data array
1156        double* sampleData=myData.getSampleDataByTag(9);
1157        for (int i=0; i<myData.getLength(); i++) {
1158          assert(sampleData[i]==0-i);
1159        }
1160    
1161      }
1162    
1163    }
1164    
1165    void DataTaggedTestCase::testAddTaggedValues() {
1166    
1167      cout << endl;
1168    
1169      {
1170    
1171        cout << "\tTest adding one key with empty value list to default DataTagged." << endl;
1172        DataTagged myData;
1173    
1174        DataTagged::TagListType keys;
1175        keys.push_back(1);
1176    
1177        DataTagged::ValueListType values;
1178    
1179        myData.addTaggedValues(keys,values);
1180    
1181        assert(myData.isCurrentTag(1));
1182    
1183        assert(myData.getTagLookup().size()==1);
1184    
1185        assert(myData.getLength()==2);
1186    
1187        // data-point 0 has tag number 1 by default
1188        assert(myData.getTagNumber(0)==1);
1189    
1190        assert(myData.getPointOffset(0,0)==1);
1191    
1192        DataArrayView myDataView = myData.getDataPoint(0,0);
1193        assert(!myDataView.isEmpty());
1194        assert(myDataView.getOffset()==1);
1195        assert(myDataView.getRank()==0);
1196        assert(myDataView.noValues()==1);
1197        assert(myDataView.getShape().size()==0);
1198        assert(myDataView()==0.0);
1199    
1200        myDataView = myData.getDataPointByTag(1);
1201        assert(!myDataView.isEmpty());
1202        assert(myDataView.getOffset()==1);
1203        assert(myDataView.getRank()==0);
1204        assert(myDataView.noValues()==1);
1205        assert(myDataView.getShape().size()==0);
1206        assert(myDataView()==0.0);
1207    
1208        myDataView = myData.getDefaultValue();
1209        assert(!myDataView.isEmpty());
1210        assert(myDataView.getOffset()==0);
1211        assert(myDataView.getRank()==0);
1212        assert(myDataView.noValues()==1);
1213        assert(myDataView.getShape().size()==0);
1214        assert(myDataView()==0.0);
1215    
1216        // use a non-existent tag so we get a pointer to
1217        // the first element of the data array
1218        double* sampleData=myData.getSampleDataByTag(9);
1219        for (int i=0; i<myData.getLength(); i++) {
1220          assert(sampleData[i]==0);
1221        }
1222    
1223      }
1224    
1225      {
1226    
1227        cout << "\tTest adding one key with one value to default DataTagged." << endl;
1228        DataTagged myData;
1229    
1230        DataTagged::TagListType keys;
1231        keys.push_back(1);
1232    
1233        DataTagged::ValueListType values;
1234    
1235        DataArrayView::ShapeType viewShape;
1236        DataArrayView::ValueType viewData(1);
1237        viewData[0]=1.0;
1238        DataArrayView myView(viewData,viewShape);
1239        values.push_back(myView);
1240    
1241        myData.addTaggedValues(keys,values);
1242    
1243        assert(myData.isCurrentTag(1));
1244    
1245        assert(myData.getTagLookup().size()==1);
1246    
1247        assert(myData.getLength()==2);
1248    
1249        // data-point 0 has tag number 1 by default
1250        assert(myData.getTagNumber(0)==1);
1251    
1252        assert(myData.getPointOffset(0,0)==1);
1253    
1254        DataArrayView myDataView = myData.getDataPoint(0,0);
1255        assert(!myDataView.isEmpty());
1256        assert(myDataView.getOffset()==1);
1257        assert(myDataView.getRank()==0);
1258        assert(myDataView.noValues()==1);
1259        assert(myDataView.getShape().size()==0);
1260        assert(myDataView()==1.0);
1261    
1262        myDataView = myData.getDataPointByTag(1);
1263        assert(!myDataView.isEmpty());
1264        assert(myDataView.getOffset()==1);
1265        assert(myDataView.getRank()==0);
1266        assert(myDataView.noValues()==1);
1267        assert(myDataView.getShape().size()==0);
1268        assert(myDataView()==1.0);
1269    
1270        myDataView = myData.getDefaultValue();
1271        assert(!myDataView.isEmpty());
1272        assert(myDataView.getOffset()==0);
1273        assert(myDataView.getRank()==0);
1274        assert(myDataView.noValues()==1);
1275        assert(myDataView.getShape().size()==0);
1276        assert(myDataView()==0.0);
1277    
1278        // use a non-existent tag so we get a pointer to
1279        // the first element of the data array
1280        double* sampleData=myData.getSampleDataByTag(9);
1281        for (int i=0; i<myData.getLength(); i++) {
1282          assert(sampleData[i]==i);
1283        }
1284    
1285      }
1286    
1287      {
1288    
1289        cout << "\tTest adding three keys with one value to default DataTagged." << endl;
1290        DataTagged myData;
1291    
1292        DataTagged::TagListType keys;
1293        keys.push_back(1);
1294        keys.push_back(2);
1295        keys.push_back(3);
1296    
1297        DataTagged::ValueListType values;
1298    
1299        DataArrayView::ShapeType viewShape;
1300        DataArrayView::ValueType viewData(1);
1301        viewData[0]=1.0;
1302        DataArrayView myView(viewData,viewShape);
1303        values.push_back(myView);
1304    
1305        myData.addTaggedValues(keys,values);
1306    
1307        assert(myData.isCurrentTag(1));
1308        assert(myData.isCurrentTag(2));
1309        assert(myData.isCurrentTag(3));
1310    
1311        assert(myData.getTagLookup().size()==3);
1312    
1313        assert(myData.getLength()==4);
1314    
1315        // data-point 0 has tag number 1 by default
1316        assert(myData.getTagNumber(0)==1);
1317    
1318        assert(myData.getPointOffset(0,0)==1);
1319    
1320        DataArrayView myDataView = myData.getDataPoint(0,0);
1321        assert(!myDataView.isEmpty());
1322        assert(myDataView.getOffset()==1);
1323        assert(myDataView.getRank()==0);
1324        assert(myDataView.noValues()==1);
1325        assert(myDataView.getShape().size()==0);
1326        assert(myDataView()==1.0);
1327    
1328        myDataView = myData.getDataPointByTag(1);
1329        assert(!myDataView.isEmpty());
1330        assert(myDataView.getOffset()==1);
1331        assert(myDataView.getRank()==0);
1332        assert(myDataView.noValues()==1);
1333        assert(myDataView.getShape().size()==0);
1334        assert(myDataView()==1.0);
1335    
1336        myDataView = myData.getDataPointByTag(2);
1337        assert(!myDataView.isEmpty());
1338        assert(myDataView.getOffset()==2);
1339        assert(myDataView.getRank()==0);
1340        assert(myDataView.noValues()==1);
1341        assert(myDataView.getShape().size()==0);
1342        assert(myDataView()==1.0);
1343    
1344        myDataView = myData.getDataPointByTag(3);
1345        assert(!myDataView.isEmpty());
1346        assert(myDataView.getOffset()==3);
1347        assert(myDataView.getRank()==0);
1348        assert(myDataView.noValues()==1);
1349        assert(myDataView.getShape().size()==0);
1350        assert(myDataView()==1.0);
1351    
1352        myDataView = myData.getDefaultValue();
1353        assert(!myDataView.isEmpty());
1354        assert(myDataView.getOffset()==0);
1355        assert(myDataView.getRank()==0);
1356        assert(myDataView.noValues()==1);
1357        assert(myDataView.getShape().size()==0);
1358        assert(myDataView()==0.0);
1359    
1360        // use a non-existent tag so we get a pointer to
1361        // the first element of the data array
1362        double* sampleData=myData.getSampleDataByTag(9);
1363        for (int i=0; i<myData.getLength(); i++) {
1364          if (i==0) {
1365            assert(sampleData[i]==0);
1366          } else {
1367            assert(sampleData[i]==1);
1368          }
1369        }
1370    
1371      }
1372    
1373      {
1374    
1375        cout << "\tTest adding three keys with three values to default DataTagged." << endl;
1376        DataTagged myData;
1377    
1378        DataTagged::TagListType keys;
1379        keys.push_back(1);
1380        keys.push_back(2);
1381        keys.push_back(3);
1382    
1383        DataTagged::ValueListType values;
1384    
1385        DataArrayView::ShapeType viewShape;
1386        DataArrayView::ValueType viewData1(1);
1387        viewData1[0]=1.0;
1388        DataArrayView::ValueType viewData2(1);
1389        viewData2[0]=2.0;
1390        DataArrayView::ValueType viewData3(1);
1391        viewData3[0]=3.0;
1392        DataArrayView myView1(viewData1,viewShape);
1393        DataArrayView myView2(viewData2,viewShape);
1394        DataArrayView myView3(viewData3,viewShape);
1395        values.push_back(myView1);
1396        values.push_back(myView2);
1397        values.push_back(myView3);
1398    
1399        myData.addTaggedValues(keys,values);
1400    
1401        assert(myData.isCurrentTag(1));
1402        assert(myData.isCurrentTag(2));
1403        assert(myData.isCurrentTag(3));
1404    
1405        assert(myData.getTagLookup().size()==3);
1406    
1407        assert(myData.getLength()==4);
1408    
1409        // data-point 0 has tag number 1 by default
1410        assert(myData.getTagNumber(0)==1);
1411    
1412        assert(myData.getPointOffset(0,0)==1);
1413    
1414        DataArrayView myDataView = myData.getDataPoint(0,0);
1415        assert(!myDataView.isEmpty());
1416        assert(myDataView.getOffset()==1);
1417        assert(myDataView.getRank()==0);
1418        assert(myDataView.noValues()==1);
1419        assert(myDataView.getShape().size()==0);
1420        assert(myDataView()==1.0);
1421    
1422        myDataView = myData.getDataPointByTag(1);
1423        assert(!myDataView.isEmpty());
1424        assert(myDataView.getOffset()==1);
1425        assert(myDataView.getRank()==0);
1426        assert(myDataView.noValues()==1);
1427        assert(myDataView.getShape().size()==0);
1428        assert(myDataView()==1.0);
1429    
1430        myDataView = myData.getDataPointByTag(2);
1431        assert(!myDataView.isEmpty());
1432        assert(myDataView.getOffset()==2);
1433        assert(myDataView.getRank()==0);
1434        assert(myDataView.noValues()==1);
1435        assert(myDataView.getShape().size()==0);
1436        assert(myDataView()==2.0);
1437    
1438        myDataView = myData.getDataPointByTag(3);
1439        assert(!myDataView.isEmpty());
1440        assert(myDataView.getOffset()==3);
1441        assert(myDataView.getRank()==0);
1442        assert(myDataView.noValues()==1);
1443        assert(myDataView.getShape().size()==0);
1444        assert(myDataView()==3.0);
1445    
1446        myDataView = myData.getDefaultValue();
1447        assert(!myDataView.isEmpty());
1448        assert(myDataView.getOffset()==0);
1449        assert(myDataView.getRank()==0);
1450        assert(myDataView.noValues()==1);
1451        assert(myDataView.getShape().size()==0);
1452        assert(myDataView()==0.0);
1453    
1454        // use a non-existent tag so we get a pointer to
1455        // the first element of the data array
1456        double* sampleData=myData.getSampleDataByTag(9);
1457        for (int i=0; i<myData.getLength(); i++) {
1458          assert(sampleData[i]==i);
1459        }
1460    
1461      }
1462    
1463      {
1464    
1465        cout << "\tTest adding one key with empty value list to DataTagged with default value only." << endl;
1466    
1467        DataArrayView::ShapeType viewShape;
1468        viewShape.push_back(3);
1469    
1470        DataTagged::TagListType keys;
1471    
1472        DataTagged::ValueListType values;
1473    
1474        DataArrayView::ValueType viewData(3);
1475        for (int i=0;i<viewShape[0];i++) {
1476          viewData[i]=i;
1477        }
1478        DataArrayView myView(viewData,viewShape);
1479    
1480        DataTagged myData(keys,values,myView,FunctionSpace());
1481    
1482        keys.push_back(1);
1483        values.clear();
1484    
1485        myData.addTaggedValues(keys,values);
1486    
1487        assert(myData.isCurrentTag(1));
1488    
1489        assert(myData.getTagLookup().size()==1);
1490    
1491        assert(myData.getLength()==6);
1492    
1493        // data-point 0 has tag number 1 by default
1494        assert(myData.getTagNumber(0)==1);
1495    
1496        assert(myData.getPointOffset(0,0)==3);
1497    
1498        DataArrayView myDataView = myData.getDataPoint(0,0);
1499        assert(myDataView==myView);
1500        assert(!myDataView.isEmpty());
1501        assert(myDataView.getOffset()==3);
1502        assert(myDataView.getRank()==1);
1503        assert(myDataView.noValues()==3);
1504        assert(myDataView.getShape().size()==1);
1505        assert(myDataView(0)==0);
1506        assert(myDataView(1)==1);
1507        assert(myDataView(2)==2);
1508    
1509        myDataView = myData.getDataPointByTag(1);
1510        assert(myDataView==myView);
1511        assert(!myDataView.isEmpty());
1512        assert(myDataView.getOffset()==3);
1513        assert(myDataView.getRank()==1);
1514        assert(myDataView.noValues()==3);
1515        assert(myDataView.getShape().size()==1);
1516        assert(myDataView(0)==0);
1517        assert(myDataView(1)==1);
1518        assert(myDataView(2)==2);
1519    
1520        myDataView = myData.getDefaultValue();
1521        assert(myDataView==myView);
1522        assert(!myDataView.isEmpty());
1523        assert(myDataView.getOffset()==0);
1524        assert(myDataView.getRank()==1);
1525        assert(myDataView.noValues()==3);
1526        assert(myDataView.getShape().size()==1);
1527        assert(myDataView(0)==0);
1528        assert(myDataView(1)==1);
1529        assert(myDataView(2)==2);
1530    
1531        // use a non-existent tag so we get a pointer to
1532        // the first element of the data array
1533        double* sampleData=myData.getSampleDataByTag(9);
1534        for (int i=0; i<myData.getLength(); i++) {
1535          assert(sampleData[i]==i%3);
1536        }
1537    
1538      }
1539    
1540      {
1541    
1542        cout << "\tTest adding one key with one value to DataTagged with default value only." << endl;
1543    
1544        DataArrayView::ShapeType viewShape;
1545        viewShape.push_back(3);
1546    
1547        DataTagged::TagListType keys;
1548    
1549        DataTagged::ValueListType values;
1550    
1551        DataArrayView::ValueType viewData(3);
1552        for (int i=0;i<viewShape[0];i++) {
1553          viewData[i]=i;
1554        }
1555        DataArrayView myView(viewData,viewShape);
1556    
1557        DataTagged myData(keys,values,myView,FunctionSpace());
1558    
1559        keys.push_back(1);
1560    
1561        DataArrayView::ValueType viewData1(3);
1562        for (int i=0;i<viewShape[0];i++) {
1563          viewData1[i]=i+3;
1564        }
1565        DataArrayView myView1(viewData1,viewShape);
1566        values.push_back(myView1);
1567    
1568        myData.addTaggedValues(keys,values);
1569    
1570        assert(myData.isCurrentTag(1));
1571    
1572        assert(myData.getTagLookup().size()==1);
1573    
1574        assert(myData.getLength()==6);
1575    
1576        // data-point 0 has tag number 1 by default
1577        assert(myData.getTagNumber(0)==1);
1578    
1579        assert(myData.getPointOffset(0,0)==3);
1580    
1581        DataArrayView myDataView = myData.getDataPoint(0,0);
1582        assert(myDataView==myView1);
1583        assert(!myDataView.isEmpty());
1584        assert(myDataView.getOffset()==3);
1585        assert(myDataView.getRank()==1);
1586        assert(myDataView.noValues()==3);
1587        assert(myDataView.getShape().size()==1);
1588        assert(myDataView(0)==3);
1589        assert(myDataView(1)==4);
1590        assert(myDataView(2)==5);
1591    
1592        myDataView = myData.getDataPointByTag(1);
1593        assert(myDataView==myView1);
1594        assert(!myDataView.isEmpty());
1595        assert(myDataView.getOffset()==3);
1596        assert(myDataView.getRank()==1);
1597        assert(myDataView.noValues()==3);
1598        assert(myDataView.getShape().size()==1);
1599        assert(myDataView(0)==3);
1600        assert(myDataView(1)==4);
1601        assert(myDataView(2)==5);
1602    
1603        myDataView = myData.getDefaultValue();
1604        assert(myDataView==myView);
1605        assert(!myDataView.isEmpty());
1606        assert(myDataView.getOffset()==0);
1607        assert(myDataView.getRank()==1);
1608        assert(myDataView.noValues()==3);
1609        assert(myDataView.getShape().size()==1);
1610        assert(myDataView(0)==0);
1611        assert(myDataView(1)==1);
1612        assert(myDataView(2)==2);
1613    
1614        // use a non-existent tag so we get a pointer to
1615        // the first element of the data array
1616        double* sampleData=myData.getSampleDataByTag(9);
1617        for (int i=0; i<myData.getLength(); i++) {
1618          assert(sampleData[i]==i);
1619        }
1620    
1621      }
1622    
1623      {
1624    
1625        cout << "\tTest adding three keys with one value to DataTagged with default value only." << endl;
1626    
1627        DataArrayView::ShapeType viewShape;
1628        viewShape.push_back(3);
1629    
1630        DataTagged::TagListType keys;
1631    
1632        DataTagged::ValueListType values;
1633    
1634        DataArrayView::ValueType viewData(3);
1635        for (int i=0;i<viewShape[0];i++) {
1636          viewData[i]=i;
1637        }
1638        DataArrayView myView(viewData,viewShape);
1639    
1640        DataTagged myData(keys,values,myView,FunctionSpace());
1641    
1642      keys.push_back(1);      keys.push_back(1);
1643      keys.push_back(2);      keys.push_back(2);
1644      keys.push_back(3);      keys.push_back(3);
1645      values.push_back(tOneView);  
1646      values.push_back(tTwoView);      DataArrayView::ValueType viewData1(3);
1647      values.push_back(tThreeView);      for (int i=0;i<viewShape[0];i++) {
1648      DataTagged tData(keys,values,defView,FunctionSpace());        viewData1[i]=3;
1649      unaryOp(tData,negate<double>());      }
1650      unaryOp(tData,negate<double>());      DataArrayView myView1(viewData1,viewShape);
1651      assert(tData.getDataPointByTag(1)==tOneView);      values.push_back(myView1);
1652      assert(tData.getDataPointByTag(2)==tTwoView);  
1653      assert(tData.getDataPointByTag(3)==tThreeView);      myData.addTaggedValues(keys,values);
1654    
1655        assert(myData.isCurrentTag(1));
1656        assert(myData.isCurrentTag(2));
1657        assert(myData.isCurrentTag(3));
1658    
1659        assert(myData.getTagLookup().size()==3);
1660    
1661        assert(myData.getLength()==12);
1662    
1663        // data-point 0 has tag number 1 by default
1664        assert(myData.getTagNumber(0)==1);
1665    
1666        assert(myData.getPointOffset(0,0)==3);
1667    
1668        DataArrayView myDataView = myData.getDataPoint(0,0);
1669        assert(myDataView==myView1);
1670        assert(!myDataView.isEmpty());
1671        assert(myDataView.getOffset()==3);
1672        assert(myDataView.getRank()==1);
1673        assert(myDataView.noValues()==3);
1674        assert(myDataView.getShape().size()==1);
1675        assert(myDataView(0)==3);
1676        assert(myDataView(1)==3);
1677        assert(myDataView(2)==3);
1678    
1679        myDataView = myData.getDataPointByTag(1);
1680        assert(myDataView==myView1);
1681        assert(!myDataView.isEmpty());
1682        assert(myDataView.getOffset()==3);
1683        assert(myDataView.getRank()==1);
1684        assert(myDataView.noValues()==3);
1685        assert(myDataView.getShape().size()==1);
1686        assert(myDataView(0)==3);
1687        assert(myDataView(1)==3);
1688        assert(myDataView(2)==3);
1689    
1690        myDataView = myData.getDataPointByTag(2);
1691        assert(myDataView==myView1);
1692        assert(!myDataView.isEmpty());
1693        assert(myDataView.getOffset()==6);
1694        assert(myDataView.getRank()==1);
1695        assert(myDataView.noValues()==3);
1696        assert(myDataView.getShape().size()==1);
1697        assert(myDataView(0)==3);
1698        assert(myDataView(1)==3);
1699        assert(myDataView(2)==3);
1700    
1701        myDataView = myData.getDataPointByTag(3);
1702        assert(myDataView==myView1);
1703        assert(!myDataView.isEmpty());
1704        assert(myDataView.getOffset()==9);
1705        assert(myDataView.getRank()==1);
1706        assert(myDataView.noValues()==3);
1707        assert(myDataView.getShape().size()==1);
1708        assert(myDataView(0)==3);
1709        assert(myDataView(1)==3);
1710        assert(myDataView(2)==3);
1711    
1712        myDataView = myData.getDefaultValue();
1713        assert(myDataView==myView);
1714        assert(!myDataView.isEmpty());
1715        assert(myDataView.getOffset()==0);
1716        assert(myDataView.getRank()==1);
1717        assert(myDataView.noValues()==3);
1718        assert(myDataView.getShape().size()==1);
1719        assert(myDataView(0)==0);
1720        assert(myDataView(1)==1);
1721        assert(myDataView(2)==2);
1722    
1723        // use a non-existent tag so we get a pointer to
1724        // the first element of the data array
1725        double* sampleData=myData.getSampleDataByTag(9);
1726        for (int i=0; i<myData.getLength(); i++) {
1727          if (i<3) {
1728            assert(sampleData[i]==i);
1729          } else {
1730            assert(sampleData[i]==3);
1731          }
1732        }
1733    
1734    }    }
1735    
1736      {
1737    
1738        cout << "\tTest adding three keys with three values to DataTagged with default value only." << endl;
1739    
1740        DataArrayView::ShapeType viewShape;
1741        viewShape.push_back(3);
1742    
1743        DataTagged::TagListType keys;
1744    
1745        DataTagged::ValueListType values;
1746    
1747        DataArrayView::ValueType viewData(3);
1748        for (int i=0;i<viewShape[0];i++) {
1749          viewData[i]=i;
1750        }
1751        DataArrayView myView(viewData,viewShape);
1752    
1753        DataTagged myData(keys,values,myView,FunctionSpace());
1754    
1755        keys.push_back(1);
1756        keys.push_back(2);
1757        keys.push_back(3);
1758    
1759        DataArrayView::ValueType viewData1(3);
1760        for (int i=0;i<viewShape[0];i++) {
1761          viewData1[i]=i+1;
1762        }
1763        DataArrayView myView1(viewData1,viewShape);
1764        values.push_back(myView1);
1765    
1766        DataArrayView::ValueType viewData2(3);
1767        for (int i=0;i<viewShape[0];i++) {
1768          viewData2[i]=i+2;
1769        }
1770        DataArrayView myView2(viewData2,viewShape);
1771        values.push_back(myView2);
1772    
1773        DataArrayView::ValueType viewData3(3);
1774        for (int i=0;i<viewShape[0];i++) {
1775          viewData3[i]=i+3;
1776        }
1777        DataArrayView myView3(viewData3,viewShape);
1778        values.push_back(myView3);
1779    
1780        myData.addTaggedValues(keys,values);
1781    
1782        assert(myData.isCurrentTag(1));
1783        assert(myData.isCurrentTag(2));
1784        assert(myData.isCurrentTag(3));
1785    
1786        assert(myData.getTagLookup().size()==3);
1787    
1788        assert(myData.getLength()==12);
1789    
1790        // data-point 0 has tag number 1 by default
1791        assert(myData.getTagNumber(0)==1);
1792    
1793        assert(myData.getPointOffset(0,0)==3);
1794    
1795        DataArrayView myDataView = myData.getDataPoint(0,0);
1796        assert(myDataView==myView1);
1797        assert(!myDataView.isEmpty());
1798        assert(myDataView.getOffset()==3);
1799        assert(myDataView.getRank()==1);
1800        assert(myDataView.noValues()==3);
1801        assert(myDataView.getShape().size()==1);
1802        assert(myDataView(0)==1);
1803        assert(myDataView(1)==2);
1804        assert(myDataView(2)==3);
1805    
1806        myDataView = myData.getDataPointByTag(1);
1807        assert(myDataView==myView1);
1808        assert(!myDataView.isEmpty());
1809        assert(myDataView.getOffset()==3);
1810        assert(myDataView.getRank()==1);
1811        assert(myDataView.noValues()==3);
1812        assert(myDataView.getShape().size()==1);
1813        assert(myDataView(0)==1);
1814        assert(myDataView(1)==2);
1815        assert(myDataView(2)==3);
1816    
1817        myDataView = myData.getDataPointByTag(2);
1818        assert(myDataView==myView2);
1819        assert(!myDataView.isEmpty());
1820        assert(myDataView.getOffset()==6);
1821        assert(myDataView.getRank()==1);
1822        assert(myDataView.noValues()==3);
1823        assert(myDataView.getShape().size()==1);
1824        assert(myDataView(0)==2);
1825        assert(myDataView(1)==3);
1826        assert(myDataView(2)==4);
1827    
1828        myDataView = myData.getDataPointByTag(3);
1829        assert(myDataView==myView3);
1830        assert(!myDataView.isEmpty());
1831        assert(myDataView.getOffset()==9);
1832        assert(myDataView.getRank()==1);
1833        assert(myDataView.noValues()==3);
1834        assert(myDataView.getShape().size()==1);
1835        assert(myDataView(0)==3);
1836        assert(myDataView(1)==4);
1837        assert(myDataView(2)==5);
1838    
1839        myDataView = myData.getDefaultValue();
1840        assert(myDataView==myView);
1841        assert(!myDataView.isEmpty());
1842        assert(myDataView.getOffset()==0);
1843        assert(myDataView.getRank()==1);
1844        assert(myDataView.noValues()==3);
1845        assert(myDataView.getShape().size()==1);
1846        assert(myDataView(0)==0);
1847        assert(myDataView(1)==1);
1848        assert(myDataView(2)==2);
1849    
1850        // use a non-existent tag so we get a pointer to
1851        // the first element of the data array
1852        double* sampleData=myData.getSampleDataByTag(9);
1853        for (int i=0; i<myData.getLength(); i++) {
1854          if (i<3) {
1855            assert(sampleData[i]==i);
1856          } else if ((i>=3) && (i<6)) {
1857            assert(sampleData[i]==i-2);
1858          } else if ((i>=6) && (i<9)) {
1859            assert(sampleData[i]==i-4);
1860          } else  {
1861            assert(sampleData[i]==i-6);
1862          }
1863        }
1864    
1865      }
1866    
1867      {
1868    
1869        cout << "\tTest adding one key with empty value list to DataTagged with three tags." << endl;
1870    
1871        DataTagged::TagListType keys;
1872        keys.push_back(1);
1873        keys.push_back(2);
1874        keys.push_back(3);
1875    
1876        DataTagged::ValueListType values;
1877    
1878        DataArrayView::ShapeType viewShape;
1879        viewShape.push_back(3);
1880    
1881        // default value
1882        DataArrayView::ValueType viewData(3);
1883        for (int i=0;i<viewShape[0];i++) {
1884          viewData[i]=i;
1885        }
1886        DataArrayView myView(viewData,viewShape);
1887    
1888        // value for tag "1"
1889        DataArray eOne(myView);
1890        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1891          eOne.getView()(i)=i+1.0;
1892        }
1893        values.push_back(eOne.getView());
1894    
1895        // value for tag "2"
1896        DataArray eTwo(myView);
1897        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1898          eTwo.getView()(i)=i+2.0;
1899        }
1900        values.push_back(eTwo.getView());
1901    
1902        // value for tag "3"
1903        DataArray eThree(myView);
1904        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1905          eThree.getView()(i)=i+3.0;
1906        }
1907        values.push_back(eThree.getView());
1908    
1909        DataTagged myData(keys,values,myView,FunctionSpace());
1910    
1911        keys.clear();
1912        keys.push_back(4);
1913        values.clear();
1914    
1915        myData.addTaggedValues(keys,values);
1916    
1917        assert(myData.isCurrentTag(4));
1918    
1919        assert(myData.getTagLookup().size()==4);
1920    
1921        assert(myData.getLength()==15);
1922    
1923        DataArrayView myDataView = myData.getDataPointByTag(4);
1924        assert(myDataView==myView);
1925        assert(!myDataView.isEmpty());
1926        assert(myDataView.getOffset()==12);
1927        assert(myDataView.getRank()==1);
1928        assert(myDataView.noValues()==3);
1929        assert(myDataView.getShape().size()==1);
1930        assert(myDataView(0)==0);
1931        assert(myDataView(1)==1);
1932        assert(myDataView(2)==2);
1933    
1934        // use a non-existent tag so we get a pointer to
1935        // the first element of the data array
1936        double* sampleData=myData.getSampleDataByTag(9);
1937        for (int i=0; i<myData.getLength(); i++) {
1938          if (i<3) {
1939            assert(sampleData[i]==i);
1940          } else if ((i>=3) && (i<6)) {
1941            assert(sampleData[i]==i-2);
1942          } else if ((i>=6) && (i<9)) {
1943            assert(sampleData[i]==i-4);
1944          } else if ((i>=9) && (i<12)) {
1945            assert(sampleData[i]==i-6);
1946          } else {
1947            assert(sampleData[i]==i-12);
1948          }
1949        }
1950    
1951      }
1952    
1953      {
1954    
1955        cout << "\tTest adding one key with one value to DataTagged with three tags." << endl;
1956    
1957        DataTagged::TagListType keys;
1958        keys.push_back(1);
1959        keys.push_back(2);
1960        keys.push_back(3);
1961    
1962        DataTagged::ValueListType values;
1963    
1964        DataArrayView::ShapeType viewShape;
1965        viewShape.push_back(3);
1966    
1967        // default value
1968        DataArrayView::ValueType viewData(3);
1969        for (int i=0;i<viewShape[0];i++) {
1970          viewData[i]=i;
1971        }
1972        DataArrayView myView(viewData,viewShape);
1973    
1974        // value for tag "1"
1975        DataArray eOne(myView);
1976        for (int i=0;i<eOne.getView().getShape()[0];i++) {
1977          eOne.getView()(i)=i+1.0;
1978        }
1979        values.push_back(eOne.getView());
1980    
1981        // value for tag "2"
1982        DataArray eTwo(myView);
1983        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
1984          eTwo.getView()(i)=i+2.0;
1985        }
1986        values.push_back(eTwo.getView());
1987    
1988        // value for tag "3"
1989        DataArray eThree(myView);
1990        for (int i=0;i<eThree.getView().getShape()[0];i++) {
1991          eThree.getView()(i)=i+3.0;
1992        }
1993        values.push_back(eThree.getView());
1994    
1995        DataTagged myData(keys,values,myView,FunctionSpace());
1996    
1997        keys.clear();
1998        keys.push_back(4);
1999    
2000        values.clear();
2001        // value for tag "4"
2002        DataArray eFour(myView);
2003        for (int i=0;i<eFour.getView().getShape()[0];i++) {
2004          eFour.getView()(i)=i+4.0;
2005        }
2006        values.push_back(eFour.getView());
2007    
2008        myData.addTaggedValues(keys,values);
2009    
2010        assert(myData.isCurrentTag(4));
2011    
2012        assert(myData.getTagLookup().size()==4);
2013    
2014        assert(myData.getLength()==15);
2015    
2016        DataArrayView myDataView = myData.getDataPointByTag(4);
2017        assert(myDataView==eFour.getView());
2018        assert(!myDataView.isEmpty());
2019        assert(myDataView.getOffset()==12);
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        // use a non-existent tag so we get a pointer to
2028        // the first element of the data array
2029        double* sampleData=myData.getSampleDataByTag(9);
2030        for (int i=0; i<myData.getLength(); i++) {
2031          if (i<3) {
2032            assert(sampleData[i]==i);
2033          } else if ((i>=3) && (i<6)) {
2034            assert(sampleData[i]==i-2);
2035          } else if ((i>=6) && (i<9)) {
2036            assert(sampleData[i]==i-4);
2037          } else if ((i>=9) && (i<12)) {
2038            assert(sampleData[i]==i-6);
2039          } else {
2040            assert(sampleData[i]==i-8);
2041          }
2042        }
2043    
2044      }
2045    
2046      {
2047    
2048        cout << "\tTest adding three keys with one value to DataTagged with three tags." << endl;
2049    
2050        DataTagged::TagListType keys;
2051        keys.push_back(1);
2052        keys.push_back(2);
2053        keys.push_back(3);
2054    
2055        DataTagged::ValueListType values;
2056    
2057        DataArrayView::ShapeType viewShape;
2058        viewShape.push_back(3);
2059    
2060        // default value
2061        DataArrayView::ValueType viewData(3);
2062        for (int i=0;i<viewShape[0];i++) {
2063          viewData[i]=i;
2064        }
2065        DataArrayView myView(viewData,viewShape);
2066    
2067        // value for tag "1"
2068        DataArray eOne(myView);
2069        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2070          eOne.getView()(i)=i+1.0;
2071        }
2072        values.push_back(eOne.getView());
2073    
2074        // value for tag "2"
2075        DataArray eTwo(myView);
2076        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2077          eTwo.getView()(i)=i+2.0;
2078        }
2079        values.push_back(eTwo.getView());
2080    
2081        // value for tag "3"
2082        DataArray eThree(myView);
2083        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2084          eThree.getView()(i)=i+3.0;
2085        }
2086        values.push_back(eThree.getView());
2087    
2088        DataTagged myData(keys,values,myView,FunctionSpace());
2089    
2090        keys.clear();
2091        keys.push_back(4);
2092        keys.push_back(5);
2093        keys.push_back(6);
2094    
2095        values.clear();
2096        // value for tags "4", "5" and "6"
2097        DataArray eFour(myView);
2098        for (int i=0;i<eFour.getView().getShape()[0];i++) {
2099          eFour.getView()(i)=i+4.0;
2100        }
2101        values.push_back(eFour.getView());
2102    
2103        myData.addTaggedValues(keys,values);
2104    
2105        assert(myData.isCurrentTag(4));
2106        assert(myData.isCurrentTag(5));
2107        assert(myData.isCurrentTag(6));
2108    
2109        assert(myData.getTagLookup().size()==6);
2110    
2111        assert(myData.getLength()==21);
2112    
2113        DataArrayView myDataView = myData.getDataPointByTag(4);
2114        assert(myDataView==eFour.getView());
2115        assert(!myDataView.isEmpty());
2116        assert(myDataView.getOffset()==12);
2117        assert(myDataView.getRank()==1);
2118        assert(myDataView.noValues()==3);
2119        assert(myDataView.getShape().size()==1);
2120        assert(myDataView(0)==4);
2121        assert(myDataView(1)==5);
2122        assert(myDataView(2)==6);
2123    
2124        myDataView = myData.getDataPointByTag(5);
2125        assert(myDataView==eFour.getView());
2126        assert(!myDataView.isEmpty());
2127        assert(myDataView.getOffset()==15);
2128        assert(myDataView.getRank()==1);
2129        assert(myDataView.noValues()==3);
2130        assert(myDataView.getShape().size()==1);
2131        assert(myDataView(0)==4);
2132        assert(myDataView(1)==5);
2133        assert(myDataView(2)==6);
2134    
2135        myDataView = myData.getDataPointByTag(6);
2136        assert(myDataView==eFour.getView());
2137        assert(!myDataView.isEmpty());
2138        assert(myDataView.getOffset()==18);
2139        assert(myDataView.getRank()==1);
2140        assert(myDataView.noValues()==3);
2141        assert(myDataView.getShape().size()==1);
2142        assert(myDataView(0)==4);
2143        assert(myDataView(1)==5);
2144        assert(myDataView(2)==6);
2145    
2146        // use a non-existent tag so we get a pointer to
2147        // the first element of the data array
2148        double* sampleData=myData.getSampleDataByTag(9);
2149        for (int i=0; i<myData.getLength(); i++) {
2150          if (i<3) {
2151            assert(sampleData[i]==i);
2152          } else if ((i>=3) && (i<6)) {
2153            assert(sampleData[i]==i-2);
2154          } else if ((i>=6) && (i<9)) {
2155            assert(sampleData[i]==i-4);
2156          } else if ((i>=9) && (i<12)) {
2157            assert(sampleData[i]==i-6);
2158          } else if ((i>=12) && (i<15)) {
2159            assert(sampleData[i]==i-8);
2160          } else if ((i>=15) && (i<18)) {
2161            assert(sampleData[i]==i-11);
2162          } else {
2163            assert(sampleData[i]==i-14);
2164          }
2165        }
2166    
2167      }
2168    
2169      {
2170    
2171        cout << "\tTest adding three keys with three values to DataTagged with three tags." << endl;
2172    
2173        DataTagged::TagListType keys;
2174        keys.push_back(1);
2175        keys.push_back(2);
2176        keys.push_back(3);
2177    
2178        DataTagged::ValueListType values;
2179    
2180        DataArrayView::ShapeType viewShape;
2181        viewShape.push_back(3);
2182    
2183        // default value
2184        DataArrayView::ValueType viewData(3);
2185        for (int i=0;i<viewShape[0];i++) {
2186          viewData[i]=i;
2187        }
2188        DataArrayView myView(viewData,viewShape);
2189    
2190        // value for tag "1"
2191        DataArray eOne(myView);
2192        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2193          eOne.getView()(i)=i+1.0;
2194        }
2195        values.push_back(eOne.getView());
2196    
2197        // value for tag "2"
2198        DataArray eTwo(myView);
2199        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2200          eTwo.getView()(i)=i+2.0;
2201        }
2202        values.push_back(eTwo.getView());
2203    
2204        // value for tag "3"
2205        DataArray eThree(myView);
2206        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2207          eThree.getView()(i)=i+3.0;
2208        }
2209        values.push_back(eThree.getView());
2210    
2211        DataTagged myData(keys,values,myView,FunctionSpace());
2212    
2213        keys.clear();
2214        keys.push_back(4);
2215        keys.push_back(5);
2216        keys.push_back(6);
2217    
2218        values.clear();
2219    
2220        // value for tag "4"
2221        DataArray eFour(myView);
2222        for (int i=0;i<eFour.getView().getShape()[0];i++) {
2223          eFour.getView()(i)=i+4.0;
2224        }
2225        values.push_back(eFour.getView());
2226    
2227        // value for tag "5"
2228        DataArray eFive(myView);
2229        for (int i=0;i<eFive.getView().getShape()[0];i++) {
2230          eFive.getView()(i)=i+5.0;
2231        }
2232        values.push_back(eFive.getView());
2233    
2234        // value for tag "6"
2235        DataArray eSix(myView);
2236        for (int i=0;i<eSix.getView().getShape()[0];i++) {
2237          eSix.getView()(i)=i+6.0;
2238        }
2239        values.push_back(eSix.getView());
2240    
2241        myData.addTaggedValues(keys,values);
2242    
2243        assert(myData.isCurrentTag(4));
2244        assert(myData.isCurrentTag(5));
2245        assert(myData.isCurrentTag(6));
2246    
2247        assert(myData.getTagLookup().size()==6);
2248    
2249        assert(myData.getLength()==21);
2250    
2251        DataArrayView myDataView = myData.getDataPointByTag(4);
2252        assert(myDataView==eFour.getView());
2253        assert(!myDataView.isEmpty());
2254        assert(myDataView.getOffset()==12);
2255        assert(myDataView.getRank()==1);
2256        assert(myDataView.noValues()==3);
2257        assert(myDataView.getShape().size()==1);
2258        assert(myDataView(0)==4);
2259        assert(myDataView(1)==5);
2260        assert(myDataView(2)==6);
2261    
2262        myDataView = myData.getDataPointByTag(5);
2263        assert(myDataView==eFive.getView());
2264        assert(!myDataView.isEmpty());
2265        assert(myDataView.getOffset()==15);
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        myDataView = myData.getDataPointByTag(6);
2274        assert(myDataView==eSix.getView());
2275        assert(!myDataView.isEmpty());
2276        assert(myDataView.getOffset()==18);
2277        assert(myDataView.getRank()==1);
2278        assert(myDataView.noValues()==3);
2279        assert(myDataView.getShape().size()==1);
2280        assert(myDataView(0)==6);
2281        assert(myDataView(1)==7);
2282        assert(myDataView(2)==8);
2283    
2284        // use a non-existent tag so we get a pointer to
2285        // the first element of the data array
2286        double* sampleData=myData.getSampleDataByTag(9);
2287        for (int i=0; i<myData.getLength(); i++) {
2288          if (i<3) {
2289            assert(sampleData[i]==i);
2290          } else if ((i>=3) && (i<6)) {
2291            assert(sampleData[i]==i-2);
2292          } else if ((i>=6) && (i<9)) {
2293            assert(sampleData[i]==i-4);
2294          } else if ((i>=9) && (i<12)) {
2295            assert(sampleData[i]==i-6);
2296          } else if ((i>=12) && (i<15)) {
2297            assert(sampleData[i]==i-8);
2298          } else if ((i>=15) && (i<18)) {
2299            assert(sampleData[i]==i-10);
2300          } else {
2301            assert(sampleData[i]==i-12);
2302          }
2303        }
2304    
2305      }
2306    
2307    }
2308    
2309    void DataTaggedTestCase::testSetTaggedValue() {
2310    
2311      cout << endl;
2312    
2313      {
2314    
2315        cout << "\tTest setting key in DataTagged with three tags." << endl;
2316    
2317        DataTagged::TagListType keys;
2318        keys.push_back(1);
2319        keys.push_back(2);
2320        keys.push_back(3);
2321    
2322        DataTagged::ValueListType values;
2323    
2324        DataArrayView::ShapeType viewShape;
2325        viewShape.push_back(3);
2326    
2327        // default value
2328        DataArrayView::ValueType viewData(3);
2329        for (int i=0;i<viewShape[0];i++) {
2330          viewData[i]=i;
2331        }
2332        DataArrayView myView(viewData,viewShape);
2333    
2334        // value for tag "1"
2335        DataArray eOne(myView);
2336        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2337          eOne.getView()(i)=i+1.0;
2338        }
2339        values.push_back(eOne.getView());
2340    
2341        // value for tag "2"
2342        DataArray eTwo(myView);
2343        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2344          eTwo.getView()(i)=i+2.0;
2345        }
2346        values.push_back(eTwo.getView());
2347    
2348        // value for tag "3"
2349        DataArray eThree(myView);
2350        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2351          eThree.getView()(i)=i+3.0;
2352        }
2353        values.push_back(eThree.getView());
2354    
2355        DataTagged myData(keys,values,myView,FunctionSpace());
2356    
2357        // new value for tag "2"
2358        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2359          eTwo.getView()(i)=i+5.0;
2360        }
2361    
2362        myData.setTaggedValue(2,eTwo.getView());
2363    
2364        assert(myData.isCurrentTag(2));
2365    
2366        assert(myData.getTagLookup().size()==3);
2367    
2368        assert(myData.getLength()==12);
2369    
2370        DataArrayView myDataView = myData.getDataPointByTag(2);
2371        assert(myDataView==eTwo.getView());
2372        assert(!myDataView.isEmpty());
2373        assert(myDataView.getOffset()==6);
2374        assert(myDataView.getRank()==1);
2375        assert(myDataView.noValues()==3);
2376        assert(myDataView.getShape().size()==1);
2377        assert(myDataView(0)==5);
2378        assert(myDataView(1)==6);
2379        assert(myDataView(2)==7);
2380    
2381        // use a non-existent tag so we get a pointer to
2382        // the first element of the data array
2383        double* sampleData=myData.getSampleDataByTag(9);
2384        for (int i=0; i<myData.getLength(); i++) {
2385          if (i<3) {
2386            assert(sampleData[i]==i);
2387          } else if ((i>=3) && (i<6)) {
2388            assert(sampleData[i]==i-2);
2389          } else if ((i>=6) && (i<9)) {
2390            assert(sampleData[i]==i-1);
2391          } else {
2392            assert(sampleData[i]==i-6);
2393          }
2394        }
2395    
2396      }
2397    
2398  }  }
2399    
2400  void DataTaggedTestCase::testAll() {  void DataTaggedTestCase::testAll() {
# Line 192  void DataTaggedTestCase::testAll() { Line 2406  void DataTaggedTestCase::testAll() {
2406      cout << "\tTest default DataTagged." << endl;      cout << "\tTest default DataTagged." << endl;
2407      DataTagged myData;      DataTagged myData;
2408    
2409        //cout << myData.toString() << endl;
2410    
2411      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
2412      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
2413    
# Line 200  void DataTaggedTestCase::testAll() { Line 2416  void DataTaggedTestCase::testAll() {
2416      assert(!myData.validSamplePointNo(1));      assert(!myData.validSamplePointNo(1));
2417      assert(!myData.validSampleNo(1));      assert(!myData.validSampleNo(1));
2418    
2419        // data-point 0 has tag number 1 by default
2420      assert(myData.getTagNumber(0)==1);      assert(myData.getTagNumber(0)==1);
2421    
2422      assert(!myData.isCurrentTag(1));      assert(!myData.isCurrentTag(1));
# Line 210  void DataTaggedTestCase::testAll() { Line 2427  void DataTaggedTestCase::testAll() {
2427    
2428      assert(myData.getPointOffset(0,0)==0);      assert(myData.getPointOffset(0,0)==0);
2429    
     // cout << myData.toString() << endl;  
   
2430      DataArrayView myDataView = myData.getDataPoint(0,0);      DataArrayView myDataView = myData.getDataPoint(0,0);
2431      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2432      assert(myDataView.getOffset()==0);      assert(myDataView.getOffset()==0);
# Line 220  void DataTaggedTestCase::testAll() { Line 2435  void DataTaggedTestCase::testAll() {
2435      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2436      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2437    
2438        // Test non-existent tag returns the default value.
2439      myDataView = myData.getDataPointByTag(1);      myDataView = myData.getDataPointByTag(1);
2440      assert(!myDataView.isEmpty());      assert(!myDataView.isEmpty());
2441      assert(myDataView.getOffset()==0);      assert(myDataView.getOffset()==0);
# Line 236  void DataTaggedTestCase::testAll() { Line 2452  void DataTaggedTestCase::testAll() {
2452      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
2453      assert(myDataView()==0.0);      assert(myDataView()==0.0);
2454    
2455      //assert(myData.getSampleDataByTag(0)[0]==0.0);      // use a non-existent tag so we get a pointer to
2456      //assert(myData.getSampleDataByTag(3)[0]==0.0);      // the first element of the data array
2457      //assert(myData.getSampleDataByTag(472)[0]==0.0);      double* sampleData=myData.getSampleDataByTag(9);
2458        for (int i=0; i<myData.getLength(); i++) {
2459      //cout << "\tTest adding two keys with empty value list." << endl;        assert(sampleData[i]==i);
2460      //DataTagged::TagListType keys;      }
2461      //DataTagged::ValueListType values;      sampleData=myData.getSampleData(0);
2462      //keys.push_back(1);      for (int i=0; i<myDataView.noValues(); i++) {
2463      //keys.push_back(2);        assert(sampleData[i]==i);
2464      //myData.addTaggedValues(keys,values);      }
2465      //for (int i=0;i<keys.size();++i) {  
2466      //  assert(myData.getPointDataView()()==0);    }
2467      //}  
2468    }    {
2469    
2470    {      cout << "\tTest DataTagged with default value only." << endl;
2471  //    cout << "\tCreate tagged data with no tag values just a default." << endl;  
2472   //   DataArrayView::ShapeType viewShape;      DataArrayView::ShapeType viewShape;
2473  //    viewShape.push_back(3);      viewShape.push_back(3);
2474  //    DataArrayView::ValueType viewData(3);  
2475  //    DataTagged::TagListType keys;      DataTagged::TagListType keys;
2476  //    DataTagged::ValueListType values;  
2477  //    for (int i=0;i<viewShape[0];i++) {      DataTagged::ValueListType values;
2478  //      viewData[i]=0.0;  
2479  //    }      DataArrayView::ValueType viewData(3);
2480  //    DataArrayView myView(viewData,viewShape);      for (int i=0;i<viewShape[0];i++) {
2481  //    DataTagged myData(keys,values,myView,FunctionSpace());        viewData[i]=i;
2482  //    assert(myData.getNumDPPSample()==1);      }
2483  //    assert(myData.getNumSamples()==1);      DataArrayView myView(viewData,viewShape);
2484  //    // Test non existent tag returns the default value.  
2485  //    assert(myData.getDataPointByTag(1)==myView);      DataTagged myData(keys,values,myView,FunctionSpace());
2486    
2487      //cout << "\tTest adding a single tag value." << endl;      //cout << myData.toString() << endl;
2488      //for (int i=0;i<myView.getShape()[0];++i) {  
2489      //  myView(i)=i;      assert(myData.getNumSamples()==1);
2490      //}      assert(myData.getNumDPPSample()==1);
2491      //values.push_back(myView);  
2492      //keys.push_back(1);      assert(myData.validSamplePointNo(0));
2493      //myData.addTaggedValues(keys,values);      assert(myData.validSampleNo(0));
2494      //assert(myData.getDataPointByTag(1)==myView);      assert(!myData.validSamplePointNo(1));
2495      //cout << "\tTest addition of further tags." << endl;      assert(!myData.validSampleNo(1));
2496      //keys.resize(0);  
2497      //keys.push_back(3);      // data-point 0 has tag number 1 by default
2498      //for (int i=0;i<myView.getShape()[0];++i) {      assert(myData.getTagNumber(0)==1);
2499      //  myView(i)=i+1.5;  
2500      //}      assert(!myData.isCurrentTag(1));
2501      //myData.addTaggedValues(keys,values);  
2502      //assert(myData.getDataPointByTag(3)==myView);      assert(myData.getTagLookup().size()==0);
2503      //assert(myData.getDataPointByTag(1)!=myView);  
2504      //cout << "\tTrigger the size mismatch exception." << endl;      assert(myData.getLength()==3);
2505      //try {  
2506      //  values.push_back(myView);      assert(myData.getPointOffset(0,0)==0);
2507      //  myData.addTaggedValues(keys,values);  
2508      //  assert(false);      DataArrayView myDataView = myData.getDataPoint(0,0);
2509      //}      assert(myDataView==myView);
2510      //catch (EsysException& e) {      assert(!myDataView.isEmpty());
2511      // assert(true);      assert(myDataView.getOffset()==0);
2512      //}      assert(myDataView.getRank()==1);
2513    }      assert(myDataView.noValues()==3);
2514        assert(myDataView.getShape().size()==1);
2515    {      assert(myDataView(0)==0);
2516  //    cout << "\tTest creation of tagged data with multiple tags." << endl;      assert(myDataView(1)==1);
2517  //    DataArrayView::ShapeType viewShape;      assert(myDataView(2)==2);
2518  //    viewShape.push_back(3);  
2519  //    DataArrayView::ValueType viewData(3);      // Test non-existent tag returns the default value.
2520   //   DataTagged::TagListType keys;      myDataView = myData.getDataPointByTag(1);
2521   //   DataTagged::ValueListType values;      assert(myDataView==myView);
2522  //    for (int i=0;i<viewShape[0];++i) {      assert(!myDataView.isEmpty());
2523  //      viewData[i]=0.0;      assert(myDataView.getOffset()==0);
2524  //    }      assert(myDataView.getRank()==1);
2525  //    DataArrayView myView(viewData,viewShape);      assert(myDataView.noValues()==3);
2526  //    DataArray eOne(myView);      assert(myDataView.getShape().size()==1);
2527  //    DataArray eTwo(myView);      assert(myDataView(0)==0);
2528  //    DataArray eThree(myView);      assert(myDataView(1)==1);
2529  //    for (int i=0;i<eOne.getView().getShape()[0];++i) {      assert(myDataView(2)==2);
2530  //      eOne.getView()(i)=i+1.0;  
2531  //    }      myDataView = myData.getDefaultValue();
2532  //    for (int i=0;i<eTwo.getView().getShape()[0];++i) {      assert(myDataView==myView);
2533  //      eTwo.getView()(i)=i+2.0;      assert(!myDataView.isEmpty());
2534  //    }      assert(myDataView.getOffset()==0);
2535  //    for (int i=0;i<eThree.getView().getShape()[0];++i) {      assert(myDataView.getRank()==1);
2536  //      eThree.getView()(i)=i+3.0;      assert(myDataView.noValues()==3);
2537  //    }      assert(myDataView.getShape().size()==1);
2538  //    values.push_back(eOne.getView());      assert(myDataView(0)==0);
2539  //    values.push_back(eTwo.getView());      assert(myDataView(1)==1);
2540  //    values.push_back(eThree.getView());      assert(myDataView(2)==2);
2541  //    keys.push_back(1);  
2542  //    keys.push_back(2);      // use a non-existent tag so we get a pointer to
2543  //    keys.push_back(3);      // the first element of the data array
2544  //    DataTagged myData(keys,values,myView,FunctionSpace());      double* sampleData=myData.getSampleDataByTag(9);
2545  //    assert(myData.getDataPointByTag(1)==eOne.getView());      for (int i=0; i<myData.getLength(); i++) {
2546  //    assert(myData.getDataPointByTag(2)==eTwo.getView());        assert(sampleData[i]==i);
2547  //    assert(myData.getDataPointByTag(3)==eThree.getView());      }
2548        sampleData=myData.getSampleDataByTag(0);
2549      //cout << "\tTest isCurrentTag function." << endl;      for (int i=0; i<myDataView.noValues(); i++) {
2550      //for (int i=0;i<keys.size();++i) {        assert(sampleData[i]==i);
2551      //  assert(myData.isCurrentTag(keys[i]));      }
2552      //}  
2553      //cout << "\tCheck correct operation for key that doesn't exist." << endl;    }
2554      //assert(!myData.isCurrentTag(123));  
2555      //cout << "\tTrigger bad shape in input values exception." << endl;    {
2556      //viewShape.clear();  
2557      //viewShape.push_back(1);      cout << "\tTest DataTagged with one tag." << endl;
2558      //keys.clear();  
2559      //values.clear();      // the one data-point has tag value "1"
2560      //viewData.resize(1,0.0);  
2561      //DataArrayView myView2(viewData,viewShape);      DataTagged::TagListType keys;
2562      //try {      keys.push_back(1);
2563      //  myData.addTaggedValue(5,myView2);  
2564      //  assert(false);      DataTagged::ValueListType values;
2565      //}  
2566      //catch (EsysException& e) {      DataArrayView::ShapeType viewShape;
2567      //  assert(true);      viewShape.push_back(3);
2568      //}  
2569      //cout << "\tTest addTaggedValues." << endl;      // default value
2570      //DataTagged myData2;      DataArrayView::ValueType viewData(3);
2571      //myData2.reshapeDataPoint(myView.getShape());      for (int i=0;i<viewShape[0];i++) {
2572      //keys.clear();        viewData[i]=i;
2573      //values.clear();      }
2574      //keys.push_back(1);      DataArrayView myView(viewData,viewShape);
2575      //keys.push_back(2);  
2576      //keys.push_back(3);      // value for tag "1"
2577      //values.push_back(eOne.getView());      DataArray eOne(myView);
2578      //values.push_back(eTwo.getView());      for (int i=0;i<eOne.getView().getShape()[0];i++) {
2579      //values.push_back(eThree.getView());        eOne.getView()(i)=i+1.0;
2580      //myData2.addTaggedValues(keys,values);      }
2581      //assert(myData2.getDataPointByTag(1)==eOne.getView());      values.push_back(eOne.getView());
2582      //assert(myData2.getDataPointByTag(2)==eTwo.getView());  
2583      //assert(myData2.getDataPointByTag(3)==eThree.getView());      DataTagged myData(keys,values,myView,FunctionSpace());
2584      //cout << "\tTest setTaggedValue." << endl;  
2585      //DataTagged myData3;      //cout << myData.toString() << endl;
2586      //myData3.reshapeDataPoint(myView.getShape());  
2587      //myData3.addTaggedValue(1,eThree.getView());      assert(myData.getNumSamples()==1);
2588      //myData3.addTaggedValue(2,eOne.getView());      assert(myData.getNumDPPSample()==1);
2589      //myData3.addTaggedValue(3,eTwo.getView());  
2590      //myData3.setTaggedValue(1,eOne.getView());      assert(myData.validSamplePointNo(0));
2591      //myData3.setTaggedValue(2,eTwo.getView());      assert(myData.validSampleNo(0));
2592      //myData3.setTaggedValue(3,eThree.getView());      assert(!myData.validSamplePointNo(1));
2593      //assert(myData3.getDataPointByTag(1)==eOne.getView());      assert(!myData.validSampleNo(1));
2594      //assert(myData3.getDataPointByTag(2)==eTwo.getView());  
2595      //assert(myData3.getDataPointByTag(3)==eThree.getView());      // data-point 0 has tag number 1 by default
2596        assert(myData.getTagNumber(0)==1);
2597    
2598        assert(!myData.isCurrentTag(0));
2599        assert(myData.isCurrentTag(1));
2600    
2601        assert(myData.getTagLookup().size()==1);
2602    
2603        assert(myData.getLength()==6);
2604    
2605        assert(myData.getPointOffset(0,0)==3);
2606    
2607        DataArrayView myDataView = myData.getDataPoint(0,0);
2608        assert(myDataView==eOne.getView());
2609        assert(!myDataView.isEmpty());
2610        assert(myDataView.getOffset()==3);
2611        assert(myDataView.getRank()==1);
2612        assert(myDataView.noValues()==3);
2613        assert(myDataView.getShape().size()==1);
2614        assert(myDataView(0)==1);
2615        assert(myDataView(1)==2);
2616        assert(myDataView(2)==3);
2617    
2618        myDataView = myData.getDataPointByTag(1);
2619        assert(myDataView==eOne.getView());
2620        assert(!myDataView.isEmpty());
2621        assert(myDataView.getOffset()==3);
2622        assert(myDataView.getRank()==1);
2623        assert(myDataView.noValues()==3);
2624        assert(myDataView.getShape().size()==1);
2625        assert(myDataView(0)==1);
2626        assert(myDataView(1)==2);
2627        assert(myDataView(2)==3);
2628    
2629        // Test non-existent tag returns the default value.
2630        myDataView = myData.getDataPointByTag(9);
2631        assert(myDataView==myView);
2632        assert(!myDataView.isEmpty());
2633        assert(myDataView.getOffset()==0);
2634        assert(myDataView.getRank()==1);
2635        assert(myDataView.noValues()==3);
2636        assert(myDataView.getShape().size()==1);
2637        assert(myDataView(0)==0);
2638        assert(myDataView(1)==1);
2639        assert(myDataView(2)==2);
2640    
2641        myDataView = myData.getDefaultValue();
2642        assert(myDataView==myView);
2643        assert(!myDataView.isEmpty());
2644        assert(myDataView.getOffset()==0);
2645        assert(myDataView.getRank()==1);
2646        assert(myDataView.noValues()==3);
2647        assert(myDataView.getShape().size()==1);
2648        assert(myDataView(0)==0);
2649        assert(myDataView(1)==1);
2650        assert(myDataView(2)==2);
2651    
2652        // use a non-existent tag so we get a pointer to
2653        // the first element of the data array
2654        double* sampleData=myData.getSampleDataByTag(9);
2655        for (int i=0; i<myData.getLength(); i++) {
2656          if (i<3) {
2657            assert(sampleData[i]==i);
2658          } else {
2659            assert(sampleData[i]==i-2);
2660          }
2661        }
2662        sampleData=myData.getSampleData(0);
2663        for (int i=0; i<myDataView.noValues(); i++) {
2664          assert(sampleData[i]==i+1);
2665        }
2666    
2667      }
2668    
2669      {
2670    
2671        cout << "\tTest DataTagged with multiple tags." << endl;
2672    
2673        // the one data-point has tag value "1"
2674    
2675        DataTagged::TagListType keys;
2676        keys.push_back(1);
2677        keys.push_back(2);
2678        keys.push_back(3);
2679    
2680        DataTagged::ValueListType values;
2681    
2682        DataArrayView::ShapeType viewShape;
2683        viewShape.push_back(3);
2684    
2685        // default value
2686        DataArrayView::ValueType viewData(3);
2687        for (int i=0;i<viewShape[0];i++) {
2688          viewData[i]=i;
2689        }
2690        DataArrayView myView(viewData,viewShape);
2691    
2692        // value for tag "1"
2693        DataArray eOne(myView);
2694        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2695          eOne.getView()(i)=i+1.0;
2696        }
2697        values.push_back(eOne.getView());
2698    
2699        // value for tag "2"
2700        DataArray eTwo(myView);
2701        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2702          eTwo.getView()(i)=i+2.0;
2703        }
2704        values.push_back(eTwo.getView());
2705    
2706        // value for tag "3"
2707        DataArray eThree(myView);
2708        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2709          eThree.getView()(i)=i+3.0;
2710        }
2711        values.push_back(eThree.getView());
2712    
2713        DataTagged myData(keys,values,myView,FunctionSpace());
2714    
2715        //cout << myData.toString() << endl;
2716    
2717        assert(myData.getNumSamples()==1);
2718        assert(myData.getNumDPPSample()==1);
2719    
2720        assert(myData.validSamplePointNo(0));
2721        assert(myData.validSampleNo(0));
2722        assert(!myData.validSamplePointNo(1));
2723        assert(!myData.validSampleNo(1));
2724    
2725        // data-point 0 has tag number 1 by default
2726        assert(myData.getTagNumber(0)==1);
2727    
2728        assert(!myData.isCurrentTag(0));
2729        assert(myData.isCurrentTag(1));
2730        assert(myData.isCurrentTag(2));
2731        assert(myData.isCurrentTag(3));
2732    
2733        assert(myData.getTagLookup().size()==3);
2734    
2735        assert(myData.getLength()==12);
2736    
2737        assert(myData.getPointOffset(0,0)==3);
2738    
2739        DataArrayView myDataView = myData.getDataPoint(0,0);
2740        assert(myDataView==eOne.getView());
2741        assert(!myDataView.isEmpty());
2742        assert(myDataView.getOffset()==3);
2743        assert(myDataView.getRank()==1);
2744        assert(myDataView.noValues()==3);
2745        assert(myDataView.getShape().size()==1);
2746        assert(myDataView(0)==1);
2747        assert(myDataView(1)==2);
2748        assert(myDataView(2)==3);
2749    
2750        myDataView = myData.getDataPointByTag(1);
2751        assert(myDataView==eOne.getView());
2752        assert(!myDataView.isEmpty());
2753        assert(myDataView.getOffset()==3);
2754        assert(myDataView.getRank()==1);
2755        assert(myDataView.noValues()==3);
2756        assert(myDataView.getShape().size()==1);
2757        assert(myDataView(0)==1);
2758        assert(myDataView(1)==2);
2759        assert(myDataView(2)==3);
2760    
2761        // Test non-existent tag returns the default value.
2762        myDataView = myData.getDataPointByTag(0);
2763        assert(myDataView==myView);
2764        assert(!myDataView.isEmpty());
2765        assert(myDataView.getOffset()==0);
2766        assert(myDataView.getRank()==1);
2767        assert(myDataView.noValues()==3);
2768        assert(myDataView.getShape().size()==1);
2769        assert(myDataView(0)==0);
2770        assert(myDataView(1)==1);
2771        assert(myDataView(2)==2);
2772    
2773        myDataView = myData.getDefaultValue();
2774        assert(myDataView==myView);
2775        assert(!myDataView.isEmpty());
2776        assert(myDataView.getOffset()==0);
2777        assert(myDataView.getRank()==1);
2778        assert(myDataView.noValues()==3);
2779        assert(myDataView.getShape().size()==1);
2780        assert(myDataView(0)==0);
2781        assert(myDataView(1)==1);
2782        assert(myDataView(2)==2);
2783    
2784        // Test data-points held for remaining tags
2785        myDataView = myData.getDataPointByTag(2);
2786        assert(myDataView==eTwo.getView());
2787        assert(!myDataView.isEmpty());
2788        assert(myDataView.getOffset()==6);
2789        assert(myDataView.getRank()==1);
2790        assert(myDataView.noValues()==3);
2791        assert(myDataView.getShape().size()==1);
2792        assert(myDataView(0)==2);
2793        assert(myDataView(1)==3);
2794        assert(myDataView(2)==4);
2795    
2796        myDataView = myData.getDataPointByTag(3);
2797        assert(myDataView==eThree.getView());
2798        assert(!myDataView.isEmpty());
2799        assert(myDataView.getOffset()==9);
2800        assert(myDataView.getRank()==1);
2801        assert(myDataView.noValues()==3);
2802        assert(myDataView.getShape().size()==1);
2803        assert(myDataView(0)==3);
2804        assert(myDataView(1)==4);
2805        assert(myDataView(2)==5);
2806    
2807        // use a non-existent tag so we get a pointer to
2808        // the first element of the data array
2809        double* sampleData=myData.getSampleDataByTag(9);
2810        for (int i=0; i<myData.getLength(); i++) {
2811          if (i<3) {
2812            assert(sampleData[i]==i);
2813          } else if ((i>=3) && (i<6)) {
2814            assert(sampleData[i]==i-2);
2815          } else if ((i>=6) && (i<9)) {
2816            assert(sampleData[i]==i-4);
2817          } else {
2818            assert(sampleData[i]==i-6);
2819          }
2820        }
2821        sampleData=myData.getSampleData(0);
2822        for (int i=0; i<myDataView.noValues(); i++) {
2823          assert(sampleData[i]==i+1);
2824        }
2825    
2826      }
2827    
2828    }
2829    
2830    void DataTaggedTestCase::testCopyConstructors() {
2831    
2832      cout << endl;
2833    
2834      {
2835    
2836        cout << "\tTest DataTagged copy constructor for DataTagged with multiple tags." << endl;
2837    
2838        // the one data-point has tag value "1"
2839    
2840        DataTagged::TagListType keys;
2841        keys.push_back(1);
2842        keys.push_back(2);
2843        keys.push_back(3);
2844    
2845        DataTagged::ValueListType values;
2846    
2847        DataArrayView::ShapeType viewShape;
2848        viewShape.push_back(3);
2849    
2850        // default value
2851        DataArrayView::ValueType viewData(3);
2852        for (int i=0;i<viewShape[0];i++) {
2853          viewData[i]=i;
2854        }
2855        DataArrayView myView(viewData,viewShape);
2856    
2857        // value for tag "1"
2858        DataArray eOne(myView);
2859        for (int i=0;i<eOne.getView().getShape()[0];i++) {
2860          eOne.getView()(i)=i+1.0;
2861        }
2862        values.push_back(eOne.getView());
2863    
2864        // value for tag "2"
2865        DataArray eTwo(myView);
2866        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
2867          eTwo.getView()(i)=i+2.0;
2868        }
2869        values.push_back(eTwo.getView());
2870    
2871        // value for tag "3"
2872        DataArray eThree(myView);
2873        for (int i=0;i<eThree.getView().getShape()[0];i++) {
2874          eThree.getView()(i)=i+3.0;
2875        }
2876        values.push_back(eThree.getView());
2877    
2878        DataTagged myData(keys,values,myView,FunctionSpace());
2879    
2880        DataTagged myDataCopy(myData);
2881    
2882        //cout << myDataCopy.toString() << endl;
2883    
2884        assert(myDataCopy.getNumSamples()==1);
2885        assert(myDataCopy.getNumDPPSample()==1);
2886    
2887        assert(myDataCopy.validSamplePointNo(0));
2888        assert(myDataCopy.validSampleNo(0));
2889        assert(!myDataCopy.validSamplePointNo(1));
2890        assert(!myDataCopy.validSampleNo(1));
2891    
2892        // data-point 0 has tag number 1 by default
2893        assert(myDataCopy.getTagNumber(0)==1);
2894    
2895        assert(!myDataCopy.isCurrentTag(0));
2896        assert(myDataCopy.isCurrentTag(1));
2897        assert(myDataCopy.isCurrentTag(2));
2898        assert(myDataCopy.isCurrentTag(3));
2899    
2900        assert(myDataCopy.getTagLookup().size()==3);
2901    
2902        assert(myDataCopy.getLength()==12);
2903    
2904        assert(myDataCopy.getPointOffset(0,0)==3);
2905    
2906        DataArrayView myDataView = myDataCopy.getDataPoint(0,0);
2907        assert(myDataView==eOne.getView());
2908        assert(!myDataView.isEmpty());
2909        assert(myDataView.getOffset()==3);
2910        assert(myDataView.getRank()==1);
2911        assert(myDataView.noValues()==3);
2912        assert(myDataView.getShape().size()==1);
2913        assert(myDataView(0)==1);
2914        assert(myDataView(1)==2);
2915        assert(myDataView(2)==3);
2916    
2917        myDataView = myDataCopy.getDataPointByTag(1);
2918        assert(myDataView==eOne.getView());
2919        assert(!myDataView.isEmpty());
2920        assert(myDataView.getOffset()==3);
2921        assert(myDataView.getRank()==1);
2922        assert(myDataView.noValues()==3);
2923        assert(myDataView.getShape().size()==1);
2924        assert(myDataView(0)==1);
2925        assert(myDataView(1)==2);
2926        assert(myDataView(2)==3);
2927    
2928        // Test non-existent tag returns the default value.
2929        myDataView = myDataCopy.getDataPointByTag(0);
2930        assert(myDataView==myView);
2931        assert(!myDataView.isEmpty());
2932        assert(myDataView.getOffset()==0);
2933        assert(myDataView.getRank()==1);
2934        assert(myDataView.noValues()==3);
2935        assert(myDataView.getShape().size()==1);
2936        assert(myDataView(0)==0);
2937        assert(myDataView(1)==1);
2938        assert(myDataView(2)==2);
2939    
2940        myDataView = myDataCopy.getDefaultValue();
2941        assert(myDataView==myView);
2942        assert(!myDataView.isEmpty());
2943        assert(myDataView.getOffset()==0);
2944        assert(myDataView.getRank()==1);
2945        assert(myDataView.noValues()==3);
2946        assert(myDataView.getShape().size()==1);
2947        assert(myDataView(0)==0);
2948        assert(myDataView(1)==1);
2949        assert(myDataView(2)==2);
2950    
2951        // Test data-points held for remaining tags
2952        myDataView = myDataCopy.getDataPointByTag(2);
2953        assert(myDataView==eTwo.getView());
2954        assert(!myDataView.isEmpty());
2955        assert(myDataView.getOffset()==6);
2956        assert(myDataView.getRank()==1);
2957        assert(myDataView.noValues()==3);
2958        assert(myDataView.getShape().size()==1);
2959        assert(myDataView(0)==2);
2960        assert(myDataView(1)==3);
2961        assert(myDataView(2)==4);
2962    
2963        myDataView = myDataCopy.getDataPointByTag(3);
2964        assert(myDataView==eThree.getView());
2965        assert(!myDataView.isEmpty());
2966        assert(myDataView.getOffset()==9);
2967        assert(myDataView.getRank()==1);
2968        assert(myDataView.noValues()==3);
2969        assert(myDataView.getShape().size()==1);
2970        assert(myDataView(0)==3);
2971        assert(myDataView(1)==4);
2972        assert(myDataView(2)==5);
2973    
2974        // use a non-existent tag so we get a pointer to
2975        // the first element of the data array
2976        double* sampleData=myDataCopy.getSampleDataByTag(9);
2977        for (int i=0; i<myData.getLength(); i++) {
2978          if (i<3) {
2979            assert(sampleData[i]==i);
2980          } else if ((i>=3) && (i<6)) {
2981            assert(sampleData[i]==i-2);
2982          } else if ((i>=6) && (i<9)) {
2983            assert(sampleData[i]==i-4);
2984          } else {
2985            assert(sampleData[i]==i-6);
2986          }
2987        }
2988    
2989      }
2990    
2991      {
2992    
2993        cout << "\tTest DataTagged copy constructor for DataConstant." << endl;
2994    
2995        // Create a DataConstant
2996        DataArrayView::ShapeType shape;
2997        DataArrayView::ValueType data(DataArrayView::noValues(shape),0);
2998        DataArrayView pointData(data,shape);
2999        pointData()=1.0;
3000        DataConstant myConstantData(pointData, FunctionSpace());
3001    
3002        // use this DataConstant to initialise a DataTagged
3003        DataTagged myData(myConstantData);
3004    
3005        //cout << myData.toString() << endl;
3006    
3007        assert(myData.getNumSamples()==1);
3008        assert(myData.getNumDPPSample()==1);
3009    
3010        assert(myData.validSamplePointNo(0));
3011        assert(myData.validSampleNo(0));
3012        assert(!myData.validSamplePointNo(1));
3013        assert(!myData.validSampleNo(1));
3014    
3015        // data-point 0 has tag number 1 by default
3016        assert(myData.getTagNumber(0)==1);
3017    
3018        assert(!myData.isCurrentTag(1));
3019    
3020        assert(myData.getTagLookup().size()==0);
3021    
3022        assert(myData.getLength()==1);
3023    
3024        assert(myData.getPointOffset(0,0)==0);
3025    
3026        DataArrayView myDataView = myData.getDataPoint(0,0);
3027        assert(!myDataView.isEmpty());
3028        assert(myDataView.getOffset()==0);
3029        assert(myDataView.getRank()==0);
3030        assert(myDataView.noValues()==1);
3031        assert(myDataView.getShape().size()==0);
3032        assert(myDataView()==1.0);
3033    
3034        // Test non-existent tag returns the default value.
3035        myDataView = myData.getDataPointByTag(1);
3036        assert(!myDataView.isEmpty());
3037        assert(myDataView.getOffset()==0);
3038        assert(myDataView.getRank()==0);
3039        assert(myDataView.noValues()==1);
3040        assert(myDataView.getShape().size()==0);
3041        assert(myDataView()==1.0);
3042    
3043        myDataView = myData.getDefaultValue();
3044        assert(!myDataView.isEmpty());
3045        assert(myDataView.getOffset()==0);
3046        assert(myDataView.getRank()==0);
3047        assert(myDataView.noValues()==1);
3048        assert(myDataView.getShape().size()==0);
3049        assert(myDataView()==1.0);
3050    
3051        // use a non-existent tag so we get a pointer to
3052        // the first element of the data array
3053        double* sampleData=myData.getSampleDataByTag(9);
3054        for (int i=0; i<myData.getLength(); i++) {
3055          assert(sampleData[i]==i+1);
3056        }
3057    
3058      }
3059    
3060    }
3061    
3062    void DataTaggedTestCase::testGetSlice() {
3063    
3064      cout << endl;
3065    
3066      {
3067    
3068        cout << "\tTest slicing default DataTagged." << endl;
3069    
3070        DataTagged myData;
3071    
3072        DataArrayView::RegionType region;
3073    
3074        DataAbstract* slicedDefault = myData.getSlice(region);
3075    
3076        // cout << slicedDefault->toString() << endl;
3077    
3078        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3079    
3080        assert(myDataSliced->getTagLookup().size()==0);
3081    
3082        assert(myDataSliced->getLength()==1);
3083    
3084        DataArrayView myDataView = myDataSliced->getDefaultValue();
3085        assert(!myDataView.isEmpty());
3086        assert(myDataView.getOffset()==0);
3087        assert(myDataView.getRank()==0);
3088        assert(myDataView.noValues()==1);
3089        assert(myDataView.getShape().size()==0);
3090        assert(myDataView()==0.0);
3091    
3092      }
3093    
3094      {
3095    
3096        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
3097    
3098        DataArrayView::ShapeType viewShape;
3099        viewShape.push_back(3);
3100    
3101        DataTagged::TagListType keys;
3102    
3103        DataTagged::ValueListType values;
3104    
3105        DataArrayView::ValueType viewData(3);
3106        for (int i=0;i<viewShape[0];i++) {
3107          viewData[i]=i;
3108        }
3109        DataArrayView myView(viewData,viewShape);
3110    
3111        DataTagged myData(keys,values,myView,FunctionSpace());
3112    
3113        // full slice
3114    
3115        std::pair<int, int> region_element;
3116        region_element.first=0;
3117        region_element.second=3;
3118        DataArrayView::RegionType region;
3119        region.push_back(region_element);
3120    
3121        DataAbstract* slicedDefault = myData.getSlice(region);
3122    
3123        //cout << slicedDefault->toString() << endl;
3124    
3125        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3126    
3127        assert(myDataSliced->getTagLookup().size()==0);
3128    
3129        assert(myDataSliced->getLength()==3);
3130    
3131        DataArrayView myDataView = myDataSliced->getDefaultValue();
3132        assert(!myDataView.isEmpty());
3133        assert(myDataView.getOffset()==0);
3134        assert(myDataView.getRank()==1);
3135        assert(myDataView.noValues()==3);
3136        assert(myDataView.getShape().size()==1);
3137        assert(myDataView(0)==0.0);
3138        assert(myDataView(1)==1.0);
3139        assert(myDataView(2)==2.0);
3140    
3141        // scalar slice
3142    
3143        region.clear();
3144        region_element.first=0;
3145        region_element.second=0;
3146        region.push_back(region_element);
3147    
3148        slicedDefault = myData.getSlice(region);
3149    
3150        //cout << slicedDefault->toString() << endl;
3151