src/MEDWrapper/V2_1/Core/MEDdatasetNumEcrire.cxx

   1 /*************************************************************************
   2 * COPYRIGHT (C) 1999 - 2002  EDF R&D
   3 * THIS LIBRARY IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   4 * IT UNDER THE TERMS OF THE GNU LESSER GENERAL PUBLIC LICENSE
   5 * AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION;
   6 * EITHER VERSION 2.1 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
   7 *
   8 * THIS LIBRARY IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
   9 * 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 LICENSE
  14 * ALONG WITH THIS LIBRARY; IF NOT, WRITE TO THE FREE SOFTWARE FOUNDATION,
  15 * INC., 59 TEMPLE PLACE, SUITE 330, BOSTON, MA 02111-1307 USA
  16 *
  17 *************************************************************************/
  18
  19 #include "med.hxx"
  20 #include "med_outils.hxx"
  21 #include <stdlib.h>
  22 #include "hdf5_version2api.hxx"
  23
  24 /*
  25  * - Nom de la fonction : _MEDdatasetNumEcrire
  26  * - Description : ecriture d'un dataset tableau numerique
  27  * - Parametres :
  28  *     - pere (IN)      : l'ID de l'objet HDF pere ou placer l'attribut
  29  *     - nom  (IN)      : le nom du dataset
  30  *     - type (IN)      : type numerique MED { MED_REEL64 , MED_INT32 , MED_INT64 }
  31  *     - interlace (IN) : Choix du type d'entrelacement utilisé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
  32  *       - nbdim   (IN) : Dimension des éléments
  33  *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer
  34  *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil
  35  *                        (référence les élements, cette taille ne prend pas en compte le nombre de pts de gauss ni la dimension )
  36  *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
  37  *       - pflmod  (IN) : PARAMETRE A AJOUTER : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }.
  38  *       - ngauss  (IN) : Nombre de points de GAUSS par élément
  39  *     - size (IN)     : Taille du tableau de valeurs
  40  *                        (référence tous les élements, cette taille  prend en compte le nombre de pts de gauss et la dimension )
  41  *     - val  (IN)     : valeurs du tableau
  42  *     - mode (IN)     : mode d'ecriture MED (MED_ECRI | MED_REMP)
  43  * - Resultat : 0 en cas de succes, -1 sinon
  44  */
  45
  46 namespace med_2_1{
  47
  48 med_err
  49 _MEDdatasetNumEcrire(med_idt pere,char *nom, med_type_champ type,
  50                      med_mode_switch interlace, med_size nbdim, med_size fixdim,
  51                      med_size psize, med_ssize * pfltab, med_int ngauss,
  52                      med_size *size,  unsigned char *val, med_mode_acces mode)
  53 {
  54   med_idt    dataset, dataspace = 0, memspace = 0;
  55 #ifdef HDF_NEW_API
  56   med_size  start_mem[1],start_data[1],*pflmem,*pfldsk;
  57 #else
  58   med_ssize  start_mem[1],start_data[1],*pflmem,*pfldsk;
  59 #endif
  60   med_size   stride[1],count[1],pcount[1],pflsize[1];
  61   med_err    ret;
  62   int        i,j,index,type_hdf;
  63   int        dim, firstdim, dimutil, lastdim ;
  64   med_mode_profil pflmod;
  65
  66   /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
  67   if ( ( fixdim < 0 ) || ( fixdim > nbdim ) )
  68     return -1;
  69
  70   /* block pflmod to MED_COMPACT (until med2.2) */
  71   pflmod = MED_COMPACT;
  72
  73   switch(type)
  74     {
  75     case MED_REEL64 :
  76       /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
  77          the file read under SGI is incorrect
  78          2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
  79          REM  : Be careful of compatibility between MED files when changing this (med2.2)                    */
  80 #if defined(PCLINUX) || defined(PCLINUX64) || defined(PCLINUX64_32) || defined(OSF1) || defined( PPRO_NT )
  81       type_hdf = H5T_IEEE_F64BE;
  82 #else
  83       type_hdf = H5T_IEEE_F64LE;
  84 #endif
  85       break;
  86
  87     case MED_INT32 :
  88 #if defined(PCLINUX) || defined(PCLINUX64) || defined(PCLINUX64_32)
  89       type_hdf = H5T_STD_I32BE;
  90       if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,(hsize_t)*size,(void *)val,NULL,(hid_t)0)) < 0)
  91           return -1;
  92 #else
  93       type_hdf = H5T_NATIVE_INT;
  94 #endif
  95       break;
  96
  97     case MED_INT64 :
  98       type_hdf = H5T_NATIVE_LONG;
  99       break;
 100
 101     default :
 102       return -1;
 103     }
 104
 105
 106   if ((dataset = H5Dopen(pere,nom)) < 0)
 107     {
 108       /* Whatever the size of the profil is we create a dataset with the size of the value array               */
 109       /* Then if we used the MED_REMP mode we can append a new dimension to a previous one in the dataset      */
 110       /* When we'll use the compression mode, the space used by unused values would be easily compressed       */
 111
 112       if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
 113         return -1;
 114       if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace,
 115                                H5P_DEFAULT)) < 0)
 116         return -1;
 117     }
 118   else
 119     if (mode != MED_REMP)
 120       {
 121         H5Dclose(dataset);
 122         return -1;
 123       }
 124     else
 125       if ((dataspace = H5Dget_space(dataset)) <0)
 126         return -1;
 127
 128
 129   switch(interlace)
 130     {  /* switch Interlace */
 131     case MED_FULL_INTERLACE :
 132
 133       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
 134       if ( fixdim != MED_ALL)
 135         {
 136           firstdim = (int)fixdim-1;
 137           lastdim  = (int)fixdim;
 138           dimutil  = 1;
 139         } else  {
 140           firstdim = 0;
 141           lastdim  = (int)nbdim;
 142           dimutil  = (int)nbdim;
 143         }
 144
 145       count [0] = (*size)/(nbdim);
 146
 147
 148       if ( psize == MED_NOPF ) {
 149
 150         /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
 151         if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
 152           return -1;
 153
 154         stride[0] = nbdim;
 155
 156         for (dim=firstdim; dim < lastdim; dim++) {
 157
 158           start_mem[0] = dim;
 159           if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride,
 160                                            count, NULL)) <0)
 161             return -1;
 162
 163           start_data[0] = dim*count[0];
 164           if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
 165                                            count, NULL)) <0)
 166             return -1;
 167
 168           if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,
 169                               H5P_DEFAULT, val)) < 0)
 170             return -1;
 171         }
 172
 173       } else { /* psize != MED_NOPF */
 174
 175         pflsize [0] = psize*ngauss*nbdim;
 176         pcount  [0] = psize*ngauss*dimutil;
 177 #ifdef HDF_NEW_API
 178         pflmem      = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
 179         pfldsk      = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
 180 #else
 181         pflmem      = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
 182         pfldsk      = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
 183 #endif
 184
 185         switch(pflmod)
 186           { /* switch pflmod pout FULL_INTERLACE*/
 187           case MED_GLOBALE :
 188
 189             /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
 190             if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
 191               return -1;
 192
 193             for (dim=firstdim; dim < lastdim; dim++) {
 194
 195               for (i=0; i < psize; i++)              /* i balaye les élements du profil */
 196                 for (j=0; j < ngauss; j++) {
 197                   index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
 198                   pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
 199                   pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
 200                 }
 201             }
 202
 203 #ifdef HDF_NEW_API2
 204             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0)
 205               return -1;
 206
 207             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0)
 208               return -1;
 209 #elif defined HDF_NEW_API
 210             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0)
 211               return -1;
 212
 213             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0)
 214               return -1;
 215 #else
 216             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0)
 217               return -1;
 218
 219             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0)
 220               return -1;
 221 #endif
 222
 223             break;
 224
 225           case MED_COMPACT :
 226
 227             /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
 228             /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
 229             /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
 230
 231             if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
 232               return -1;
 233
 234             for (dim=firstdim; dim < lastdim; dim++) {
 235
 236               for (i=0; i < psize; i++)              /* i balaye les élements du profil */
 237                 for (j=0; j < ngauss; j++) {
 238                   index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
 239                   pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
 240                   pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
 241                 }
 242             }
 243
 244 #ifdef HDF_NEW_API2
 245             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0)
 246               return -1;
 247
 248             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0)
 249               return -1;
 250 #elif defined HDF_NEW_API
 251             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0)
 252               return -1;
 253
 254             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0)
 255               return -1;
 256 #else
 257             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0)
 258               return -1;
 259
 260             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0)
 261               return -1;
 262 #endif
 263
 264             break;
 265
 266           default :
 267             return -1;
 268           }
 269
 270         if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
 271           return -1;
 272
 273         free(pflmem);
 274         free(pfldsk);
 275       }
 276
 277
 278       break;
 279
 280     case MED_NO_INTERLACE :
 281
 282       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
 283
 284       count[0] = (*size)/nbdim;
 285
 286       if ( psize == MED_NOPF ) {
 287
 288         if ( fixdim != MED_ALL)
 289           start_data[0] = (fixdim-1)*count[0];
 290         else {
 291           count[0] = *size;
 292           start_data[0] =  0;
 293         };
 294
 295         if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
 296                                          count, NULL)) <0)
 297           return -1;
 298
 299         if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,
 300                             H5P_DEFAULT, val)) < 0)
 301           return -1;
 302
 303       } else {
 304
 305         if ( fixdim != MED_ALL)
 306           {
 307             firstdim = (int)fixdim-1;
 308             lastdim  = (int)fixdim;
 309             dimutil  = 1;
 310           } else        {
 311             firstdim = 0;
 312             lastdim  = (int)nbdim;
 313             dimutil  = (int)nbdim;
 314           }
 315
 316         pflsize [0] = psize*ngauss*nbdim;
 317         pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */
 318 #ifdef HDF_NEW_API
 319         pfldsk     = (med_size *) malloc(sizeof(med_size)*(size_t)pcount[0]);
 320 #else
 321         pfldsk     = (med_ssize *) malloc(sizeof(med_ssize)*(size_t)pcount[0]);
 322 #endif
 323
 324         switch(pflmod)
 325           { /*switch plfmod pour NO_INTERLACE */
 326           case MED_GLOBALE :
 327
 328             for (dim=firstdim; dim < lastdim; dim++) {
 329
 330               for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
 331                 for (j=0; j < ngauss; j++) {
 332                   index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
 333                   pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;
 334                 }
 335             }
 336
 337 #ifdef HDF_NEW_API2
 338             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0)
 339               return -1;
 340 #elif defined HDF_NEW_API
 341             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0)
 342               return -1;
 343 #else
 344             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0)
 345               return -1;
 346 #endif
 347
 348             if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
 349               return -1;
 350
 351             break;
 352
 353           case MED_COMPACT :
 354
 355             /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
 356             /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
 357             /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
 358
 359             if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
 360               return -1;
 361
 362 #ifdef HDF_NEW_API
 363             pflmem     = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
 364 #else
 365             pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
 366 #endif
 367
 368             /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
 369
 370             for (dim=firstdim; dim < lastdim; dim++) {
 371
 372               for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
 373                 for (j=0; j < ngauss; j++) {
 374                   index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
 375                   pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j;
 376                   pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;
 377                 }
 378             }
 379
 380 #ifdef HDF_NEW_API2
 381             if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pflmem ) ) <0)
 382               return -1;
 383
 384             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0)
 385               return -1;
 386 #elif defined HDF_NEW_API
 387             if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pflmem ) ) <0)
 388               return -1;
 389
 390             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0)
 391               return -1;
 392 #else
 393             if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pflmem ) ) <0)
 394               return -1;
 395
 396             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0)
 397               return -1;
 398 #endif
 399
 400             if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
 401               return -1;
 402
 403             free(pflmem);
 404
 405             break;
 406
 407           default :
 408             return -1;
 409
 410           }
 411
 412         free(pfldsk);
 413
 414       };
 415
 416       break;
 417
 418     default :
 419       return -1;
 420     }
 421
 422
 423   if (memspace)
 424     if ((ret = H5Sclose(memspace)) < 0)
 425       return -1;
 426
 427   if ((ret = H5Sclose(dataspace)) < 0)
 428     return -1;
 429
 430   if ((ret = H5Dclose(dataset)) < 0)
 431     return -1;
 432
 433 #if defined(PCLINUX) || defined(PCLINUX64) || defined(PCLINUX64_32)
 434   if (type == MED_INT32)
 435       if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,(hsize_t)*size,(void *)val,NULL,(hid_t)0)) < 0)
 436           return -1;
 437 #endif
 438
 439   return 0;
 440 }
 441
 442 }