/[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 527 by jgs, Wed Feb 15 01:25:57 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  TestSuite* DataTaggedTestCase::suite ()  TestSuite* DataTaggedTestCase::suite ()
4190  {  {
4191    //    //
# Line 2962  TestSuite* DataTaggedTestCase::suite () Line 4197  TestSuite* DataTaggedTestCase::suite ()
4197    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testCopyConstructors",&DataTaggedTestCase::testCopyConstructors));
4198    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testOperations",&DataTaggedTestCase::testOperations));
4199    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));    testSuite->addTest (new TestCaller< DataTaggedTestCase>("testReshape",&DataTaggedTestCase::testReshape));
4200      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testGetSlice",&DataTaggedTestCase::testGetSlice));
4201      testSuite->addTest (new TestCaller< DataTaggedTestCase>("testSetSlice",&DataTaggedTestCase::testSetSlice));
4202    return testSuite;    return testSuite;
4203  }  }

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

  ViewVC Help
Powered by ViewVC 1.1.26