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

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

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

revision 510 by jgs, Fri Feb 10 04:00:50 2006 UTC revision 548 by jgs, Tue Feb 21 23:52:41 2006 UTC
# Line 1  Line 1 
1  // $Id$  // $Id$
2    
3  /*  /*
4   *****************************************************************************   *****************************************************************************
5   *                                                                           *   *                                                                           *
# Line 569  void DataTaggedTestCase::testOperations( Line 570  void DataTaggedTestCase::testOperations(
570      DataTagged myData;      DataTagged myData;
571      DataTagged right;      DataTagged right;
572    
573      DataArray vOne(1.0);      // it's important that default values are different, as we need to be able to
574      DataArray vTwo(2.0);      // 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());      myData.addTaggedValue(1,vOne.getView());
583      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
584    
585        //cout << myData.toString() << endl;
586        //cout << right.toString() << endl;
587    
588      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
589    
590        //cout << myData.toString() << endl;
591    
592      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
593      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
594    
# Line 603  void DataTaggedTestCase::testOperations( Line 616  void DataTaggedTestCase::testOperations(
616      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
617      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
618      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
619      assert(myDataView()==1.0);      assert(myDataView()==5.0);
620    
621      // check result value for tag "2"      // check result value for tag "2"
622      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 612  void DataTaggedTestCase::testOperations( Line 625  void DataTaggedTestCase::testOperations(
625      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
626      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
627      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
628      assert(myDataView()==2.0);      assert(myDataView()==5.0);
629    
630      // check result for default value      // check result for default value
631      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 621  void DataTaggedTestCase::testOperations( Line 634  void DataTaggedTestCase::testOperations(
634      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
635      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
636      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
637      assert(myDataView()==0.0);      assert(myDataView()==3.0);
638    
639      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
640      // the first element of the data array      // the first element of the data array
641      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
642      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==3);
643        assert(sampleData[i]==i);      assert(sampleData[1]==5);
644      }      assert(sampleData[2]==5);
645    
646    }    }
647    
# Line 638  void DataTaggedTestCase::testOperations( Line 651  void DataTaggedTestCase::testOperations(
651      DataTagged myData;      DataTagged myData;
652      DataTagged right;      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);      DataArray vOne(1.0);
662      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
663      myData.addTaggedValue(2,vOne.getView());      myData.addTaggedValue(2,vOne.getView());
664      right.addTaggedValue(2,vOne.getView());      right.addTaggedValue(2,vOne.getView());
665      right.addTaggedValue(3,vOne.getView());      right.addTaggedValue(3,vOne.getView());
666    
667        //cout << myData.toString() << endl;
668        //cout << right.toString() << endl;
669    
670      binaryOp(myData,right,plus<double>());      binaryOp(myData,right,plus<double>());
671    
672        //cout << myData.toString() << endl;
673    
674      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
675      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
676    
# Line 674  void DataTaggedTestCase::testOperations( Line 699  void DataTaggedTestCase::testOperations(
699      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
700      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
701      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
702      assert(myDataView()==1.0);      assert(myDataView()==4.0);
703    
704      // check result value for tag "2"      // check result value for tag "2"
705      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 692  void DataTaggedTestCase::testOperations( Line 717  void DataTaggedTestCase::testOperations(
717      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
718      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
719      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
720      assert(myDataView()==1.0);      assert(myDataView()==3.0);
721    
722      // check result for default value      // check result for default value
723      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 701  void DataTaggedTestCase::testOperations( Line 726  void DataTaggedTestCase::testOperations(
726      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
727      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
728      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
729      assert(myDataView()==0.0);      assert(myDataView()==5.0);
730    
731      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
732      // the first element of the data array      // the first element of the data array
733      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
734      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==5);
735        if (i<3) {      assert(sampleData[1]==4);
736          assert(sampleData[i]==i);      assert(sampleData[2]==2);
737        } else {      assert(sampleData[3]==3);
         assert(sampleData[i]==i-2);  
       }  
     }  
738    
739    }    }
740    
# Line 783  void DataTaggedTestCase::testOperations( Line 805  void DataTaggedTestCase::testOperations(
805      DataTagged myData;      DataTagged myData;
806      DataTagged right;      DataTagged right;
807    
808        // it's important that default values are different, as we need to be able to
809        // verify that the tag values in each object are being added to the correct
810        // default values - since the tag lists don't match, the default values will
811        // be used for missing tags in each object
812        myData.getDefaultValue()()=2.0;
813        right.getDefaultValue()()=3.0;
814    
815      DataArray vOne(1.0);      DataArray vOne(1.0);
816      DataArray vTwo(2.0);      DataArray vTwo(2.0);
817      myData.addTaggedValue(1,vOne.getView());      myData.addTaggedValue(1,vOne.getView());
# Line 790  void DataTaggedTestCase::testOperations( Line 819  void DataTaggedTestCase::testOperations(
819      right.addTaggedValue(2,vTwo.getView());      right.addTaggedValue(2,vTwo.getView());
820      right.addTaggedValue(3,vTwo.getView());      right.addTaggedValue(3,vTwo.getView());
821    
822        //cout << myData.toString() << endl;
823        //cout << right.toString() << endl;
824    
825      binaryOp(myData,right,multiplies<double>());      binaryOp(myData,right,multiplies<double>());
826    
827        //cout << myData.toString() << endl;
828    
829      assert(myData.getNumSamples()==1);      assert(myData.getNumSamples()==1);
830      assert(myData.getNumDPPSample()==1);      assert(myData.getNumDPPSample()==1);
831    
# Line 820  void DataTaggedTestCase::testOperations( Line 854  void DataTaggedTestCase::testOperations(
854      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
855      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
856      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
857      assert(myDataView()==0.0);      assert(myDataView()==3.0);
858    
859      // check result value for tag "2"      // check result value for tag "2"
860      myDataView = myData.getDataPointByTag(2);      myDataView = myData.getDataPointByTag(2);
# Line 838  void DataTaggedTestCase::testOperations( Line 872  void DataTaggedTestCase::testOperations(
872      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
873      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
874      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
875      assert(myDataView()==0.0);      assert(myDataView()==4.0);
876    
877      // check result for default value      // check result for default value
878      myDataView = myData.getDefaultValue();      myDataView = myData.getDefaultValue();
# Line 847  void DataTaggedTestCase::testOperations( Line 881  void DataTaggedTestCase::testOperations(
881      assert(myDataView.getRank()==0);      assert(myDataView.getRank()==0);
882      assert(myDataView.noValues()==1);      assert(myDataView.noValues()==1);
883      assert(myDataView.getShape().size()==0);      assert(myDataView.getShape().size()==0);
884      assert(myDataView()==0.0);      assert(myDataView()==6.0);
885    
886      // use a non-existent tag so we get a pointer to      // use a non-existent tag so we get a pointer to
887      // the first element of the data array      // the first element of the data array
888      double* sampleData=myData.getSampleDataByTag(9);      double* sampleData=myData.getSampleDataByTag(9);
889      for (int i=0; i<myData.getLength(); i++) {      assert(sampleData[0]==6);
890        if (i==2) {      assert(sampleData[1]==3);
891          assert(sampleData[i]==2);      assert(sampleData[2]==2);
892        } else {      assert(sampleData[3]==4);
         assert(sampleData[i]==0);  
       }  
     }  
893    
894    }    }
895    
# Line 2951  void DataTaggedTestCase::testCopyConstru Line 2982  void DataTaggedTestCase::testCopyConstru
2982    
2983  }  }
2984    
2985    void DataTaggedTestCase::testGetSlice() {
2986    
2987      cout << endl;
2988    
2989      {
2990    
2991        cout << "\tTest slicing default DataTagged." << endl;
2992    
2993        DataTagged myData;
2994    
2995        DataArrayView::RegionType region;
2996    
2997        DataAbstract* slicedDefault = myData.getSlice(region);
2998    
2999        // cout << slicedDefault->toString() << endl;
3000    
3001        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3002    
3003        assert(myDataSliced->getTagLookup().size()==0);
3004    
3005        assert(myDataSliced->getLength()==1);
3006    
3007        DataArrayView myDataView = myDataSliced->getDefaultValue();
3008        assert(!myDataView.isEmpty());
3009        assert(myDataView.getOffset()==0);
3010        assert(myDataView.getRank()==0);
3011        assert(myDataView.noValues()==1);
3012        assert(myDataView.getShape().size()==0);
3013        assert(myDataView()==0.0);
3014    
3015      }
3016    
3017      {
3018    
3019        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
3020    
3021        DataArrayView::ShapeType viewShape;
3022        viewShape.push_back(3);
3023    
3024        DataTagged::TagListType keys;
3025    
3026        DataTagged::ValueListType values;
3027    
3028        DataArrayView::ValueType viewData(3);
3029        for (int i=0;i<viewShape[0];i++) {
3030          viewData[i]=i;
3031        }
3032        DataArrayView myView(viewData,viewShape);
3033    
3034        DataTagged myData(keys,values,myView,FunctionSpace());
3035    
3036        // full slice
3037    
3038        std::pair<int, int> region_element;
3039        region_element.first=0;
3040        region_element.second=3;
3041        DataArrayView::RegionType region;
3042        region.push_back(region_element);
3043    
3044        DataAbstract* slicedDefault = myData.getSlice(region);
3045    
3046        //cout << slicedDefault->toString() << endl;
3047    
3048        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3049    
3050        assert(myDataSliced->getTagLookup().size()==0);
3051    
3052        assert(myDataSliced->getLength()==3);
3053    
3054        DataArrayView myDataView = myDataSliced->getDefaultValue();
3055        assert(!myDataView.isEmpty());
3056        assert(myDataView.getOffset()==0);
3057        assert(myDataView.getRank()==1);
3058        assert(myDataView.noValues()==3);
3059        assert(myDataView.getShape().size()==1);
3060        assert(myDataView(0)==0.0);
3061        assert(myDataView(1)==1.0);
3062        assert(myDataView(2)==2.0);
3063    
3064        // scalar slice
3065    
3066        region.clear();
3067        region_element.first=0;
3068        region_element.second=0;
3069        region.push_back(region_element);
3070    
3071        slicedDefault = myData.getSlice(region);
3072    
3073        //cout << slicedDefault->toString() << endl;
3074    
3075        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3076    
3077        assert(myDataSliced->getTagLookup().size()==0);
3078    
3079        assert(myDataSliced->getLength()==1);
3080    
3081        myDataView = myDataSliced->getDefaultValue();
3082        assert(!myDataView.isEmpty());
3083        assert(myDataView.getOffset()==0);
3084        assert(myDataView.getRank()==0);
3085        assert(myDataView.noValues()==1);
3086        assert(myDataView.getShape().size()==0);
3087        assert(myDataView()==0.0);
3088    
3089      }
3090    
3091      {
3092    
3093        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
3094    
3095        DataArrayView::ShapeType viewShape;
3096        viewShape.push_back(3);
3097        viewShape.push_back(3);
3098        viewShape.push_back(3);
3099    
3100        DataTagged::TagListType keys;
3101    
3102        DataTagged::ValueListType values;
3103    
3104        DataArrayView::ValueType viewData(27);
3105        for (int i=0;i<viewData.size();i++) {
3106          viewData[i]=i;
3107        }
3108        DataArrayView myView(viewData,viewShape);
3109    
3110        DataTagged myData(keys,values,myView,FunctionSpace());
3111    
3112        //cout << myData.toString() << endl;
3113    
3114        // full slice
3115    
3116        std::pair<int, int> region_element;
3117        region_element.first=0;
3118        region_element.second=3;
3119        DataArrayView::RegionType region;
3120        region.push_back(region_element);
3121        region.push_back(region_element);
3122        region.push_back(region_element);
3123    
3124        DataAbstract* slicedDefault = myData.getSlice(region);
3125    
3126        //cout << slicedDefault->toString() << endl;
3127    
3128        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3129    
3130        assert(myDataSliced->getTagLookup().size()==0);
3131    
3132        assert(myDataSliced->getLength()==27);
3133    
3134        DataArrayView myDataView = myDataSliced->getDefaultValue();
3135        assert(!myDataView.isEmpty());
3136        assert(myDataView.getOffset()==0);
3137        assert(myDataView.getRank()==3);
3138        assert(myDataView.noValues()==27);
3139        assert(myDataView.getShape().size()==3);
3140    
3141        // rank 1 slice
3142    
3143        region.clear();
3144        region.push_back(region_element);
3145        region_element.second=0;
3146        region.push_back(region_element);
3147        region.push_back(region_element);
3148    
3149        slicedDefault = myData.getSlice(region);
3150    
3151        //cout << slicedDefault->toString() << endl;
3152    
3153        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3154    
3155        assert(myDataSliced->getTagLookup().size()==0);
3156    
3157        assert(myDataSliced->getLength()==3);
3158    
3159        myDataView = myDataSliced->getDefaultValue();
3160        assert(!myDataView.isEmpty());
3161        assert(myDataView.getOffset()==0);
3162        assert(myDataView.getRank()==1);
3163        assert(myDataView.noValues()==3);
3164        assert(myDataView.getShape().size()==1);
3165        assert(myDataView(0)==0.0);
3166        assert(myDataView(1)==1.0);
3167        assert(myDataView(2)==2.0);
3168    
3169        // scalar slice
3170    
3171        region.clear();
3172        region_element.first=2;
3173        region_element.second=2;
3174        region.push_back(region_element);
3175        region.push_back(region_element);
3176        region.push_back(region_element);
3177    
3178        slicedDefault = myData.getSlice(region);
3179    
3180        //cout << slicedDefault->toString() << endl;
3181    
3182        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3183    
3184        assert(myDataSliced->getTagLookup().size()==0);
3185    
3186        assert(myDataSliced->getLength()==1);
3187    
3188        myDataView = myDataSliced->getDefaultValue();
3189        assert(!myDataView.isEmpty());
3190        assert(myDataView.getOffset()==0);
3191        assert(myDataView.getRank()==0);
3192        assert(myDataView.noValues()==1);
3193        assert(myDataView.getShape().size()==0);
3194        assert(myDataView()==26);
3195    
3196      }
3197    
3198      {
3199    
3200        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
3201    
3202        DataTagged::TagListType keys;
3203        keys.push_back(1);
3204    
3205        DataTagged::ValueListType values;
3206    
3207        DataArrayView::ShapeType viewShape;
3208    
3209        // default value
3210        DataArrayView::ValueType viewData(1);
3211        viewData[0]=0.0;
3212        DataArrayView myView(viewData,viewShape);
3213    
3214        // value for tag "1"
3215        DataArray eOne(myView);
3216        eOne.getView()()=1.0;
3217        values.push_back(eOne.getView());
3218    
3219        DataTagged myData(keys,values,myView,FunctionSpace());
3220    
3221        //cout << myData.toString() << endl;
3222    
3223        // full slice
3224    
3225        DataArrayView::RegionType region;
3226    
3227        DataAbstract* slicedDefault = myData.getSlice(region);
3228    
3229        //cout << slicedDefault->toString() << endl;
3230    
3231        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3232    
3233        assert(myDataSliced->getTagLookup().size()==1);
3234    
3235        assert(myDataSliced->getLength()==2);
3236    
3237        DataArrayView myDataView = myDataSliced->getDefaultValue();
3238        assert(!myDataView.isEmpty());
3239        assert(myDataView.getOffset()==0);
3240        assert(myDataView.getRank()==0);
3241        assert(myDataView.noValues()==1);
3242        assert(myDataView.getShape().size()==0);
3243        assert(myDataView()==0);
3244    
3245        myDataView = myDataSliced->getDataPointByTag(1);
3246        assert(!myDataView.isEmpty());
3247        assert(myDataView.getOffset()==1);
3248        assert(myDataView.getRank()==0);
3249        assert(myDataView.noValues()==1);
3250        assert(myDataView.getShape().size()==0);
3251        assert(myDataView()==1);
3252    
3253      }
3254    
3255      {
3256    
3257        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
3258    
3259        DataArrayView::ShapeType viewShape;
3260        viewShape.push_back(3);
3261    
3262        DataTagged::TagListType keys;
3263        keys.push_back(1);
3264    
3265        DataTagged::ValueListType values;
3266    
3267        // default value
3268        DataArrayView::ValueType viewData(3);
3269        for (int i=0;i<viewShape[0];i++) {
3270          viewData[i]=i;
3271        }
3272        DataArrayView myView(viewData,viewShape);
3273    
3274        // value for tag "1"
3275        DataArray eOne(myView);
3276        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3277          eOne.getView()(i)=i+3.0;
3278        }
3279        values.push_back(eOne.getView());
3280    
3281        DataTagged myData(keys,values,myView,FunctionSpace());
3282    
3283        //cout << myData.toString() << endl;
3284    
3285        // full slice
3286    
3287        std::pair<int, int> region_element;
3288        region_element.first=0;
3289        region_element.second=3;
3290        DataArrayView::RegionType region;
3291        region.push_back(region_element);
3292    
3293        DataAbstract* slicedDefault = myData.getSlice(region);
3294    
3295        //cout << slicedDefault->toString() << endl;
3296    
3297        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3298    
3299        assert(myDataSliced->getTagLookup().size()==1);
3300    
3301        assert(myDataSliced->getLength()==6);
3302    
3303        DataArrayView myDataView = myDataSliced->getDefaultValue();
3304        assert(!myDataView.isEmpty());
3305        assert(myDataView.getOffset()==0);
3306        assert(myDataView.getRank()==1);
3307        assert(myDataView.noValues()==3);
3308        assert(myDataView.getShape().size()==1);
3309        assert(myDataView(0)==0);
3310        assert(myDataView(1)==1);
3311        assert(myDataView(2)==2);
3312    
3313        myDataView = myDataSliced->getDataPointByTag(1);
3314        assert(!myDataView.isEmpty());
3315        assert(myDataView.getOffset()==3);
3316        assert(myDataView.getRank()==1);
3317        assert(myDataView.noValues()==3);
3318        assert(myDataView.getShape().size()==1);
3319        assert(myDataView(0)==3);
3320        assert(myDataView(1)==4);
3321        assert(myDataView(2)==5);
3322    
3323        // scalar slice
3324    
3325        region_element.first=1;
3326        region_element.second=1;
3327        region.clear();
3328        region.push_back(region_element);
3329    
3330        slicedDefault = myData.getSlice(region);
3331    
3332        //cout << slicedDefault->toString() << endl;
3333    
3334        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3335    
3336        assert(myDataSliced->getTagLookup().size()==1);
3337    
3338        assert(myDataSliced->getLength()==2);
3339    
3340        myDataView = myDataSliced->getDefaultValue();
3341        assert(!myDataView.isEmpty());
3342        assert(myDataView.getOffset()==0);
3343        assert(myDataView.getRank()==0);
3344        assert(myDataView.noValues()==1);
3345        assert(myDataView.getShape().size()==0);
3346        assert(myDataView()==1);
3347    
3348        myDataView = myDataSliced->getDataPointByTag(1);
3349        assert(!myDataView.isEmpty());
3350        assert(myDataView.getOffset()==1);
3351        assert(myDataView.getRank()==0);
3352        assert(myDataView.noValues()==1);
3353        assert(myDataView.getShape().size()==0);
3354        assert(myDataView()==4);
3355    
3356      }
3357    
3358      {
3359    
3360        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
3361    
3362        DataArrayView::ShapeType viewShape;
3363        viewShape.push_back(3);
3364        viewShape.push_back(3);
3365        viewShape.push_back(3);
3366    
3367        DataTagged::TagListType keys;
3368        keys.push_back(1);
3369    
3370        DataTagged::ValueListType values;
3371    
3372        // default value
3373        DataArrayView::ValueType viewData(27);
3374        for (int i=0;i<viewData.size();i++) {
3375          viewData[i]=i;
3376        }
3377        DataArrayView myView(viewData,viewShape);
3378    
3379        // value for tag "1"
3380        DataArrayView::ValueType viewData1(27);
3381        for (int i=0;i<viewData1.size();i++) {
3382          viewData1[i]=i+27.0;
3383        }
3384        DataArrayView myView1(viewData1,viewShape);
3385        values.push_back(myView1);
3386    
3387        DataTagged myData(keys,values,myView,FunctionSpace());
3388    
3389        //cout << myData.toString() << endl;
3390    
3391        // full slice
3392    
3393        std::pair<int, int> region_element;
3394        region_element.first=0;
3395        region_element.second=3;
3396        DataArrayView::RegionType region;
3397        region.push_back(region_element);
3398        region.push_back(region_element);
3399        region.push_back(region_element);
3400    
3401        DataAbstract* slicedDefault = myData.getSlice(region);
3402    
3403        //cout << slicedDefault->toString() << endl;
3404    
3405        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3406    
3407        assert(myDataSliced->getTagLookup().size()==1);
3408    
3409        assert(myDataSliced->getLength()==54);
3410    
3411        DataArrayView myDataView = myDataSliced->getDefaultValue();
3412        assert(!myDataView.isEmpty());
3413        assert(myDataView.getOffset()==0);
3414        assert(myDataView.getRank()==3);
3415        assert(myDataView.noValues()==27);
3416        assert(myDataView.getShape().size()==3);
3417    
3418        myDataView = myDataSliced->getDataPointByTag(1);
3419        assert(!myDataView.isEmpty());
3420        assert(myDataView.getOffset()==27);
3421        assert(myDataView.getRank()==3);
3422        assert(myDataView.noValues()==27);
3423        assert(myDataView.getShape().size()==3);
3424    
3425        // rank 1 slice
3426    
3427        region.clear();
3428        region.push_back(region_element);
3429        region_element.second=0;
3430        region.push_back(region_element);
3431        region.push_back(region_element);
3432    
3433        slicedDefault = myData.getSlice(region);
3434    
3435        //cout << slicedDefault->toString() << endl;
3436    
3437        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3438    
3439        assert(myDataSliced->getTagLookup().size()==1);
3440    
3441        assert(myDataSliced->getLength()==6);
3442    
3443        myDataView = myDataSliced->getDefaultValue();
3444        assert(!myDataView.isEmpty());
3445        assert(myDataView.getOffset()==0);
3446        assert(myDataView.getRank()==1);
3447        assert(myDataView.noValues()==3);
3448        assert(myDataView.getShape().size()==1);
3449        assert(myDataView(0)==0);
3450        assert(myDataView(1)==1);
3451        assert(myDataView(2)==2);
3452    
3453        myDataView = myDataSliced->getDataPointByTag(1);
3454        assert(!myDataView.isEmpty());
3455        assert(myDataView.getOffset()==3);
3456        assert(myDataView.getRank()==1);
3457        assert(myDataView.noValues()==3);
3458        assert(myDataView.getShape().size()==1);
3459        assert(myDataView(0)==27);
3460        assert(myDataView(1)==28);
3461        assert(myDataView(2)==29);
3462    
3463        // scalar slice
3464    
3465        region_element.first=1;
3466        region_element.second=1;
3467        region.clear();
3468        region.push_back(region_element);
3469        region.push_back(region_element);
3470        region.push_back(region_element);
3471    
3472        slicedDefault = myData.getSlice(region);
3473    
3474        //cout << slicedDefault->toString() << endl;
3475    
3476        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3477    
3478        assert(myDataSliced->getTagLookup().size()==1);
3479    
3480        assert(myDataSliced->getLength()==2);
3481    
3482        myDataView = myDataSliced->getDefaultValue();
3483        assert(!myDataView.isEmpty());
3484        assert(myDataView.getOffset()==0);
3485        assert(myDataView.getRank()==0);
3486        assert(myDataView.noValues()==1);
3487        assert(myDataView.getShape().size()==0);
3488        assert(myDataView()==13);
3489    
3490        myDataView = myDataSliced->getDataPointByTag(1);
3491        assert(!myDataView.isEmpty());
3492        assert(myDataView.getOffset()==1);
3493        assert(myDataView.getRank()==0);
3494        assert(myDataView.noValues()==1);
3495        assert(myDataView.getShape().size()==0);
3496        assert(myDataView()==40);
3497    
3498      }
3499    
3500      {
3501    
3502        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
3503    
3504        DataTagged::TagListType keys;
3505        keys.push_back(1);
3506        keys.push_back(2);
3507        keys.push_back(3);
3508    
3509        DataTagged::ValueListType values;
3510    
3511        DataArrayView::ShapeType viewShape;
3512    
3513        // default value
3514        DataArrayView::ValueType viewData(1);
3515        viewData[0]=0.0;
3516        DataArrayView myView(viewData,viewShape);
3517    
3518        // value for tag "1"
3519        DataArray eOne(myView);
3520        eOne.getView()()=1.0;
3521        values.push_back(eOne.getView());
3522    
3523        // value for tag "2"
3524        DataArray eTwo(myView);
3525        eTwo.getView()()=2.0;
3526        values.push_back(eTwo.getView());
3527    
3528        // value for tag "3"
3529        DataArray eThree(myView);
3530        eThree.getView()()=3.0;
3531        values.push_back(eThree.getView());
3532    
3533        DataTagged myData(keys,values,myView,FunctionSpace());
3534    
3535        // cout << myData.toString() << endl;
3536    
3537        // full slice
3538    
3539        DataArrayView::RegionType region;
3540    
3541        DataAbstract* slicedDefault = myData.getSlice(region);
3542    
3543        //cout << slicedDefault->toString() << endl;
3544    
3545        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3546    
3547        assert(myDataSliced->getTagLookup().size()==3);
3548    
3549        assert(myDataSliced->getLength()==4);
3550    
3551        DataArrayView myDataView = myDataSliced->getDefaultValue();
3552        assert(!myDataView.isEmpty());
3553        assert(myDataView.getOffset()==0);
3554        assert(myDataView.getRank()==0);
3555        assert(myDataView.noValues()==1);
3556        assert(myDataView.getShape().size()==0);
3557        assert(myDataView()==0);
3558    
3559        myDataView = myDataSliced->getDataPointByTag(1);
3560        assert(!myDataView.isEmpty());
3561        assert(myDataView.getOffset()==1);
3562        assert(myDataView.getRank()==0);
3563        assert(myDataView.noValues()==1);
3564        assert(myDataView.getShape().size()==0);
3565        assert(myDataView()==1);
3566    
3567        myDataView = myDataSliced->getDataPointByTag(2);
3568        assert(!myDataView.isEmpty());
3569        assert(myDataView.getOffset()==2);
3570        assert(myDataView.getRank()==0);
3571        assert(myDataView.noValues()==1);
3572        assert(myDataView.getShape().size()==0);
3573        assert(myDataView()==2);
3574    
3575        myDataView = myDataSliced->getDataPointByTag(3);
3576        assert(!myDataView.isEmpty());
3577        assert(myDataView.getOffset()==3);
3578        assert(myDataView.getRank()==0);
3579        assert(myDataView.noValues()==1);
3580        assert(myDataView.getShape().size()==0);
3581        assert(myDataView()==3);
3582    
3583      }
3584    
3585      {
3586    
3587        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
3588    
3589        DataArrayView::ShapeType viewShape;
3590        viewShape.push_back(3);
3591    
3592        DataTagged::TagListType keys;
3593        keys.push_back(1);
3594        keys.push_back(2);
3595        keys.push_back(3);
3596    
3597        DataTagged::ValueListType values;
3598    
3599        // default value
3600        DataArrayView::ValueType viewData(3);
3601        for (int i=0;i<viewShape[0];i++) {
3602          viewData[i]=i;
3603        }
3604        DataArrayView myView(viewData,viewShape);
3605    
3606        // value for tag "1"
3607        DataArray eOne(myView);
3608        for (int i=0;i<eOne.getView().getShape()[0];i++) {
3609          eOne.getView()(i)=i+3.0;
3610        }
3611        values.push_back(eOne.getView());
3612    
3613        // value for tag "2"
3614        DataArray eTwo(myView);
3615        for (int i=0;i<eTwo.getView().getShape()[0];i++) {
3616          eTwo.getView()(i)=i+6.0;
3617        }
3618        values.push_back(eTwo.getView());
3619    
3620        // value for tag "3"
3621        DataArray eThree(myView);
3622        for (int i=0;i<eThree.getView().getShape()[0];i++) {
3623          eThree.getView()(i)=i+9.0;
3624        }
3625        values.push_back(eThree.getView());
3626    
3627        DataTagged myData(keys,values,myView,FunctionSpace());
3628    
3629        //cout << myData.toString() << endl;
3630    
3631        // full slice
3632    
3633        std::pair<int, int> region_element;
3634        region_element.first=0;
3635        region_element.second=3;
3636        DataArrayView::RegionType region;
3637        region.push_back(region_element);
3638    
3639        DataAbstract* slicedDefault = myData.getSlice(region);
3640    
3641        //cout << slicedDefault->toString() << endl;
3642    
3643        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3644    
3645        assert(myDataSliced->getTagLookup().size()==3);
3646    
3647        assert(myDataSliced->getLength()==12);
3648    
3649        DataArrayView myDataView = myDataSliced->getDefaultValue();
3650        assert(!myDataView.isEmpty());
3651        assert(myDataView.getOffset()==0);
3652        assert(myDataView.getRank()==1);
3653        assert(myDataView.noValues()==3);
3654        assert(myDataView.getShape().size()==1);
3655        assert(myDataView(0)==0);
3656        assert(myDataView(1)==1);
3657        assert(myDataView(2)==2);
3658    
3659        myDataView = myDataSliced->getDataPointByTag(1);
3660        assert(!myDataView.isEmpty());
3661        assert(myDataView.getOffset()==3);
3662        assert(myDataView.getRank()==1);
3663        assert(myDataView.noValues()==3);
3664        assert(myDataView.getShape().size()==1);
3665        assert(myDataView(0)==3);
3666        assert(myDataView(1)==4);
3667        assert(myDataView(2)==5);
3668    
3669        myDataView = myDataSliced->getDataPointByTag(2);
3670        assert(!myDataView.isEmpty());
3671        assert(myDataView.getOffset()==6);
3672        assert(myDataView.getRank()==1);
3673        assert(myDataView.noValues()==3);
3674        assert(myDataView.getShape().size()==1);
3675        assert(myDataView(0)==6);
3676        assert(myDataView(1)==7);
3677        assert(myDataView(2)==8);
3678    
3679        myDataView = myDataSliced->getDataPointByTag(3);
3680        assert(!myDataView.isEmpty());
3681        assert(myDataView.getOffset()==9);
3682        assert(myDataView.getRank()==1);
3683        assert(myDataView.noValues()==3);
3684        assert(myDataView.getShape().size()==1);
3685        assert(myDataView(0)==9);
3686        assert(myDataView(1)==10);
3687        assert(myDataView(2)==11);
3688    
3689        // scalar slice
3690    
3691        region.clear();
3692        region_element.first=1;
3693        region_element.second=1;
3694        region.push_back(region_element);
3695    
3696        slicedDefault = myData.getSlice(region);
3697    
3698        //cout << slicedDefault->toString() << endl;
3699    
3700        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3701    
3702        assert(myDataSliced->getTagLookup().size()==3);
3703    
3704        assert(myDataSliced->getLength()==4);
3705    
3706        myDataView = myDataSliced->getDefaultValue();
3707        assert(!myDataView.isEmpty());
3708        assert(myDataView.getOffset()==0);
3709        assert(myDataView.getRank()==0);
3710        assert(myDataView.noValues()==1);
3711        assert(myDataView.getShape().size()==0);
3712        assert(myDataView()==1);
3713    
3714        myDataView = myDataSliced->getDataPointByTag(1);
3715        assert(!myDataView.isEmpty());
3716        assert(myDataView.getOffset()==1);
3717        assert(myDataView.getRank()==0);
3718        assert(myDataView.noValues()==1);
3719        assert(myDataView.getShape().size()==0);
3720        assert(myDataView()==4);
3721    
3722        myDataView = myDataSliced->getDataPointByTag(2);
3723        assert(!myDataView.isEmpty());
3724        assert(myDataView.getOffset()==2);
3725        assert(myDataView.getRank()==0);
3726        assert(myDataView.noValues()==1);
3727        assert(myDataView.getShape().size()==0);
3728        assert(myDataView()==7);
3729    
3730        myDataView = myDataSliced->getDataPointByTag(3);
3731        assert(!myDataView.isEmpty());
3732        assert(myDataView.getOffset()==3);
3733        assert(myDataView.getRank()==0);
3734        assert(myDataView.noValues()==1);
3735        assert(myDataView.getShape().size()==0);
3736        assert(myDataView()==10);
3737    
3738      }
3739    
3740      {
3741    
3742        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
3743    
3744        DataArrayView::ShapeType viewShape;
3745        viewShape.push_back(3);
3746        viewShape.push_back(3);
3747        viewShape.push_back(3);
3748    
3749        DataTagged::TagListType keys;
3750        keys.push_back(1);
3751        keys.push_back(2);
3752        keys.push_back(3);
3753    
3754        DataTagged::ValueListType values;
3755    
3756        // default value
3757        DataArrayView::ValueType viewData(27);
3758        for (int i=0;i<viewData.size();i++) {
3759          viewData[i]=i;
3760        }
3761        DataArrayView myView(viewData,viewShape);
3762    
3763        // value for tag "1"
3764        DataArrayView::ValueType viewData1(27);
3765        for (int i=0;i<viewData1.size();i++) {
3766          viewData1[i]=i+27.0;
3767        }
3768        DataArrayView myView1(viewData1,viewShape);
3769        values.push_back(myView1);
3770    
3771        // value for tag "2"
3772        DataArrayView::ValueType viewData2(27);
3773        for (int i=0;i<viewData2.size();i++) {
3774          viewData2[i]=i+54.0;
3775        }
3776        DataArrayView myView2(viewData2,viewShape);
3777        values.push_back(myView2);
3778    
3779        // value for tag "3"
3780        DataArrayView::ValueType viewData3(27);
3781        for (int i=0;i<viewData3.size();i++) {
3782          viewData3[i]=i+81.0;
3783        }
3784        DataArrayView myView3(viewData3,viewShape);
3785        values.push_back(myView3);
3786    
3787        DataTagged myData(keys,values,myView,FunctionSpace());
3788    
3789        //cout << myData.toString() << endl;
3790    
3791        // full slice
3792    
3793        std::pair<int, int> region_element;
3794        region_element.first=0;
3795        region_element.second=3;
3796        DataArrayView::RegionType region;
3797        region.push_back(region_element);
3798        region.push_back(region_element);
3799        region.push_back(region_element);
3800    
3801        DataAbstract* slicedDefault = myData.getSlice(region);
3802    
3803        //cout << slicedDefault->toString() << endl;
3804    
3805        const DataTagged* myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3806    
3807        assert(myDataSliced->getTagLookup().size()==3);
3808    
3809        assert(myDataSliced->getLength()==108);
3810    
3811        DataArrayView myDataView = myDataSliced->getDefaultValue();
3812        assert(!myDataView.isEmpty());
3813        assert(myDataView.getOffset()==0);
3814        assert(myDataView.getRank()==3);
3815        assert(myDataView.noValues()==27);
3816        assert(myDataView.getShape().size()==3);
3817    
3818        myDataView = myDataSliced->getDataPointByTag(1);
3819        assert(!myDataView.isEmpty());
3820        assert(myDataView.getOffset()==27);
3821        assert(myDataView.getRank()==3);
3822        assert(myDataView.noValues()==27);
3823        assert(myDataView.getShape().size()==3);
3824    
3825        myDataView = myDataSliced->getDataPointByTag(2);
3826        assert(!myDataView.isEmpty());
3827        assert(myDataView.getOffset()==54);
3828        assert(myDataView.getRank()==3);
3829        assert(myDataView.noValues()==27);
3830        assert(myDataView.getShape().size()==3);
3831    
3832        myDataView = myDataSliced->getDataPointByTag(3);
3833        assert(!myDataView.isEmpty());
3834        assert(myDataView.getOffset()==81);
3835        assert(myDataView.getRank()==3);
3836        assert(myDataView.noValues()==27);
3837        assert(myDataView.getShape().size()==3);
3838    
3839        // rank 1 slice
3840    
3841        region.clear();
3842        region.push_back(region_element);
3843        region_element.second=0;
3844        region.push_back(region_element);
3845        region.push_back(region_element);
3846    
3847        slicedDefault = myData.getSlice(region);
3848    
3849        // cout << slicedDefault->toString() << endl;
3850    
3851        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3852    
3853        assert(myDataSliced->getTagLookup().size()==3);
3854    
3855        assert(myDataSliced->getLength()==12);
3856    
3857        myDataView = myDataSliced->getDefaultValue();
3858        assert(!myDataView.isEmpty());
3859        assert(myDataView.getOffset()==0);
3860        assert(myDataView.getRank()==1);
3861        assert(myDataView.noValues()==3);
3862        assert(myDataView.getShape().size()==1);
3863        assert(myDataView(0)==0);
3864        assert(myDataView(1)==1);
3865        assert(myDataView(2)==2);
3866    
3867        myDataView = myDataSliced->getDataPointByTag(1);
3868        assert(!myDataView.isEmpty());
3869        assert(myDataView.getOffset()==3);
3870        assert(myDataView.getRank()==1);
3871        assert(myDataView.noValues()==3);
3872        assert(myDataView.getShape().size()==1);
3873        assert(myDataView(0)==27);
3874        assert(myDataView(1)==28);
3875        assert(myDataView(2)==29);
3876    
3877        myDataView = myDataSliced->getDataPointByTag(2);
3878        assert(!myDataView.isEmpty());
3879        assert(myDataView.getOffset()==6);
3880        assert(myDataView.getRank()==1);
3881        assert(myDataView.noValues()==3);
3882        assert(myDataView.getShape().size()==1);
3883        assert(myDataView(0)==54);
3884        assert(myDataView(1)==55);
3885        assert(myDataView(2)==56);
3886    
3887        myDataView = myDataSliced->getDataPointByTag(3);
3888        assert(!myDataView.isEmpty());
3889        assert(myDataView.getOffset()==9);
3890        assert(myDataView.getRank()==1);
3891        assert(myDataView.noValues()==3);
3892        assert(myDataView.getShape().size()==1);
3893        assert(myDataView(0)==81);
3894        assert(myDataView(1)==82);
3895        assert(myDataView(2)==83);
3896    
3897        // scalar slice
3898    
3899        region_element.first=1;
3900        region_element.second=1;
3901        region.clear();
3902        region.push_back(region_element);
3903        region.push_back(region_element);
3904        region.push_back(region_element);
3905    
3906        slicedDefault = myData.getSlice(region);
3907    
3908        //cout << slicedDefault->toString() << endl;
3909    
3910        myDataSliced=dynamic_cast<const DataTagged*>(slicedDefault);
3911    
3912        assert(myDataSliced->getTagLookup().size()==3);
3913    
3914        assert(myDataSliced->getLength()==4);
3915    
3916        myDataView = myDataSliced->getDefaultValue();
3917        assert(!myDataView.isEmpty());
3918        assert(myDataView.getOffset()==0);
3919        assert(myDataView.getRank()==0);
3920        assert(myDataView.noValues()==1);
3921        assert(myDataView.getShape().size()==0);
3922        assert(myDataView()==13);
3923    
3924        myDataView = myDataSliced->getDataPointByTag(1);
3925        assert(!myDataView.isEmpty());
3926        assert(myDataView.getOffset()==1);
3927        assert(myDataView.getRank()==0);
3928        assert(myDataView.noValues()==1);
3929        assert(myDataView.getShape().size()==0);
3930        assert(myDataView()==40);
3931    
3932        myDataView = myDataSliced->getDataPointByTag(2);
3933        assert(!myDataView.isEmpty());
3934        assert(myDataView.getOffset()==2);
3935        assert(myDataView.getRank()==0);
3936        assert(myDataView.noValues()==1);
3937        assert(myDataView.getShape().size()==0);
3938        assert(myDataView()==67);
3939    
3940        myDataView = myDataSliced->getDataPointByTag(3);
3941        assert(!myDataView.isEmpty());
3942        assert(myDataView.getOffset()==3);
3943        assert(myDataView.getRank()==0);
3944        assert(myDataView.noValues()==1);
3945        assert(myDataView.getShape().size()==0);
3946        assert(myDataView()==94);
3947    
3948      }
3949    
3950    }
3951    
3952    void DataTaggedTestCase::testSetSlice() {
3953    
3954      cout << endl;
3955    
3956      {
3957    
3958        cout << "\tTest slicing default DataTagged." << endl;
3959    
3960        DataTagged myData1;
3961        DataTagged myData2;
3962    
3963        DataArrayView::RegionType region;
3964    
3965        myData2.getDefaultValue()()=1.0;
3966    
3967        myData1.setSlice(&myData2, region);
3968    
3969        //cout << myData1.toString() << endl;
3970    
3971        assert(myData1.getTagLookup().size()==0);
3972    
3973        assert(myData1.getLength()==1);
3974    
3975        DataArrayView myDataView = myData1.getDefaultValue();
3976        assert(!myDataView.isEmpty());
3977        assert(myDataView.getOffset()==0);
3978        assert(myDataView.getRank()==0);
3979        assert(myDataView.noValues()==1);
3980        assert(myDataView.getShape().size()==0);
3981        assert(myDataView()==1.0);
3982    
3983      }
3984    
3985      {
3986    
3987        cout << "\tTest slicing DataTagged with rank 1 default value only." << endl;
3988    
3989        DataTagged::TagListType keys;
3990    
3991        DataTagged::ValueListType values;
3992    
3993        DataArrayView::ShapeType viewShape;
3994        viewShape.push_back(3);
3995    
3996        DataArrayView::ValueType viewData1(3);
3997        for (int i=0;i<viewShape[0];i++) {
3998          viewData1[i]=i;
3999        }
4000        DataArrayView myView1(viewData1,viewShape);
4001        DataTagged myData1(keys,values,myView1,FunctionSpace());
4002    
4003        DataArrayView::ValueType viewData2(3);
4004        for (int i=0;i<viewShape[0];i++) {
4005          viewData2[i]=i+3;
4006        }
4007        DataArrayView myView2(viewData2,viewShape);
4008        DataTagged myData2(keys,values,myView2,FunctionSpace());
4009    
4010        // full slice
4011    
4012        std::pair<int, int> region_element;
4013        region_element.first=0;
4014        region_element.second=3;
4015        DataArrayView::RegionType region;
4016        region.push_back(region_element);
4017    
4018        myData1.setSlice(&myData2, region);
4019    
4020        //cout << myData1.toString() << endl;
4021    
4022        assert(myData1.getTagLookup().size()==0);
4023    
4024        assert(myData1.getLength()==3);
4025    
4026        DataArrayView myDataView = myData1.getDefaultValue();
4027        assert(!myDataView.isEmpty());
4028        assert(myDataView.getOffset()==0);
4029        assert(myDataView.getRank()==1);
4030        assert(myDataView.noValues()==3);
4031        assert(myDataView.getShape().size()==1);
4032        assert(myDataView(0)==3.0);
4033        assert(myDataView(1)==4.0);
4034        assert(myDataView(2)==5.0);
4035    
4036        // rank 1 slice
4037    
4038        viewShape.clear();
4039        viewShape.push_back(1);
4040    
4041        DataArrayView::ValueType viewData3(1);
4042        viewData3[0]=6.0;
4043        DataArrayView myView3(viewData3,viewShape);
4044        DataTagged myData3(keys,values,myView3,FunctionSpace());
4045    
4046        region.clear();
4047        region_element.first=1;
4048        region_element.second=2;
4049        region.push_back(region_element);
4050    
4051        myData1.setSlice(&myData3, region);
4052    
4053        //cout << myData1.toString() << endl;
4054    
4055        assert(myData1.getTagLookup().size()==0);
4056    
4057        assert(myData1.getLength()==3);
4058    
4059        myDataView = myData1.getDefaultValue();
4060        assert(!myDataView.isEmpty());
4061        assert(myDataView.getOffset()==0);
4062        assert(myDataView.getRank()==1);
4063        assert(myDataView.noValues()==3);
4064        assert(myDataView.getShape().size()==1);
4065        assert(myDataView(0)==3.0);
4066        assert(myDataView(1)==6.0);
4067        assert(myDataView(2)==5.0);
4068    
4069        // scalar slice
4070    
4071        region.clear();
4072        region_element.first=0;
4073        region_element.second=0;
4074        region.push_back(region_element);
4075    
4076        DataTagged myData4;
4077        myData4.getDefaultValue()()=7.0;
4078    
4079        myData1.setSlice(&myData4, region);
4080    
4081        //cout << myData3.toString() << endl;
4082    
4083        assert(myData1.getTagLookup().size()==0);
4084    
4085        assert(myData1.getLength()==3);
4086    
4087        myDataView = myData1.getDefaultValue();
4088        assert(!myDataView.isEmpty());
4089        assert(myDataView.getOffset()==0);
4090        assert(myDataView.getRank()==1);
4091        assert(myDataView.noValues()==3);
4092        assert(myDataView.getShape().size()==1);
4093        assert(myDataView(0)==7.0);
4094        assert(myDataView(1)==6.0);
4095        assert(myDataView(2)==5.0);
4096    
4097      }
4098    
4099      {
4100    
4101        cout << "\tTest slicing DataTagged with rank 3 default value only." << endl;
4102    
4103        DataTagged::TagListType keys;
4104    
4105        DataTagged::ValueListType values;
4106    
4107        DataArrayView::ShapeType viewShape;
4108        viewShape.push_back(3);
4109        viewShape.push_back(3);
4110        viewShape.push_back(3);
4111    
4112        DataArrayView::ValueType viewData1(27);
4113        for (int i=0;i<viewData1.size();i++) {
4114          viewData1[i]=i;
4115        }
4116        DataArrayView myView1(viewData1,viewShape);
4117        DataTagged myData1(keys,values,myView1,FunctionSpace());
4118    
4119        DataArrayView::ValueType viewData2(27);
4120        for (int i=0;i<viewData2.size();i++) {
4121          viewData2[i]=i+27;
4122        }
4123        DataArrayView myView2(viewData2,viewShape);
4124        DataTagged myData2(keys,values,myView2,FunctionSpace());
4125    
4126        // full slice
4127    
4128        std::pair<int, int> region_element;
4129        region_element.first=0;
4130        region_element.second=3;
4131        DataArrayView::RegionType region;
4132        region.push_back(region_element);
4133        region.push_back(region_element);
4134        region.push_back(region_element);
4135    
4136        myData1.setSlice(&myData2, region);
4137    
4138        //cout << myData1.toString() << endl;
4139    
4140        assert(myData1.getTagLookup().size()==0);
4141    
4142        assert(myData1.getLength()==27);
4143    
4144        DataArrayView myDataView = myData1.getDefaultValue();
4145        assert(!myDataView.isEmpty());
4146        assert(myDataView.getOffset()==0);
4147        assert(myDataView.getRank()==3);
4148        assert(myDataView.noValues()==27);
4149        assert(myDataView.getShape().size()==3);
4150    
4151        // rank 1 slice
4152    
4153        viewShape.clear();
4154        viewShape.push_back(3);
4155    
4156        DataArrayView::ValueType viewData3(3);
4157        for (int i=0;i<viewData3.size();i++) {
4158          viewData3[i]=i+60;
4159        }
4160        DataArrayView myView3(viewData3,viewShape);
4161        DataTagged myData3(keys,values,myView3,FunctionSpace());
4162    
4163        region.clear();
4164        region.push_back(region_element);
4165        region_element.first=0;
4166        region_element.second=0;
4167        region.push_back(region_element);
4168        region.push_back(region_element);
4169    
4170        myData1.setSlice(&myData3, region);
4171    
4172        //cout << myData1.toString() << endl;
4173    
4174        assert(myData1.getTagLookup().size()==0);
4175    
4176        assert(myData1.getLength()==27);
4177    
4178        myDataView = myData1.getDefaultValue();
4179        assert(!myDataView.isEmpty());
4180        assert(myDataView.getOffset()==0);
4181        assert(myDataView.getRank()==3);
4182        assert(myDataView.noValues()==27);
4183        assert(myDataView.getShape().size()==3);
4184        assert(myDataView(0,0,0)==60.0);
4185        assert(myDataView(1,0,0)==61.0);
4186        assert(myDataView(2,0,0)==62.0);
4187    
4188        // scalar slice
4189    
4190        region.clear();
4191        region_element.first=0;
4192        region_element.second=0;
4193        region.push_back(region_element);
4194        region.push_back(region_element);
4195        region.push_back(region_element);
4196    
4197        DataTagged myData4;
4198        myData4.getDefaultValue()()=70.0;
4199    
4200        myData1.setSlice(&myData4, region);
4201    
4202        //cout << myData1.toString() << endl;
4203    
4204        assert(myData1.getTagLookup().size()==0);
4205    
4206        assert(myData1.getLength()==27);
4207    
4208        myDataView = myData1.getDefaultValue();
4209        assert(!myDataView.isEmpty());
4210        assert(myDataView.getOffset()==0);
4211        assert(myDataView.getRank()==3);
4212        assert(myDataView.noValues()==27);
4213        assert(myDataView.getShape().size()==3);
4214        assert(myDataView(0,0,0)==70.0);
4215    
4216      }
4217    
4218      {
4219    
4220        cout << "\tTest slicing DataTagged with scalar values and one tag." << endl;
4221    
4222        DataTagged::TagListType keys;
4223        keys.push_back(1);
4224    
4225        DataTagged::ValueListType values;
4226    
4227        DataArrayView::ShapeType viewShape;
4228    
4229        // default value for Data1
4230        DataArrayView::ValueType viewData1(1);
4231        viewData1[0]=0.0;
4232        DataArrayView myView1(viewData1,viewShape);
4233    
4234        // value for tag "1" for Data1
4235        DataArrayView::ValueType viewData2(1);
4236        viewData2[0]=0.0;
4237        DataArrayView myView2(viewData2,viewShape);
4238        values.push_back(myView2);
4239    
4240        DataTagged myData1(keys,values,myView1,FunctionSpace());
4241    
4242        values.clear();
4243    
4244        // default value for Data2
4245        DataArrayView::ValueType viewData3(1);
4246        viewData3[0]=1.0;
4247        DataArrayView myView3(viewData3,viewShape);
4248    
4249        // value for tag "1" for Data2
4250        DataArrayView::ValueType viewData4(1);
4251        viewData4[0]=2.0;
4252        DataArrayView myView4(viewData4,viewShape);
4253        values.push_back(myView4);
4254    
4255        DataTagged myData2(keys,values,myView3,FunctionSpace());
4256    
4257        // full slice
4258    
4259        DataArrayView::RegionType region;
4260    
4261        myData1.setSlice(&myData2, region);
4262    
4263        //cout << myData1.toString() << endl;
4264    
4265        assert(myData1.getTagLookup().size()==1);
4266    
4267        assert(myData1.getLength()==2);
4268    
4269        DataArrayView myDataView = myData1.getDefaultValue();
4270        assert(!myDataView.isEmpty());
4271        assert(myDataView.getOffset()==0);
4272        assert(myDataView.getRank()==0);
4273        assert(myDataView.noValues()==1);
4274        assert(myDataView.getShape().size()==0);
4275        assert(myDataView()==1.0);
4276    
4277        myDataView = myData1.getDataPointByTag(1);
4278        assert(!myDataView.isEmpty());
4279        assert(myDataView.getOffset()==1);
4280        assert(myDataView.getRank()==0);
4281        assert(myDataView.noValues()==1);
4282        assert(myDataView.getShape().size()==0);
4283        assert(myDataView()==2.0);
4284    
4285      }
4286    
4287      {
4288    
4289        cout << "\tTest slicing DataTagged with rank 1 values and one tag." << endl;
4290    
4291        DataTagged::TagListType keys;
4292        keys.push_back(1);
4293    
4294        DataTagged::ValueListType values;
4295    
4296        DataArrayView::ShapeType viewShape;
4297        viewShape.push_back(3);
4298    
4299        // default value for Data1
4300        DataArrayView::ValueType viewData1(3);
4301        for (int i=0;i<viewData1.size();i++) {
4302          viewData1[i]=0.0;
4303        }
4304        DataArrayView myView1(viewData1,viewShape);
4305    
4306        // value for tag "1" for Data1
4307        DataArrayView::ValueType viewData2(3);
4308        for (int i=0;i<viewData2.size();i++) {
4309          viewData2[i]=0.0;
4310        }
4311        DataArrayView myView2(viewData2,viewShape);
4312        values.push_back(myView2);
4313    
4314        DataTagged myData1(keys,values,myView1,FunctionSpace());
4315    
4316        values.clear();
4317    
4318        // default value for Data2
4319        DataArrayView::ValueType viewData3(3);
4320        for (int i=0;i<viewData3.size();i++) {
4321          viewData3[i]=1.0;
4322        }
4323        DataArrayView myView3(viewData3,viewShape);
4324    
4325        // value for tag "1" for Data2
4326        DataArrayView::ValueType viewData4(3);
4327        for (int i=0;i<viewData4.size();i++) {
4328          viewData4[i]=2.0;
4329        }
4330        DataArrayView myView4(viewData4,viewShape);
4331        values.push_back(myView4);
4332    
4333        DataTagged myData2(keys,values,myView3,FunctionSpace());
4334    
4335        // full slice
4336    
4337        std::pair<int, int> region_element;
4338        region_element.first=0;
4339        region_element.second=3;
4340        DataArrayView::RegionType region;
4341        region.push_back(region_element);
4342    
4343        myData1.setSlice(&myData2, region);
4344    
4345        //cout << myData1.toString() << endl;
4346    
4347        assert(myData1.getTagLookup().size()==1);
4348    
4349        assert(myData1.getLength()==6);
4350    
4351        DataArrayView myDataView = myData1.getDefaultValue();
4352        assert(!myDataView.isEmpty());
4353        assert(myDataView.getOffset()==0);
4354        assert(myDataView.getRank()==1);
4355        assert(myDataView.noValues()==3);
4356        assert(myDataView.getShape().size()==1);
4357        assert(myDataView(0)==1.0);
4358        assert(myDataView(1)==1.0);
4359        assert(myDataView(2)==1.0);
4360    
4361        myDataView = myData1.getDataPointByTag(1);
4362        assert(!myDataView.isEmpty());
4363        assert(myDataView.getOffset()==3);
4364        assert(myDataView.getRank()==1);
4365        assert(myDataView.noValues()==3);
4366        assert(myDataView.getShape().size()==1);
4367        assert(myDataView(0)==2.0);
4368        assert(myDataView(1)==2.0);
4369        assert(myDataView(2)==2.0);
4370    
4371        // rank 1 slice
4372    
4373        viewShape.clear();
4374        viewShape.push_back(1);
4375    
4376        DataArrayView::ValueType viewData5(1);
4377        viewData5[0]=3.0;
4378        DataArrayView myView5(viewData5,viewShape);
4379    
4380        values.clear();
4381    
4382        DataArrayView::ValueType viewData6(1);
4383        viewData6[0]=4.0;
4384        DataArrayView myView6(viewData6,viewShape);
4385        values.push_back(myView6);
4386    
4387        DataTagged myData3(keys,values,myView5,FunctionSpace());
4388    
4389        region.clear();
4390        region_element.first=1;
4391        region_element.second=2;
4392        region.push_back(region_element);
4393    
4394        myData1.setSlice(&myData3, region);
4395    
4396        //cout << myData1.toString() << endl;
4397    
4398        assert(myData1.getTagLookup().size()==1);
4399    
4400        assert(myData1.getLength()==6);
4401    
4402        myDataView = myData1.getDefaultValue();
4403        assert(!myDataView.isEmpty());
4404        assert(myDataView.getOffset()==0);
4405        assert(myDataView.getRank()==1);
4406        assert(myDataView.noValues()==3);
4407        assert(myDataView.getShape().size()==1);
4408        assert(myDataView(0)==1.0);
4409        assert(myDataView(1)==3.0);
4410        assert(myDataView(2)==1.0);
4411    
4412        myDataView = myData1.getDataPointByTag(1);
4413        assert(!myDataView.isEmpty());
4414        assert(myDataView.getOffset()==3);
4415        assert(myDataView.getRank()==1);
4416        assert(myDataView.noValues()==3);
4417        assert(myDataView.getShape().size()==1);
4418        assert(myDataView(0)==2.0);
4419        assert(myDataView(1)==4.0);
4420        assert(myDataView(2)==2.0);
4421    
4422        // scalar slice
4423    
4424        viewShape.clear();
4425    
4426        DataArrayView::ValueType viewData7(1);
4427        viewData7[0]=5.0;
4428        DataArrayView myView7(viewData7,viewShape);
4429    
4430        values.clear();
4431    
4432        DataArrayView::ValueType viewData8(1);
4433        viewData8[0]=6.0;
4434        DataArrayView myView8(viewData8,viewShape);
4435        values.push_back(myView8);
4436    
4437        DataTagged myData4(keys,values,myView7,FunctionSpace());
4438    
4439        region.clear();
4440        region_element.first=0;
4441        region_element.second=0;
4442        region.push_back(region_element);
4443    
4444        myData1.setSlice(&myData4, region);
4445    
4446        //cout << myData1.toString() << endl;
4447    
4448        myDataView = myData1.getDefaultValue();
4449        assert(!myDataView.isEmpty());
4450        assert(myDataView.getOffset()==0);
4451        assert(myDataView.getRank()==1);
4452        assert(myDataView.noValues()==3);
4453        assert(myDataView.getShape().size()==1);
4454        assert(myDataView(0)==5.0);
4455        assert(myDataView(1)==3.0);
4456        assert(myDataView(2)==1.0);
4457    
4458        myDataView = myData1.getDataPointByTag(1);
4459        assert(!myDataView.isEmpty());
4460        assert(myDataView.getOffset()==3);
4461        assert(myDataView.getRank()==1);
4462        assert(myDataView.noValues()==3);
4463        assert(myDataView.getShape().size()==1);
4464        assert(myDataView(0)==6.0);
4465        assert(myDataView(1)==4.0);
4466        assert(myDataView(2)==2.0);
4467    
4468      }
4469    
4470      {
4471    
4472        cout << "\tTest slicing DataTagged with rank 3 values and one tag." << endl;
4473    
4474        DataTagged::TagListType keys;
4475        keys.push_back(1);
4476    
4477        DataTagged::ValueListType values;
4478    
4479        DataArrayView::ShapeType viewShape;
4480        viewShape.push_back(3);
4481        viewShape.push_back(3);
4482        viewShape.push_back(3);
4483    
4484        // default value for Data1
4485        DataArrayView::ValueType viewData1(27);
4486        for (int i=0;i<viewData1.size();i++) {
4487          viewData1[i]=0.0;
4488        }
4489        DataArrayView myView1(viewData1,viewShape);
4490    
4491        // value for tag "1" for Data1
4492        DataArrayView::ValueType viewData2(27);
4493        for (int i=0;i<viewData2.size();i++) {
4494          viewData2[i]=0.0;
4495        }
4496        DataArrayView myView2(viewData2,viewShape);
4497        values.push_back(myView2);
4498    
4499        DataTagged myData1(keys,values,myView1,FunctionSpace());
4500    
4501        values.clear();
4502    
4503        // default value for Data2
4504        DataArrayView::ValueType viewData3(27);
4505        for (int i=0;i<viewData3.size();i++) {
4506          viewData3[i]=1.0;
4507        }
4508        DataArrayView myView3(viewData3,viewShape);
4509    
4510        // value for tag "1" for Data2
4511        DataArrayView::ValueType viewData4(27);
4512        for (int i=0;i<viewData4.size();i++) {
4513          viewData4[i]=2.0;
4514        }
4515        DataArrayView myView4(viewData4,viewShape);
4516        values.push_back(myView4);
4517    
4518        DataTagged myData2(keys,values,myView3,FunctionSpace());
4519    
4520        // full slice
4521    
4522        std::pair<int, int> region_element;
4523        region_element.first=0;
4524        region_element.second=3;
4525        DataArrayView::RegionType region;
4526        region.push_back(region_element);
4527        region.push_back(region_element);
4528        region.push_back(region_element);
4529    
4530        myData1.setSlice(&myData2, region);
4531    
4532        //cout << myData1.toString() << endl;
4533    
4534        assert(myData1.getTagLookup().size()==1);
4535    
4536        assert(myData1.getLength()==54);
4537    
4538        DataArrayView myDataView = myData1.getDefaultValue();
4539        assert(!myDataView.isEmpty());
4540        assert(myDataView.getOffset()==0);
4541        assert(myDataView.getRank()==3);
4542        assert(myDataView.noValues()==27);
4543        assert(myDataView.getShape().size()==3);
4544        assert(myDataView(0,0,0)==1.0);
4545        assert(myDataView(1,1,1)==1.0);
4546        assert(myDataView(2,2,2)==1.0);
4547    
4548        myDataView = myData1.getDataPointByTag(1);
4549        assert(!myDataView.isEmpty());
4550        assert(myDataView.getOffset()==27);
4551        assert(myDataView.getRank()==3);
4552        assert(myDataView.noValues()==27);
4553        assert(myDataView.getShape().size()==3);
4554        assert(myDataView(0,0,0)==2.0);
4555        assert(myDataView(1,1,1)==2.0);
4556        assert(myDataView(2,2,2)==2.0);
4557    
4558        // rank 1 slice
4559    
4560        viewShape.clear();
4561        viewShape.push_back(3);
4562    
4563        DataArrayView::ValueType viewData5(3);
4564        for (int i=0;i<viewData5.size();i++) {
4565          viewData5[i]=3.0;
4566        }
4567        DataArrayView myView5(viewData5,viewShape);
4568    
4569        values.clear();
4570    
4571        DataArrayView::ValueType viewData6(3);
4572        for (int i=0;i<viewData6.size();i++) {
4573          viewData6[i]=4.0;
4574        }
4575        DataArrayView myView6(viewData6,viewShape);
4576        values.push_back(myView6);
4577    
4578        DataTagged myData3(keys,values,myView5,FunctionSpace());
4579    
4580        region.clear();
4581        region.push_back(region_element);
4582        region_element.first=0;
4583        region_element.second=0;
4584        region.push_back(region_element);
4585        region.push_back(region_element);
4586    
4587        myData1.setSlice(&myData3, region);
4588    
4589        //cout << myData1.toString() << endl;
4590    
4591        assert(myData1.getTagLookup().size()==1);
4592    
4593        assert(myData1.getLength()==54);
4594    
4595        myDataView = myData1.getDefaultValue();
4596        assert(!myDataView.isEmpty());
4597        assert(myDataView.getOffset()==0);
4598        assert(myDataView.getRank()==3);
4599        assert(myDataView.noValues()==27);
4600        assert(myDataView.getShape().size()==3);
4601        assert(myDataView(0,0,0)==3.0);
4602        assert(myDataView(1,0,0)==3.0);
4603        assert(myDataView(2,0,0)==3.0);
4604    
4605        myDataView = myData1.getDataPointByTag(1);
4606        assert(!myDataView.isEmpty());
4607        assert(myDataView.getOffset()==27);
4608        assert(myDataView.getRank()==3);
4609        assert(myDataView.noValues()==27);
4610        assert(myDataView.getShape().size()==3);
4611        assert(myDataView(0,0,0)==4.0);
4612        assert(myDataView(1,0,0)==4.0);
4613        assert(myDataView(2,0,0)==4.0);
4614    
4615        // scalar slice
4616    
4617        viewShape.clear();
4618    
4619        DataArrayView::ValueType viewData7(1);
4620        viewData7[0]=5.0;
4621        DataArrayView myView7(viewData7,viewShape);
4622    
4623        values.clear();
4624    
4625        DataArrayView::ValueType viewData8(1);
4626        viewData8[0]=6.0;
4627        DataArrayView myView8(viewData8,viewShape);
4628        values.push_back(myView8);
4629    
4630        DataTagged myData4(keys,values,myView7,FunctionSpace());
4631    
4632        region.clear();
4633        region_element.first=0;
4634        region_element.second=0;
4635        region.push_back(region_element);
4636        region.push_back(region_element);
4637        region.push_back(region_element);
4638    
4639        myData1.setSlice(&myData4, region);
4640    
4641        //cout << myData1.toString() << endl;
4642    
4643        myDataView = myData1.getDefaultValue();
4644        assert(!myDataView.isEmpty());
4645        assert(myDataView.getOffset()==0);
4646        assert(myDataView.getRank()==3);
4647        assert(myDataView.noValues()==27);
4648        assert(myDataView.getShape().size()==3);
4649        assert(myDataView(0,0,0)==5.0);
4650    
4651        myDataView = myData1.getDataPointByTag(1);
4652        assert(!myDataView.isEmpty());
4653        assert(myDataView.getOffset()==27);
4654        assert(myDataView.getRank()==3);
4655        assert(myDataView.noValues()==27);
4656        assert(myDataView.getShape().size()==3);
4657        assert(myDataView(0,0,0)==6.0);
4658    
4659      }
4660    
4661      {
4662    
4663        cout << "\tTest slicing DataTagged with scalar values and three tags." << endl;
4664    
4665        DataTagged::TagListType keys;
4666        keys.push_back(1);
4667        keys.push_back(2);
4668        keys.push_back(3);
4669    
4670        DataTagged::ValueListType values;
4671    
4672        DataArrayView::ShapeType viewShape;
4673    
4674        // default value for Data1
4675        DataArrayView::ValueType viewData1(1);
4676        viewData1[0]=0.0;
4677        DataArrayView myView1(viewData1,viewShape);
4678    
4679        // value for tag "1" for Data1
4680        DataArrayView::ValueType viewData2(1);
4681        viewData2[0]=0.0;
4682        DataArrayView myView2(viewData2,viewShape);
4683        values.push_back(myView2);
4684    
4685        // value for tag "2" for Data1
4686        DataArrayView::ValueType viewData5(1);
4687        viewData5[0]=0.0;
4688        DataArrayView myView5(viewData5,viewShape);
4689        values.push_back(myView5);
4690    
4691        // value for tag "3" for Data1
4692        DataArrayView::ValueType viewData6(1);
4693        viewData6[0]=0.0;
4694        DataArrayView myView6(viewData6,viewShape);
4695        values.push_back(myView6);
4696    
4697        DataTagged myData1(keys,values,myView1,FunctionSpace());
4698    
4699        values.clear();
4700    
4701        // default value for Data2
4702        DataArrayView::ValueType viewData3(1);
4703        viewData3[0]=1.0;
4704        DataArrayView myView3(viewData3,viewShape);
4705    
4706        // value for tag "1" for Data2
4707        DataArrayView::ValueType viewData4(1);
4708        viewData4[0]=2.0;
4709        DataArrayView myView4(viewData4,viewShape);
4710        values.push_back(myView4);
4711    
4712        // value for tag "2" for Data2
4713        DataArrayView::ValueType viewData7(1);
4714        viewData7[0]=3.0;
4715        DataArrayView myView7(viewData7,viewShape);
4716        values.push_back(myView7);
4717    
4718        // value for tag "3" for Data2
4719        DataArrayView::ValueType viewData8(1);
4720        viewData8[0]=4.0;
4721        DataArrayView myView8(viewData8,viewShape);
4722        values.push_back(myView8);
4723    
4724        DataTagged myData2(keys,values,myView3,FunctionSpace());
4725    
4726        // full slice
4727    
4728        DataArrayView::RegionType region;
4729    
4730        myData1.setSlice(&myData2, region);
4731    
4732        //cout << myData1.toString() << endl;
4733    
4734        assert(myData1.getTagLookup().size()==3);
4735    
4736        assert(myData1.getLength()==4);
4737    
4738        DataArrayView myDataView = myData1.getDefaultValue();
4739        assert(!myDataView.isEmpty());
4740        assert(myDataView.getOffset()==0);
4741        assert(myDataView.getRank()==0);
4742        assert(myDataView.noValues()==1);
4743        assert(myDataView.getShape().size()==0);
4744        assert(myDataView()==1.0);
4745    
4746        myDataView = myData1.getDataPointByTag(1);
4747        assert(!myDataView.isEmpty());
4748        assert(myDataView.getOffset()==1);
4749        assert(myDataView.getRank()==0);
4750        assert(myDataView.noValues()==1);
4751        assert(myDataView.getShape().size()==0);
4752        assert(myDataView()==2.0);
4753    
4754        myDataView = myData1.getDataPointByTag(2);
4755        assert(!myDataView.isEmpty());
4756        assert(myDataView.getOffset()==2);
4757        assert(myDataView.getRank()==0);
4758        assert(myDataView.noValues()==1);
4759        assert(myDataView.getShape().size()==0);
4760        assert(myDataView()==3.0);
4761    
4762        myDataView = myData1.getDataPointByTag(3);
4763        assert(!myDataView.isEmpty());
4764        assert(myDataView.getOffset()==3);
4765        assert(myDataView.getRank()==0);
4766        assert(myDataView.noValues()==1);
4767        assert(myDataView.getShape().size()==0);
4768        assert(myDataView()==4.0);
4769    
4770      }
4771    
4772      {
4773    
4774        cout << "\tTest slicing DataTagged with rank 1 values and three tags." << endl;
4775    
4776        DataTagged::TagListType keys;
4777        keys.push_back(1);
4778        keys.push_back(2);
4779        keys.push_back(3);
4780    
4781        DataTagged::ValueListType values;
4782    
4783        DataArrayView::ShapeType viewShape;
4784        viewShape.push_back(3);
4785    
4786        // default value for Data1
4787        DataArrayView::ValueType viewData1(3);
4788        for (int i=0;i<viewData1.size();i++) {
4789          viewData1[i]=0.0;
4790        }
4791        DataArrayView myView1(viewData1,viewShape);
4792    
4793        // value for tag "1" for Data1
4794        DataArrayView::ValueType viewData2(3);
4795        for (int i=0;i<viewData2.size();i++) {
4796          viewData2[i]=0.0;
4797        }
4798        DataArrayView myView2(viewData2,viewShape);
4799        values.push_back(myView2);
4800    
4801        // value for tag "2" for Data1
4802        DataArrayView::ValueType viewData3(3);
4803        for (int i=0;i<viewData3.size();i++) {
4804          viewData3[i]=0.0;
4805        }
4806        DataArrayView myView3(viewData3,viewShape);
4807        values.push_back(myView3);
4808    
4809        // value for tag "3" for Data1
4810        DataArrayView::ValueType viewData4(3);
4811        for (int i=0;i<viewData4.size();i++) {
4812          viewData4[i]=0.0;
4813        }
4814        DataArrayView myView4(viewData4,viewShape);
4815        values.push_back(myView4);
4816    
4817        DataTagged myData1(keys,values,myView1,FunctionSpace());
4818    
4819        values.clear();
4820    
4821        // default value for Data2
4822        DataArrayView::ValueType viewData5(3);
4823        for (int i=0;i<viewData5.size();i++) {
4824          viewData5[i]=1.0;
4825        }
4826        DataArrayView myView5(viewData5,viewShape);
4827    
4828        // value for tag "1" for Data2
4829        DataArrayView::ValueType viewData6(3);
4830        for (int i=0;i<viewData6.size();i++) {
4831          viewData6[i]=2.0;
4832        }
4833        DataArrayView myView6(viewData6,viewShape);
4834        values.push_back(myView6);
4835    
4836        // value for tag "2" for Data2
4837        DataArrayView::ValueType viewData7(3);
4838        for (int i=0;i<viewData7.size();i++) {
4839          viewData7[i]=3.0;
4840        }
4841        DataArrayView myView7(viewData7,viewShape);
4842        values.push_back(myView7);
4843    
4844        // value for tag "3" for Data2
4845        DataArrayView::ValueType viewData8(3);
4846        for (int i=0;i<viewData8.size();i++) {
4847          viewData8[i]=4.0;
4848        }
4849        DataArrayView myView8(viewData8,viewShape);
4850        values.push_back(myView8);
4851    
4852        DataTagged myData2(keys,values,myView5,FunctionSpace());
4853    
4854        // full slice
4855    
4856        std::pair<int, int> region_element;
4857        region_element.first=0;
4858        region_element.second=3;
4859        DataArrayView::RegionType region;
4860        region.push_back(region_element);
4861    
4862        myData1.setSlice(&myData2, region);
4863    
4864        //cout << myData1.toString() << endl;
4865    
4866        assert(myData1.getTagLookup().size()==3);
4867    
4868        assert(myData1.getLength()==12);
4869    
4870        DataArrayView myDataView = myData1.getDefaultValue();
4871        assert(!myDataView.isEmpty());
4872        assert(myDataView.getOffset()==0);
4873        assert(myDataView.getRank()==1);
4874        assert(myDataView.noValues()==3);
4875        assert(myDataView.getShape().size()==1);
4876        assert(myDataView(0)==1.0);
4877        assert(myDataView(1)==1.0);
4878        assert(myDataView(2)==1.0);
4879    
4880        myDataView = myData1.getDataPointByTag(1);
4881        assert(!myDataView.isEmpty());
4882        assert(myDataView.getOffset()==3);
4883        assert(myDataView.getRank()==1);
4884        assert(myDataView.noValues()==3);
4885        assert(myDataView.getShape().size()==1);
4886        assert(myDataView(0)==2.0);
4887        assert(myDataView(1)==2.0);
4888        assert(myDataView(2)==2.0);
4889    
4890        myDataView = myData1.getDataPointByTag(2);
4891        assert(!myDataView.isEmpty());
4892        assert(myDataView.getOffset()==6);
4893        assert(myDataView.getRank()==1);
4894        assert(myDataView.noValues()==3);
4895        assert(myDataView.getShape().size()==1);
4896        assert(myDataView(0)==3.0);
4897        assert(myDataView(1)==3.0);
4898        assert(myDataView(2)==3.0);
4899    
4900        myDataView = myData1.getDataPointByTag(3);
4901        assert(!myDataView.isEmpty());
4902        assert(myDataView.getOffset()==9);
4903        assert(myDataView.getRank()==1);
4904        assert(myDataView.noValues()==3);
4905        assert(myDataView.getShape().size()==1);
4906        assert(myDataView(0)==4.0);
4907        assert(myDataView(1)==4.0);
4908        assert(myDataView(2)==4.0);
4909    
4910        // rank 1 slice
4911    
4912        viewShape.clear();
4913        viewShape.push_back(1);
4914    
4915        DataArrayView::ValueType viewData9(1);
4916        viewData9[0]=6.0;
4917        DataArrayView myView9(viewData9,viewShape);
4918    
4919        values.clear();
4920    
4921        DataArrayView::ValueType viewData10(1);
4922        viewData10[0]=7.0;
4923        DataArrayView myView10(viewData10,viewShape);
4924        values.push_back(myView10);
4925    
4926        DataArrayView::ValueType viewData11(1);
4927        viewData11[0]=8.0;
4928        DataArrayView myView11(viewData11,viewShape);
4929        values.push_back(myView11);
4930    
4931        DataArrayView::ValueType viewData12(1);
4932        viewData12[0]=9.0;
4933        DataArrayView myView12(viewData12,viewShape);
4934        values.push_back(myView12);
4935    
4936        DataTagged myData3(keys,values,myView9,FunctionSpace());
4937    
4938        region.clear();
4939        region_element.first=1;
4940        region_element.second=2;
4941        region.push_back(region_element);
4942    
4943        myData1.setSlice(&myData3, region);
4944    
4945        //cout << myData1.toString() << endl;
4946    
4947        assert(myData1.getTagLookup().size()==3);
4948    
4949        assert(myData1.getLength()==12);
4950    
4951        myDataView = myData1.getDefaultValue();
4952        assert(!myDataView.isEmpty());
4953        assert(myDataView.getOffset()==0);
4954        assert(myDataView.getRank()==1);
4955        assert(myDataView.noValues()==3);
4956        assert(myDataView.getShape().size()==1);
4957        assert(myDataView(0)==1.0);
4958        assert(myDataView(1)==6.0);
4959        assert(myDataView(2)==1.0);
4960    
4961        myDataView = myData1.getDataPointByTag(1);
4962        assert(!myDataView.isEmpty());
4963        assert(myDataView.getOffset()==3);
4964        assert(myDataView.getRank()==1);
4965        assert(myDataView.noValues()==3);
4966        assert(myDataView.getShape().size()==1);
4967        assert(myDataView(0)==2.0);
4968        assert(myDataView(1)==7.0);
4969        assert(myDataView(2)==2.0);
4970    
4971        myDataView = myData1.getDataPointByTag(2);
4972        assert(!myDataView.isEmpty());
4973        assert(myDataView.getOffset()==6);
4974        assert(myDataView.getRank()==1);
4975        assert(myDataView.noValues()==3);
4976        assert(myDataView.getShape().size()==1);
4977        assert(myDataView(0)==3.0);
4978        assert(myDataView(1)==8.0);
4979        assert(myDataView(2)==3.0);
4980    
4981        myDataView = myData1.getDataPointByTag(3);
4982        assert(!myDataView.isEmpty());
4983        assert(myDataView.getOffset()==9);
4984        assert(myDataView.getRank()==1);
4985        assert(myDataView.noValues()==3);
4986        assert(myDataView.getShape().size()==1);
4987        assert(myDataView(0)==4.0);
4988        assert(myDataView(1)==9.0);
4989        assert(myDataView(2)==4.0);
4990    
4991        // scalar slice
4992    
4993        viewShape.clear();
4994    
4995        DataArrayView::ValueType viewData13(1);
4996        viewData13[0]=10.0;
4997        DataArrayView myView13(viewData13,viewShape);
4998    
4999        values.clear();
5000    
5001        DataArrayView::ValueType viewData14(1);
5002        viewData14[0]=11.0;
5003        DataArrayView myView14(viewData14,viewShape);
5004        values.push_back(myView14);
5005    
5006        DataArrayView::ValueType viewData15(2);
5007        viewData15[0]=12.0;
5008        DataArrayView myView15(viewData15,viewShape);
5009        values.push_back(myView15);
5010    
5011        DataArrayView::ValueType viewData16(3);
5012        viewData16[0]=13.0;
5013        DataArrayView myView16(viewData16,viewShape);
5014        values.push_back(myView16);
5015    
5016        DataTagged myData4(keys,values,myView13,FunctionSpace());
5017    
5018        region.clear();
5019        region_element.first=0;
5020        region_element.second=0;
5021        region.push_back(region_element);
5022    
5023        myData1.setSlice(&myData4, region);
5024    
5025        //cout << myData1.toString() << endl;
5026    
5027        myDataView = myData1.getDefaultValue();
5028        assert(!myDataView.isEmpty());
5029        assert(myDataView.getOffset()==0);
5030        assert(myDataView.getRank()==1);
5031        assert(myDataView.noValues()==3);
5032        assert(myDataView.getShape().size()==1);
5033        assert(myDataView(0)==10.0);
5034        assert(myDataView(1)==6.0);
5035        assert(myDataView(2)==1.0);
5036    
5037        myDataView = myData1.getDataPointByTag(1);
5038        assert(!myDataView.isEmpty());
5039        assert(myDataView.getOffset()==3);
5040        assert(myDataView.getRank()==1);
5041        assert(myDataView.noValues()==3);
5042        assert(myDataView.getShape().size()==1);
5043        assert(myDataView(0)==11.0);
5044        assert(myDataView(1)==7.0);
5045        assert(myDataView(2)==2.0);
5046    
5047        myDataView = myData1.getDataPointByTag(2);
5048        assert(!myDataView.isEmpty());
5049        assert(myDataView.getOffset()==6);
5050        assert(myDataView.getRank()==1);
5051        assert(myDataView.noValues()==3);
5052        assert(myDataView.getShape().size()==1);
5053        assert(myDataView(0)==12.0);
5054        assert(myDataView(1)==8.0);
5055        assert(myDataView(2)==3.0);
5056    
5057        myDataView = myData1.getDataPointByTag(3);
5058        assert(!myDataView.isEmpty());
5059        assert(myDataView.getOffset()==9);
5060        assert(myDataView.getRank()==1);
5061        assert(myDataView.noValues()==3);
5062        assert(myDataView.getShape().size()==1);
5063        assert(myDataView(0)==13.0);
5064        assert(myDataView(1)==9.0);
5065        assert(myDataView(2)==4.0);
5066    
5067      }
5068    
5069      {
5070    
5071        cout << "\tTest slicing DataTagged with rank 3 values and three tags." << endl;
5072    
5073        DataTagged::TagListType keys;
5074        keys.push_back(1);
5075        keys.push_back(2);
5076        keys.push_back(3);
5077    
5078        DataTagged::ValueListType values;
5079    
5080        DataArrayView::ShapeType viewShape;
5081        viewShape.push_back(3);
5082        viewShape.push_back(3);
5083        viewShape.push_back(3);
5084    
5085        // default value for Data1
5086        DataArrayView::ValueType viewData1(27);
5087        for (int i=0;i<viewData1.size();i++) {
5088          viewData1[i]=0.0;
5089        }
5090        DataArrayView myView1(viewData1,viewShape);
5091    
5092        // value for tag "1" for Data1
5093        DataArrayView::ValueType viewData2(27);
5094        for (int i=0;i<viewData2.size();i++) {
5095          viewData2[i]=0.0;
5096        }
5097        DataArrayView myView2(viewData2,viewShape);
5098        values.push_back(myView2);
5099    
5100        // value for tag "2" for Data1
5101        DataArrayView::ValueType viewData3(27);
5102        for (int i=0;i<viewData3.size();i++) {
5103          viewData3[i]=0.0;
5104        }
5105        DataArrayView myView3(viewData3,viewShape);
5106        values.push_back(myView3);
5107    
5108        // value for tag "3" for Data1
5109        DataArrayView::ValueType viewData4(27);
5110        for (int i=0;i<viewData4.size();i++) {
5111          viewData4[i]=0.0;
5112        }
5113        DataArrayView myView4(viewData4,viewShape);
5114        values.push_back(myView4);
5115    
5116        DataTagged myData1(keys,values,myView1,FunctionSpace());
5117    
5118        values.clear();
5119    
5120        // default value for Data2
5121        DataArrayView::ValueType viewData5(27);
5122        for (int i=0;i<viewData5.size();i++) {
5123          viewData5[i]=1.0;
5124        }
5125        DataArrayView myView5(viewData5,viewShape);
5126    
5127        // value for tag "1" for Data2
5128        DataArrayView::ValueType viewData6(27);
5129        for (int i=0;i<viewData6.size();i++) {
5130          viewData6[i]=2.0;
5131        }
5132        DataArrayView myView6(viewData6,viewShape);
5133        values.push_back(myView6);
5134    
5135        // value for tag "2" for Data2
5136        DataArrayView::ValueType viewData7(27);
5137        for (int i=0;i<viewData7.size();i++) {
5138          viewData7[i]=3.0;
5139        }
5140        DataArrayView myView7(viewData7,viewShape);
5141        values.push_back(myView7);
5142    
5143        // value for tag "3" for Data2
5144        DataArrayView::ValueType viewData8(27);
5145        for (int i=0;i<viewData8.size();i++) {
5146          viewData8[i]=4.0;
5147        }
5148        DataArrayView myView8(viewData8,viewShape);
5149        values.push_back(myView8);
5150    
5151        DataTagged myData2(keys,values,myView5,FunctionSpace());
5152    
5153        // full slice
5154    
5155        std::pair<int, int> region_element;
5156        region_element.first=0;
5157        region_element.second=3;
5158        DataArrayView::RegionType region;
5159        region.push_back(region_element);
5160        region.push_back(region_element);
5161        region.push_back(region_element);
5162    
5163        myData1.setSlice(&myData2, region);
5164    
5165        //cout << myData1.toString() << endl;
5166    
5167        assert(myData1.getTagLookup().size()==3);
5168    
5169        assert(myData1.getLength()==108);
5170    
5171        DataArrayView myDataView = myData1.getDefaultValue();
5172        assert(!myDataView.isEmpty());
5173        assert(myDataView.getOffset()==0);
5174        assert(myDataView.getRank()==3);
5175        assert(myDataView.noValues()==27);
5176        assert(myDataView.getShape().size()==3);
5177        assert(myDataView(0,0,0)==1.0);
5178        assert(myDataView(1,0,0)==1.0);
5179        assert(myDataView(2,0,0)==1.0);
5180    
5181        myDataView = myData1.getDataPointByTag(1);
5182        assert(!myDataView.isEmpty());
5183        assert(myDataView.getOffset()==27);
5184        assert(myDataView.getRank()==3);
5185        assert(myDataView.noValues()==27);
5186        assert(myDataView.getShape().size()==3);
5187        assert(myDataView(0,0,0)==2.0);
5188        assert(myDataView(1,0,0)==2.0);
5189        assert(myDataView(2,0,0)==2.0);
5190    
5191        myDataView = myData1.getDataPointByTag(2);
5192        assert(!myDataView.isEmpty());
5193        assert(myDataView.getOffset()==54);
5194        assert(myDataView.getRank()==3);
5195        assert(myDataView.noValues()==27);
5196        assert(myDataView.getShape().size()==3);
5197        assert(myDataView(0,0,0)==3.0);
5198        assert(myDataView(1,0,0)==3.0);
5199        assert(myDataView(2,0,0)==3.0);
5200    
5201        myDataView = myData1.getDataPointByTag(3);
5202        assert(!myDataView.isEmpty());
5203        assert(myDataView.getOffset()==81);
5204        assert(myDataView.getRank()==3);
5205        assert(myDataView.noValues()==27);
5206        assert(myDataView.getShape().size()==3);
5207        assert(myDataView(0,0,0)==4.0);
5208        assert(myDataView(1,0,0)==4.0);
5209        assert(myDataView(2,0,0)==4.0);
5210    
5211        // rank 1 slice
5212    
5213        viewShape.clear();
5214        viewShape.push_back(3);
5215    
5216        DataArrayView::ValueType viewData9(3);
5217        for (int i=0;i<viewData9.size();i++) {
5218          viewData9[i]=6.0;
5219        }
5220        DataArrayView myView9(viewData9,viewShape);
5221    
5222        values.clear();
5223    
5224        DataArrayView::ValueType viewData10(3);
5225        for (int i=0;i<viewData10.size();i++) {
5226          viewData10[i]=7.0;
5227        }
5228        DataArrayView myView10(viewData10,viewShape);
5229        values.push_back(myView10);
5230    
5231        DataArrayView::ValueType viewData11(3);
5232        for (int i=0;i<viewData11.size();i++) {
5233          viewData11[i]=8.0;
5234        }
5235        DataArrayView myView11(viewData11,viewShape);
5236        values.push_back(myView11);
5237    
5238        DataArrayView::ValueType viewData12(3);
5239        for (int i=0;i<viewData12.size();i++) {
5240          viewData12[i]=9.0;
5241        }
5242        DataArrayView myView12(viewData12,viewShape);
5243        values.push_back(myView12);
5244    
5245        DataTagged myData3(keys,values,myView9,FunctionSpace());
5246    
5247        region.clear();
5248        region_element.first=0;
5249        region_element.second=3;
5250        region.push_back(region_element);
5251        region_element.second=0;
5252        region.push_back(region_element);
5253        region.push_back(region_element);
5254    
5255        myData1.setSlice(&myData3, region);
5256    
5257        //cout << myData1.toString() << endl;
5258    
5259        assert(myData1.getTagLookup().size()==3);
5260    
5261        assert(myData1.getLength()==108);
5262    
5263        myDataView = myData1.getDefaultValue();
5264        assert(!myDataView.isEmpty());
5265        assert(myDataView.getOffset()==0);
5266        assert(myDataView.getRank()==3);
5267        assert(myDataView.noValues()==27);
5268        assert(myDataView.getShape().size()==3);
5269        assert(myDataView(0,0,0)==6.0);
5270        assert(myDataView(1,0,0)==6.0);
5271        assert(myDataView(2,0,0)==6.0);
5272    
5273        myDataView = myData1.getDataPointByTag(1);
5274        assert(!myDataView.isEmpty());
5275        assert(myDataView.getOffset()==27);
5276        assert(myDataView.getRank()==3);
5277        assert(myDataView.noValues()==27);
5278        assert(myDataView.getShape().size()==3);
5279        assert(myDataView(0,0,0)==7.0);
5280        assert(myDataView(1,0,0)==7.0);
5281        assert(myDataView(2,0,0)==7.0);
5282    
5283        myDataView = myData1.getDataPointByTag(2);
5284        assert(!myDataView.isEmpty());
5285        assert(myDataView.getOffset()==54);
5286        assert(myDataView.getRank()==3);
5287        assert(myDataView.noValues()==27);
5288        assert(myDataView.getShape().size()==3);
5289        assert(myDataView(0,0,0)==8.0);
5290        assert(myDataView(1,0,0)==8.0);
5291        assert(myDataView(2,0,0)==8.0);
5292    
5293        myDataView = myData1.getDataPointByTag(3);
5294        assert(!myDataView.isEmpty());
5295        assert(myDataView.getOffset()==81);
5296        assert(myDataView.getRank()==3);
5297        assert(myDataView.noValues()==27);
5298        assert(myDataView.getShape().size()==3);
5299        assert(myDataView(0,0,0)==9.0);
5300        assert(myDataView(1,0,0)==9.0);
5301        assert(myDataView(2,0,0)==9.0);
5302    
5303        // scalar slice
5304    
5305        viewShape.clear();
5306    
5307        DataArrayView::ValueType viewData13(1);
5308        viewData13[0]=10.0;
5309        DataArrayView myView13(viewData13,viewShape);
5310    
5311        values.clear();
5312    
5313        DataArrayView::ValueType viewData14(1);
5314        viewData14[0]=11.0;
5315        DataArrayView myView14(viewData14,viewShape);
5316        values.push_back(myView14);
5317    
5318        DataArrayView::ValueType viewData15(2);
5319        viewData15[0]=12.0;
5320        DataArrayView myView15(viewData15,viewShape);
5321        values.push_back(myView15);
5322    
5323        DataArrayView::ValueType viewData16(3);
5324        viewData16[0]=13.0;
5325        DataArrayView myView16(viewData16,viewShape);
5326        values.push_back(myView16);
5327    
5328        DataTagged myData4(keys,values,myView13,FunctionSpace());
5329    
5330        region.clear();
5331        region_element.first=0;
5332        region_element.second=0;
5333        region.push_back(region_element);
5334        region.push_back(region_element);
5335        region.push_back(region_element);
5336    
5337        myData1.setSlice(&myData4, region);
5338    
5339        //cout << myData1.toString() << endl;
5340    
5341        myDataView = myData1.getDefaultValue();
5342        assert(!myDataView.isEmpty());
5343        assert(myDataView.getOffset()==0);
5344        assert(myDataView.getRank()==3);
5345        assert(myDataView.noValues()==27);
5346        assert(myDataView.getShape().size()==3);
5347        assert(myDataView(0,0,0)==10.0);
5348    
5349        myDataView = myData1.getDataPointByTag(1);
5350        assert(!myDataView.isEmpty());
5351        assert(myDataView.getOffset()==27);
5352        assert(myDataView.getRank()==3);
5353        assert(myDataView.noValues()==27);
5354        assert(myDataView.getShape().size()==3);
5355        assert(myDataView(0,0,0)==11.0);
5356    
5357        myDataView = myData1.getDataPointByTag(2);
5358        assert(!myDataView.isEmpty());
5359        assert(myDataView.getOffset()==54);
5360        assert(myDataView.getRank()==3);
5361        assert(myDataView.noValues()==27);
5362        assert(myDataView.getShape().size()==3);
5363        assert(myDataView(0,0,0)==12.0);
5364    
5365        myDataView = myData1.getDataPointByTag(3);
5366        assert(!myDataView.isEmpty());
5367        assert(myDataView.getOffset()==81);
5368        assert(myDataView.getRank()==3);
5369        assert(myDataView.noValues()==27);
5370        assert(myDataView.getShape().size()==3);
5371        assert(myDataView(0,0,0)==13.0);
5372    
5373      }
5374    
5375      {
5376    
5377        cout << "\tTest slicing DataTagged with scalar values and three *mismatched* tags." << endl;
5378    
5379        DataTagged::TagListType keys1;
5380        keys1.push_back(1);
5381        keys1.push_back(2);
5382        keys1.push_back(3);
5383    
5384        DataTagged::TagListType keys2;
5385        keys2.push_back(3);
5386        keys2.push_back(4);
5387        keys2.push_back(5);
5388    
5389        DataTagged::ValueListType values;
5390    
5391        DataArrayView::ShapeType viewShape;
5392    
5393        // default value for Data1
5394        DataArrayView::ValueType viewData1(1);
5395        viewData1[0]=0.0;
5396        DataArrayView myView1(viewData1,viewShape);
5397    
5398        // value for tag "1" for Data1
5399        DataArrayView::ValueType viewData2(1);
5400        viewData2[0]=0.0;
5401        DataArrayView myView2(viewData2,viewShape);
5402        values.push_back(myView2);
5403    
5404        // value for tag "2" for Data1
5405        DataArrayView::ValueType viewData5(1);
5406        viewData5[0]=0.0;
5407        DataArrayView myView5(viewData5,viewShape);
5408        values.push_back(myView5);
5409    
5410        // value for tag "3" for Data1
5411        DataArrayView::ValueType viewData6(1);
5412        viewData6[0]=0.0;
5413        DataArrayView myView6(viewData6,viewShape);
5414        values.push_back(myView6);
5415    
5416        DataTagged myData1(keys1,values,myView1,FunctionSpace());
5417    
5418        values.clear();
5419    
5420        // default value for Data2
5421        DataArrayView::ValueType viewData3(1);
5422        viewData3[0]=1.0;
5423        DataArrayView myView3(viewData3,viewShape);
5424    
5425        // value for tag "3" for Data2
5426        DataArrayView::ValueType viewData4(1);
5427        viewData4[0]=2.0;
5428        DataArrayView myView4(viewData4,viewShape);
5429        values.push_back(myView4);
5430    
5431        // value for tag "4" for Data2
5432        DataArrayView::ValueType viewData7(1);
5433        viewData7[0]=3.0;
5434        DataArrayView myView7(viewData7,viewShape);
5435        values.push_back(myView7);
5436    
5437        // value for tag "5" for Data2
5438        DataArrayView::ValueType viewData8(1);
5439        viewData8[0]=4.0;
5440        DataArrayView myView8(viewData8,viewShape);
5441        values.push_back(myView8);
5442    
5443        DataTagged myData2(keys2,values,myView3,FunctionSpace());
5444    
5445        //cout << myData1.toString() << endl;
5446        //cout << myData2.toString() << endl;
5447    
5448        // full slice
5449    
5450        DataArrayView::RegionType region;
5451    
5452        myData1.setSlice(&myData2, region);
5453    
5454        //cout << myData1.toString() << endl;
5455    
5456        assert(myData1.getTagLookup().size()==5);
5457    
5458        assert(myData1.getLength()==6);
5459    
5460        DataArrayView myDataView = myData1.getDefaultValue();
5461        assert(!myDataView.isEmpty());
5462        assert(myDataView.getOffset()==0);
5463        assert(myDataView.getRank()==0);
5464        assert(myDataView.noValues()==1);
5465        assert(myDataView.getShape().size()==0);
5466        assert(myDataView()==1.0);
5467    
5468        myDataView = myData1.getDataPointByTag(1);
5469        assert(!myDataView.isEmpty());
5470        assert(myDataView.getOffset()==1);
5471        assert(myDataView.getRank()==0);
5472        assert(myDataView.noValues()==1);
5473        assert(myDataView.getShape().size()==0);
5474        assert(myDataView()==1.0);
5475    
5476        myDataView = myData1.getDataPointByTag(2);
5477        assert(!myDataView.isEmpty());
5478        assert(myDataView.getOffset()==2);
5479        assert(myDataView.getRank()==0);
5480        assert(myDataView.noValues()==1);
5481        assert(myDataView.getShape().size()==0);
5482        assert(myDataView()==1.0);
5483    
5484        myDataView = myData1.getDataPointByTag(3);
5485        assert(!myDataView.isEmpty());
5486        assert(myDataView.getOffset()==3);
5487        assert(myDataView.getRank()==0);
5488        assert(myDataView.noValues()==1);
5489        assert(myDataView.getShape().size()==0);
5490        assert(myDataView()==2.0);
5491    
5492        myDataView = myData1.getDataPointByTag(4);
5493        assert(!myDataView.isEmpty());
5494        assert(myDataView.getOffset()==4);
5495        assert(myDataView.getRank()==0);
5496        assert(myDataView.noValues()==1);
5497        assert(myDataView.getShape().size()==0);
5498        assert(myDataView()==3.0);
5499    
5500        myDataView = myData1.getDataPointByTag(5);
5501        assert(!myDataView.isEmpty());
5502        assert(myDataView.getOffset()==5);
5503        assert(myDataView.getRank()==0);
5504        assert(myDataView.noValues()==1);
5505        assert(myDataView.getShape().size()==0);
5506        assert(myDataView()==4.0);
5507    
5508      }
5509    
5510    }
5511    
5512  TestSuite* DataTaggedTestCase::suite ()  TestSuite* DataTaggedTestCase::suite ()
5513  {  {
5514    //    //
# Line 2962  TestSuite* DataTaggedTestCase::suite () Line 5520  TestSuite* DataTaggedTestCase::suite ()
5520    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
5521    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
5522    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
5523      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testGetSlice",&DataTaggedTestCase::testGetSlice));
5524      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetSlice",&DataTaggedTestCase::testSetSlice));
5525    return testSuite;    return testSuite;
5526  }  }

Legend:
Removed from v.510  
changed lines
  Added in v.548

  ViewVC Help
Powered by ViewVC 1.1.26