# MEDdatasetNumEcrire231.c

Aller à la documentation de ce fichier.

    00001 /*  This file is part of MED.
    00002  *
    00003  *  COPYRIGHT (C) 1999 - 2011  EDF R&D, CEA/DEN
    00004  *  MED is free software: you can redistribute it and/or modify
    00005  *  it under the terms of the GNU Lesser General Public License as published by
    00006  *  the Free Software Foundation, either version 3 of the License, or
    00007  *  (at your option) any later version.
    00008  *
    00009  *  MED is distributed in the hope that it will be useful,
    00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00012  *  GNU Lesser General Public License for more details.
    00013  *
    00014  *  You should have received a copy of the GNU Lesser General Public License
    00015  *  along with MED.  If not, see <http://www.gnu.org/licenses/>.
    00016  */
    00017
    00018
    00019 #include <med.h>
    00020 #include <med_config.h>
    00021 #include <med_outils.h>
    00022 #include <hdf5.h>
    00023
    00024 /*
    00025  * - Nom de la fonction : _MEDdatasetNumEcrire
    00026  * - Description : ecriture d'un dataset tableau numerique
    00027  * - Parametres :
    00028  *     - pere (IN)      : l'ID de l'objet HDF pere ou placer l'attribut
    00029  *     - nom  (IN)      : le nom du dataset
    00030  *     - type (IN)      : type numerique MED { MED_FLOAT64 , MED_INT32 , MED_INT64 }
    00031  *     - interlace (IN) : Choix du type d'entrelacement utilisé par l'appelant
    00032  *                        { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
    00033  *       - nbdim   (IN) : Dimension des éléments
    00034  *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer
    00035  *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil
    00036  *                        (référence les élements, cette taille ne prend pas en compte le nombre de pts de gauss ni la dimension )
    00037  *       - pflmod  (IN) : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }.
    00038  *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
    00039  *       - ngauss  (IN) : Nombre de points de GAUSS par élément
    00040  *     - size (IN)     : Taille du tableau de valeurs
    00041  *                        (référence tous les élements, cette taille  prend en compte le nombre de pts de gauss et la dimension )
    00042  *     - val  (IN)     : valeurs du tableau
    00043  * - Resultat : 0 en cas de succes, -1 sinon
    00044  */
    00045
    00046 void  _MEDdatasetNumEcrire231(int dummy,...) {
    00047
    00048   va_list params;
    00049
    00050   med_idt         pere;
    00051   char *          nom;
    00052   med_type_champ  type;
    00053   med_mode_switch interlace;
    00054   med_size        nbdim, fixdim, psize, * pfltab, *size;
    00055   med_mode_profil pflmod;
    00056   med_int         ngauss;
    00057   unsigned char   *val;
    00058   med_int         modifpfl;
    00059   med_err *       fret;
    00060
    00061   med_idt    dataset, dataspace = 0, memspace = 0;
    00062   med_size   start_mem[1],start_data[1],*pflmem,*pfldsk;
    00063   med_size   stride[1],count[1],pcount[1],pflsize[1];
    00064   med_err    ret;
    00065   int        i,j,index,type_hdf;
    00066   int        dim, firstdim, dimutil, lastdim ;
    00067   med_mode_acces MED_MODE_ACCES;
    00068
    00069   va_start(params,dummy);
    00070   pere      = va_arg(params,med_idt);
    00071   nom       = va_arg(params,char *);
    00072   type      = va_arg(params,med_type_champ);
    00073   interlace = va_arg(params,med_mode_switch);
    00074   nbdim     = va_arg(params,med_size);
    00075   fixdim    = va_arg(params,med_size);
    00076   psize     = va_arg(params,med_size);
    00077   pflmod    = va_arg(params,med_mode_profil);
    00078   modifpfl  = va_arg(params,med_int);
    00079   pfltab    = va_arg(params,med_size *);
    00080   ngauss    = va_arg(params,med_int);
    00081   size      = va_arg(params,med_size *);
    00082   val       = va_arg(params,  unsigned char *);
    00083   fret      = va_arg(params,  med_err *);
    00084
    00085   /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
    00086   if ( fixdim > nbdim )
    00087     goto Fail;
    00088
    00089   switch(type)
    00090     {
    00091     case MED_FLOAT64 :
    00092       type_hdf = H5T_NATIVE_DOUBLE;
    00093       break;
    00094
    00095     case MED_INT32 :
    00096       type_hdf = H5T_NATIVE_INT;
    00097       break;
    00098
    00099     case MED_INT64 :
    00100       type_hdf = H5T_NATIVE_LONG;
    00101       break;
    00102
    00103     default :
    00104       goto Fail;
    00105     }
    00106
    00107   if ( (MED_MODE_ACCES = _MEDmodeAcces(pere) ) == MED_UNDEF_MODE_ACCES ) {
    00108     MESSAGE("Impossible de déterminer le mode d'acces au fichier ");
    00109     goto Fail;
    00110   }
    00111
    00112   if ((dataset = H5Dopen(pere,nom)) < 0)
    00113     {
    00114       /* Whatever the size of the profil is we create a dataset with the size of the value array                   */
    00115       /* Then if we used the MED_LECTURE_AJOUT mode we can append a new dimension to a previous one in the dataset */
    00116       /* When we'll use the compression mode, the space used by unused values would be easily compressed           */
    00117
    00118       if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
    00119         goto Fail;
    00120       if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace,
    00121                                H5P_DEFAULT)) < 0)
    00122         goto Fail;
    00123     }
    00124   else
    00125     if ( MED_MODE_ACCES == MED_LECTURE_AJOUT )
    00126       {
    00127         H5Dclose(dataset);
    00128         goto Fail;
    00129       }
    00130     else
    00131       if ((dataspace = H5Dget_space(dataset)) <0)
    00132         goto Fail;
    00133
    00134
    00135   switch(interlace)
    00136     {  /* switch Interlace */
    00137     case MED_FULL_INTERLACE :
    00138
    00139       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00140       if ( fixdim != MED_ALL)
    00141         {
    00142           firstdim = fixdim-1;
    00143           lastdim  = fixdim;
    00144           dimutil  = 1;
    00145         } else  {
    00146           firstdim = 0;
    00147           lastdim  = nbdim;
    00148           dimutil  = nbdim;
    00149         }
    00150
    00151       count [0] = (*size)/(nbdim);
    00152
    00153
    00154       if ( psize == MED_NOPF ) {
    00155
    00156         /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00157         if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
    00158           goto Fail;
    00159
    00160         stride[0] = nbdim;
    00161
    00162         for (dim=firstdim; dim < lastdim; dim++) {
    00163
    00164           start_mem[0] = dim;
    00165           if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride,
    00166                                            count, NULL)) <0)
    00167             goto Fail;
    00168
    00169           start_data[0] = dim*count[0];
    00170           if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00171                                            count, NULL)) <0)
    00172             goto Fail;
    00173
    00174           if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,
    00175                               H5P_DEFAULT, val)) < 0)
    00176             goto Fail;
    00177         }
    00178
    00179       } else { /* psize != MED_NOPF */
    00180
    00181         pflsize [0] = psize*ngauss*nbdim;
    00182         pcount  [0] = psize*ngauss*dimutil;
    00183         pflmem      = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00184         pfldsk      = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00185
    00186         switch(pflmod)
    00187           { /* switch pflmod pout FULL_INTERLACE*/
    00188           case MED_GLOBAL :
    00189
    00190             /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00191             if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
    00192               goto Fail;
    00193
    00194             for (dim=firstdim; dim < lastdim; dim++) {
    00195
    00196               for (i=0; i < psize; i++)              /* i balaye les élements du profil */
    00197                 for (j=0; j < ngauss; j++) {
    00198                   index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00199                   pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
    00200                   pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00201                 }
    00202             }
    00203
    00204             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00205               goto Fail;
    00206
    00207             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00208               goto Fail;
    00209
    00210             break;
    00211
    00212           case MED_COMPACT :
    00213
    00214             /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00215             /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00216             /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00217
    00218             if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
    00219               goto Fail;
    00220
    00221             for (dim=firstdim; dim < lastdim; dim++) {
    00222
    00223               for (i=0; i < psize; i++)              /* i balaye les élements du profil */
    00224                 for (j=0; j < ngauss; j++) {
    00225                   index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00226                   pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
    00227                   pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00228                 }
    00229             }
    00230
    00231             if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00232               goto Fail;
    00233
    00234             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00235               goto Fail;
    00236
    00237             break;
    00238
    00239           default :
    00240             goto Fail;
    00241           }
    00242
    00243         if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00244           goto Fail;
    00245
    00246         free(pflmem);
    00247         free(pfldsk);
    00248       }
    00249
    00250
    00251       break;
    00252
    00253     case MED_NO_INTERLACE :
    00254
    00255       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00256
    00257       count[0] = (*size)/nbdim;
    00258
    00259       if ( psize == MED_NOPF ) {
    00260
    00261         if ( fixdim != MED_ALL)
    00262           start_data[0] = (fixdim-1)*count[0];
    00263         else {
    00264           count[0] = *size;
    00265           start_data[0] =  0;
    00266         };
    00267
    00268         if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00269                                          count, NULL)) <0)
    00270           goto Fail;
    00271
    00272         if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,
    00273                             H5P_DEFAULT, val)) < 0)
    00274           goto Fail;
    00275
    00276       } else {
    00277
    00278         if ( fixdim != MED_ALL)
    00279           {
    00280             firstdim = fixdim-1;
    00281             lastdim  = fixdim;
    00282             dimutil  = 1;
    00283           } else        {
    00284             firstdim = 0;
    00285             lastdim  = nbdim;
    00286             dimutil  = nbdim;
    00287           }
    00288
    00289         pflsize [0] = psize*ngauss*nbdim;
    00290         pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */
    00291         pfldsk     = (med_size *) malloc(sizeof(med_size)*pcount[0]);
    00292
    00293         switch(pflmod)
    00294           { /*switch plfmod pour NO_INTERLACE */
    00295           case MED_GLOBAL :
    00296
    00297             for (dim=firstdim; dim < lastdim; dim++) {
    00298
    00299               for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
    00300                 for (j=0; j < ngauss; j++) {
    00301                   index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00302                   pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;
    00303                 }
    00304             }
    00305
    00306             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00307               goto Fail;
    00308
    00309             if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
    00310               goto Fail;
    00311
    00312             break;
    00313
    00314           case MED_COMPACT :
    00315
    00316             /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00317             /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00318             /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00319
    00320             if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
    00321               goto Fail;
    00322
    00323             pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00324
    00325             /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
    00326
    00327             index = 0;
    00328             for (dim=firstdim; dim < lastdim; dim++) {
    00329
    00330               for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
    00331                 for (j=0; j < ngauss; j++) {
    00332                   /*FORMULATION 1ere : index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);*/
    00333                   /*FORMULATION 1ere : pflmem[index] = dim*(psize*ngauss) + i*ngauss+j;*/
    00334                   pflmem[index] = ( (dim*psize) + i )*ngauss + j;
    00335                   pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;
    00336                   index++;
    00337                 }
    00338             }
    00339
    00340             if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00341               goto Fail;
    00342
    00343             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00344               goto Fail;
    00345
    00346             if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00347               goto Fail;
    00348
    00349             free(pflmem);
    00350
    00351             break;
    00352
    00353           default :
    00354             goto Fail;
    00355
    00356           }
    00357
    00358         free(pfldsk);
    00359
    00360       };
    00361
    00362       break;
    00363
    00364     default :
    00365       goto Fail;
    00366     }
    00367
    00368
    00369   if (memspace)
    00370     if ((ret = H5Sclose(memspace)) < 0)
    00371       goto Fail;
    00372
    00373   if ((ret = H5Sclose(dataspace)) < 0)
    00374     goto Fail;
    00375
    00376   if ((ret = H5Dclose(dataset)) < 0)
    00377     goto Fail;
    00378
    00379  Success:
    00380   va_end(params);
    00381   *fret=0;
    00382   return;
    00383
    00384  Fail:
    00385   va_end(params);
    00386   *fret = -1;
    00387   return;
    00388 }