src/MEDMEMBinTest/test_MEDMEM_nArray.cxx

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