src/MEDMEM/test_MEDMEM_nArray.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, CEA, EDF R&D, LEG
   2 //           PRINCIPIA R&D, EADS CCR, Lip6, BV, CEDRAT
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 #include <stdlib.h>
  20 #include <iostream>
  21 #include <stdio.h>
  22
  23 #include "MEDMEM_ArrayInterface.hxx"
  24 #include "MEDMEM_Field.hxx"
  25 #include "MEDMEM_IndexCheckingPolicy.hxx"
  26 #include "MEDMEM_ArrayConvert.hxx"
  27
  28 using namespace MEDMEM;
  29
  30 int main(void) {
  31
  32   const int mdim = 2;
  33   const int nbelem1 = 20;
  34
  35   // TEST n° 1  FullInterlace et NoGauss
  36   std::cout << std::endl;
  37   std::cout << "Test de MEDMEM_Array en FullInterlace et NoGauss : " << std::endl;
  38   std::cout << std::endl;
  39
  40   bool test1ok = true;
  41   const double * myArray1Ptr = 0;
  42   const double array1Ref[]  = { 11 , 12 , 21 , 22 , 31 , 32 , 41 , 42 , 51 , 52 ,
  43                                61 , 62 , 71 , 72 , 81 , 82 , 91 , 92 , 101 , 102 ,
  44                                111 , 112 , 121 , 122 , 131 , 132 , 141 , 142 ,
  45                                151 , 152 , 161 , 162 , 171 , 172 , 181 , 182 ,
  46                                191 , 192 , 201 , 202 };
  47
  48   const double array2Ref[] = { 11 , 21 , 31 , 41 , 51 , 61 , 71 , 81 , 91 , 101
  49                                , 111 , 121 , 131 , 141 , 151 , 161 , 171 , 181
  50                                , 191 , 201 ,
  51                                12 , 22 , 32 , 42 , 52 , 62 , 72 , 82 , 92 , 102
  52                                , 112 , 122 , 132 , 142 , 152 , 162 , 172 , 182
  53                                , 192 , 202 };
  54
  55   MEDMEM_Array<double>  myArray1(mdim,nbelem1);
  56
  57   for (int i =1; i <= nbelem1; i++)
  58     for (int j =1; j <= mdim; j++)
  59       myArray1.setIJ(i,j,i*10+j);
  60
  61   myArray1Ptr = myArray1.getPtr();
  62   for (int i =0; i < mdim*nbelem1; i++)
  63         test1ok = test1ok && ( myArray1Ptr[i] == array1Ref[i] );
  64
  65   std::cout << "- Egualité de myArray1 et de myArray1Ref : " << test1ok << std::endl ;
  66
  67   test1ok = true;
  68   MEDMEM_Array<double> myArray1bis(myArray1, false);
  69   myArray1Ptr = myArray1bis.getPtr();
  70   for (int i =0; i < mdim*nbelem1; i++)
  71         test1ok = test1ok && ( myArray1Ptr[i] == array1Ref[i] );
  72   std::cout << "- Constructeur par recopie en FullInterlace et NoGauss : " << test1ok << std::endl;
  73
  74   test1ok = true;
  75   MEDMEM_Array<double> myArray1ter;
  76   myArray1ter = myArray1;
  77   myArray1Ptr = myArray1ter.getPtr();
  78   for (int i =0; i < mdim*nbelem1; i++)
  79         test1ok = test1ok && ( myArray1Ptr[i] == array1Ref[i] );
  80   std::cout << "- Opérateur d'affectation en FullInterlace et NoGauss : " << test1ok << std::endl;
  81
  82
  83   test1ok = true;
  84   MEDMEM_Array<double> myArray1qua(mdim,nbelem1);
  85   myArray1Ptr = myArray1qua.getPtr();
  86
  87   for (int i =1; i <= nbelem1; i++)
  88     myArray1qua.setRow(i,&array1Ref[(i-1)*mdim]);
  89
  90   for (int i =0; i < mdim*nbelem1; i++)
  91         test1ok = test1ok && ( myArray1Ptr[i] == array1Ref[i] );
  92   std::cout << "- Méthode setRow en FullInterlace et NoGauss : " << test1ok << std::endl;
  93
  94   std::cout << "- Test de levée d'exception pour getColumn : ";
  95   try {
  96     myArray1qua.getColumn(1);
  97   }
  98   catch (MEDMEM::MEDEXCEPTION &m) {
  99     std::cout << m.what() << endl ;
 100   }
 101
 102   test1ok = true;
 103   MEDMEM_Array<double,NoInterlaceNoGaussPolicy> * myArray1cin = ArrayConvert(myArray1);
 104   myArray1Ptr = myArray1cin->getPtr();
 105   int elemno = 0;
 106   for (int j=1; j <= mdim; j++)
 107     for (int  i=1; i <= nbelem1 ; i++ ) {
 108       test1ok = test1ok
 109         && (  myArray1cin->getIJ(i,j) ==  array2Ref[elemno] )
 110         && (  myArray1Ptr[elemno]     ==  array2Ref[elemno] );
 111       elemno++;
 112     }
 113   std::cout << "- Convertion du mode FullInterlaceNoGaussPolicy au mode NoInterlaceNoGaussPolicy : "
 114             << test1ok << std::endl;
 115
 116
 117
 118   // TEST n°2   NoInterlace et NoGauss
 119   std::cout << std::endl;
 120   std::cout << "Test de MEDMEM_Array en NoInterlace et NoGauss : " << std::endl;
 121   std::cout << std::endl;
 122
 123   bool test2ok = true;
 124   const double * myArray2Ptr = 0;
 125
 126   MEDMEM_Array<double,NoInterlaceNoGaussPolicy> myArray2(mdim,nbelem1);
 127
 128   for (int i =1; i <= nbelem1; i++)
 129     for (int j =1; j <= mdim; j++)
 130       myArray2.setIJ(i,j,i*10+j);
 131
 132   myArray2Ptr = myArray2.getPtr();
 133   for (int i =0; i < mdim*nbelem1; i++)
 134         test2ok = test2ok && ( myArray2Ptr[i] == array2Ref[i] );
 135
 136   std::cout << "- Egualité de myArray2 et de myArray2Ref : " << test2ok << std::endl ;
 137
 138   test2ok = true;
 139   MEDMEM_Array<double,NoInterlaceNoGaussPolicy> myArray2bis(myArray2, false);
 140   myArray2Ptr = myArray2bis.getPtr();
 141   for (int i =0; i < mdim*nbelem1; i++)
 142         test2ok = test2ok && ( myArray2Ptr[i] == array2Ref[i] );
 143   std::cout << "- Constructeur par recopie en NoInterlace et NoGauss : " << test2ok << std::endl;
 144
 145   test2ok = true;
 146   MEDMEM_Array<double,NoInterlaceNoGaussPolicy> myArray2ter;
 147   myArray2ter = myArray2;
 148   myArray2Ptr = myArray2ter.getPtr();
 149   for (int i =0; i < mdim*nbelem1; i++)
 150         test2ok = test2ok && ( myArray2Ptr[i] == array2Ref[i] );
 151   std::cout << "- Opérateur d'affectation en NoInterlace et NoGauss : " << test2ok << std::endl;
 152
 153   test2ok = true;
 154   MEDMEM_Array<double,NoInterlaceNoGaussPolicy> myArray2qua(mdim,nbelem1);
 155   myArray2Ptr = myArray2qua.getPtr();
 156
 157   for (int j =1; j <= mdim; j++)
 158     myArray2qua.setColumn(j,&array2Ref[nbelem1*(j-1)]);
 159
 160   for (int i =0; i < mdim*nbelem1; i++)
 161         test2ok = test2ok && ( myArray2Ptr[i] == array2Ref[i] );
 162   std::cout << "- Méthode setColumn en NoInterlace et NoGauss : " << test2ok << std::endl;
 163
 164   std::cout << "- Test de levée d'exception pour getRow : " ;
 165   try {
 166     myArray2qua.getRow(1);
 167   }
 168   catch (MEDMEM::MEDEXCEPTION &m) {
 169     std::cout << m.what() << endl ;
 170   }
 171
 172   test2ok = true;
 173   MEDMEM_Array<double,FullInterlaceNoGaussPolicy> * myArray2cin = ArrayConvert(myArray2);
 174   myArray2Ptr = myArray2cin->getPtr();
 175   elemno = 0;
 176   for (int  i=1; i <= nbelem1 ; i++ )
 177     for (int j=1; j <= mdim; j++) {
 178       test2ok = test2ok
 179         && (  myArray2cin->getIJ(i,j) ==  array1Ref[elemno] )
 180         && (  myArray2Ptr[elemno]     ==  array1Ref[elemno] );
 181       elemno++;
 182     }
 183   std::cout << "- Convertion du mode NoInterlaceNoGaussPolicy au mode FullInterlaceNoGaussPolicy : "
 184             << test2ok << std::endl;
 185
 186
 187   // TEST n°3   FullInterlace et Gauss
 188   const int nbelem2 = 5;
 189   const int nbtypegeo = 2;
 190   const int nbelgeoc[nbtypegeo+1]   = {1,3,6};
 191   const int nbgaussgeo[nbtypegeo+1] = {-1,2,3};
 192
 193   std::cout << std::endl;
 194   std::cout << "Test de MEDMEM_Array en FullInterlace et Gauss : " << std::endl;
 195   std::cout << std::endl;
 196
 197   bool test3ok = true;
 198   const double * myArray3Ptr = 0;
 199   const double array3Ref[] = {1.11 , 1.12 , 1.21 , 1.22 ,
 200                               2.11 , 2.12 , 2.21 , 2.22 ,
 201                               13.11 , 13.12 , 13.21 , 13.22 , 13.31 , 13.32 ,
 202                               14.11 , 14.12 , 14.21 , 14.22 , 14.31 , 14.32 ,
 203                               15.11 , 15.12 , 15.21 , 15.22 , 15.31 , 15.32 };
 204
 205   const double array4Ref[] = { 1.11 , 1.21 , 2.11 , 2.21,
 206                                13.11 , 13.21 , 13.31 , 14.11 , 14.21 , 14.31 ,
 207                                15.11 , 15.21 , 15.31 ,
 208                                1.12 , 1.22 , 2.12 , 2.22 ,
 209                                13.12 , 13.22 , 13.32 , 14.12 , 14.22 , 14.32 ,
 210                                15.12 , 15.22 , 15.32 };
 211
 212   MEDMEM_Array<double,FullInterlaceGaussPolicy> myArray3(mdim,nbelem2,nbtypegeo,nbelgeoc,nbgaussgeo);
 213
 214   elemno = 1;
 215    for (int ntyp=1; ntyp <= nbtypegeo; ntyp++ ) {
 216     for (int  i=0; i < (nbelgeoc[ntyp]-nbelgeoc[ntyp-1]) ; i++ ) {
 217       for (int k=1; k <= nbgaussgeo[ntyp]; k++)
 218         for (int j=1; j <= mdim; j++) {
 219           myArray3.setIJK(elemno,j,k,elemno+(ntyp-1)*10+0.1*k+0.01*j);
 220         }
 221       elemno++;
 222     }
 223   }
 224   myArray3Ptr = myArray3.getPtr();
 225   for (int i =0; i < myArray3.getArraySize(); i++)
 226     test3ok = test3ok && ( myArray3Ptr[i] == array3Ref[i] );
 227
 228   std::cout << "- Egualité de myArray3 et de myArray3Ref : " << test3ok << std::endl ;
 229
 230   test3ok = true;
 231   MEDMEM_Array<double,FullInterlaceGaussPolicy> myArray3bis(myArray3, false);
 232   myArray3Ptr = myArray3bis.getPtr();
 233
 234   elemno = 0;
 235   for (int  i=1; i < nbelgeoc[nbtypegeo] ; i++ )
 236     for (int k=1; k <= myArray3bis.getNbGauss(i); k++)
 237       for (int j=1; j <= mdim; j++) {
 238         test3ok = test3ok
 239           && (  myArray3bis.getIJK(i,j,k)    ==  array3Ref[elemno] )
 240           && (  myArray3Ptr[elemno]          ==  array3Ref[elemno] );
 241         elemno++;
 242       }
 243   std::cout << "- Constructeur par recopie en FullInterlace et Gauss : " << test3ok << std::endl;
 244
 245   test3ok = true;
 246   MEDMEM_Array<double,FullInterlaceGaussPolicy> myArray3ter;
 247   myArray3ter = myArray3; //Opérateur d'affectation
 248   myArray3Ptr = myArray3ter.getPtr();
 249
 250   elemno = 0;
 251   for (int  i=1; i < nbelgeoc[nbtypegeo] ; i++ )
 252     for (int k=1; k <= myArray3ter.getNbGauss(i); k++)
 253       for (int j=1; j <= mdim; j++) {
 254         test3ok = test3ok
 255           && (  myArray3ter.getIJK(i,j,k)    ==  array3Ref[elemno] )
 256           && (  myArray3Ptr[elemno]          ==  array3Ref[elemno] );
 257         elemno++;
 258       }
 259
 260   std::cout << "- Opérateur d'affectation en FullInterlace et Gauss : " << test3ok << std::endl;
 261
 262
 263   test3ok = true;
 264   MEDMEM_Array<double,FullInterlaceGaussPolicy> myArray3qua(mdim,nbelem2,
 265                                                             nbtypegeo,nbelgeoc,nbgaussgeo);
 266   myArray3Ptr = myArray3qua.getPtr();
 267
 268   int cumul = 0;
 269   for (int i =1; i <= nbelem2; i++){
 270     myArray3qua.setRow(i,&array3Ref[cumul]);
 271     cumul+=myArray3qua.getNbGauss(i)*mdim;
 272   };
 273
 274   for (int i =0; i < myArray3qua.getArraySize(); i++)
 275         test3ok = test3ok && ( myArray3Ptr[i] == array3Ref[i] );
 276   std::cout << "- Méthode setRow en FullInterlace et Gauss : " << test3ok << std::endl;
 277
 278   std::cout << "- Test de levée d'exception pour getColumn : " ;
 279   try {
 280     myArray3qua.getColumn(1);
 281   }
 282   catch (MEDMEM::MEDEXCEPTION &m) {
 283     std::cout << m.what() << endl ;
 284   }
 285
 286   test3ok = true;
 287   MEDMEM_Array<double,NoInterlaceGaussPolicy> * myArray3cin = ArrayConvert(myArray3);
 288   myArray3Ptr = myArray3cin->getPtr();
 289   elemno = 0;
 290   for (int j=1; j <= mdim; j++)
 291     for (int  i=1; i < nbelgeoc[nbtypegeo] ; i++ )
 292       for (int k=1; k <= myArray3cin->getNbGauss(i); k++) {
 293         test3ok = test3ok
 294           && (  myArray3cin->getIJK(i,j,k) ==  array4Ref[elemno] )
 295           && (  myArray3Ptr[elemno]        ==  array4Ref[elemno] );
 296         elemno++;
 297       }
 298   std::cout << "- Convertion du mode FullInterlaceGaussPolicy au mode NoInterlaceGaussPolicy : "
 299             << test3ok << std::endl;
 300
 301
 302   // TEST n°4   NoInterlace et Gauss
 303   std::cout << std::endl;
 304   std::cout << "Test de MEDMEM_Array en NoInterlace et Gauss : " << std::endl;
 305   std::cout << std::endl;
 306
 307   bool test4ok = true;
 308   const double * myArray4Ptr = 0;
 309
 310   MEDMEM_Array<double,NoInterlaceGaussPolicy> myArray4(mdim,nbelem2,nbtypegeo,nbelgeoc,nbgaussgeo);
 311
 312   elemno = 1;
 313    for (int ntyp=1; ntyp <= nbtypegeo; ntyp++ ) {
 314     for (int  i=0; i < (nbelgeoc[ntyp]-nbelgeoc[ntyp-1]) ; i++ ) {
 315       for (int k=1; k <= nbgaussgeo[ntyp]; k++)
 316         for (int j=1; j <= mdim; j++) {
 317           myArray4.setIJK(elemno,j,k,elemno+(ntyp-1)*10+0.1*k+0.01*j);
 318         }
 319       elemno++;
 320     }
 321   }
 322   myArray4Ptr = myArray4.getPtr();
 323   for (int i =0; i < myArray4.getArraySize(); i++) {
 324     test4ok = test4ok && ( myArray4Ptr[i] == array4Ref[i] );
 325   }
 326   std::cout << "- Egualité de myArray4 et de myArray4Ref : " << test4ok << std::endl ;
 327
 328   test4ok = true;
 329   MEDMEM_Array<double,NoInterlaceGaussPolicy> myArray4bis(myArray4, false);
 330   myArray4Ptr = myArray4bis.getPtr();
 331
 332   elemno = 0;
 333   for (int j=1; j <= mdim; j++)
 334     for (int  i=1; i < nbelgeoc[nbtypegeo] ; i++ )
 335       for (int k=1; k <= myArray4bis.getNbGauss(i); k++) {
 336         test4ok = test4ok
 337           && (  myArray4bis.getIJK(i,j,k)    ==  array4Ref[elemno] )
 338           && (  myArray4Ptr[elemno]          ==  array4Ref[elemno] );
 339         elemno++;
 340       }
 341   std::cout << "- Constructeur par recopie en NoInterlace et Gauss : " << test4ok << std::endl;
 342
 343   test4ok = true;
 344   MEDMEM_Array<double,NoInterlaceGaussPolicy> myArray4ter;
 345   myArray4ter = myArray4; // Opérateur d'affectation
 346   myArray4Ptr = myArray4ter.getPtr();
 347
 348   elemno = 0;
 349   for (int j=1; j <= mdim; j++)
 350     for (int  i=1; i < nbelgeoc[nbtypegeo] ; i++ )
 351       for (int k=1; k <= myArray4ter.getNbGauss(i); k++) {
 352         test4ok = test4ok
 353           && (  myArray4ter.getIJK(i,j,k)    ==  array4Ref[elemno] )
 354           && (  myArray4Ptr[elemno]          ==  array4Ref[elemno] );
 355         elemno++;
 356       }
 357
 358   std::cout << "- Opérateur d'affectation en NoInterlace et Gauss : " << test4ok << std::endl;
 359
 360
 361   test4ok = true;
 362   MEDMEM_Array<double,NoInterlaceGaussPolicy> myArray4qua(mdim,nbelem2,nbtypegeo,nbelgeoc,nbgaussgeo);
 363   myArray4Ptr = myArray4qua.getPtr();
 364
 365   for (int j =1; j <= mdim; j++)
 366     myArray4qua.setColumn(j,&array4Ref[(myArray4qua.getArraySize()/mdim)*(j-1)]);
 367
 368   for (int i =0; i < myArray4qua.getArraySize(); i++)
 369         test4ok = test4ok && ( myArray4Ptr[i] == array4Ref[i] );
 370   std::cout << "- Méthode setColumn en NoInterlace et Gauss : " << test4ok << std::endl;
 371
 372   std::cout << "- Test de levée d'exception pour getRow : " ;
 373   try {
 374     myArray4qua.getRow(1);
 375   }
 376   catch (MEDMEM::MEDEXCEPTION &m) {
 377     std::cout << m.what() << endl ;
 378   }
 379
 380
 381   test4ok = true;
 382   MEDMEM_Array<double,FullInterlaceGaussPolicy> * myArray4cin = ArrayConvert(myArray4);
 383   //// MEDMEM_Array<double,FullInterlaceGaussPolicy> * myArray4cin;
 384   ////ArrayConvert(myArray4,myArray4cin);
 385   // typedef MEDMEM_Array<double,FullInterlaceGaussPolicy> MyArray;
 386   //   MyArray myArray4cin MyArray(myArray4);
 387   //   myArray4cin.convert(myArray4);
 388   //  MEDMEM_Array<double,FullInterlaceGaussPolicy> myArray4cin(myArray4);
 389   myArray4Ptr = myArray4cin->getPtr();
 390   elemno = 0;
 391   for (int  i=1; i < nbelgeoc[nbtypegeo] ; i++ )
 392     for (int k=1; k <= myArray4cin->getNbGauss(i); k++)
 393       for (int j=1; j <= mdim; j++) {
 394         test4ok = test4ok
 395           && (  myArray4cin->getIJK(i,j,k)   ==  array3Ref[elemno] )
 396           && (  myArray4cin->getIJK(i,j,k)   ==  myArray3.getIJK(i,j,k) )
 397           && (  myArray4Ptr[elemno]          ==  array3Ref[elemno] );
 398         elemno++;
 399       }
 400
 401   std::cout << "- Convertion du mode NoInterlaceGaussPolicy au mode FullInterlaceGaussPolicy : "
 402             << test4ok << std::endl;
 403
 404
 405   //TEST DES METHODES D'INTERROGATION en NoInterlace et Gauss :
 406   //  MEDMEM_ArrayInterface<double,NoInterlace,Gauss>::Array & myArray4bis = myField4bis.getArray();
 407
 408   std::cout << std::endl;
 409   std::cout << "Test de la méthode getDim : " << myArray4bis.getDim() << std::endl;
 410   std::cout << "Test de la méthode getNbelem : " << myArray4bis.getNbElem() << std::endl;
 411   std::cout << "Test de la méthode getArraySize : " << myArray4bis.getArraySize() << std::endl;
 412   std::cout << "Test de la méthode getInterlacingType : " << myArray4bis.getInterlacingType() << std::endl;
 413
 414
 415   // Test de levée d'exception si MED_ARRAY compilée avec une politique de checking
 416   std::cout << std::endl;
 417   std::cout << "Test de levée d'exception pour indice incohérent " << std::endl;
 418   try {
 419     myArray4.getIJ(0,2); //L'exception génère des blocks perdus (A voir)
 420   }
 421   catch (MEDMEM::MEDEXCEPTION &m) {
 422     std::cout << m.what() << endl ;
 423   }
 424
 425
 426
 427   return 0;
 428
 429 };
 430