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

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

  ViewVC Help
Powered by ViewVC 1.1.26