# MEDdatasetNumEcrire232.c

Aller à la documentation de ce fichier.

    00001 /*  This file is part of MED.
    00002  *
    00003  *  COPYRIGHT (C) 1999 - 2012  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 #ifdef TRACEPFL
    00026 #define tracepfl(x) x
    00027 #else
    00028 #define tracepfl(x)
    00029 #endif
    00030
    00031 /*
    00032  * - Nom de la fonction : _MEDdatasetNumEcrire
    00033  * - Description : ecriture d'un dataset tableau numerique
    00034  * - Parametres :
    00035  *     - pere (IN)      : l'ID de l'objet HDF pere ou placer l'attribut
    00036  *     - nom  (IN)      : le nom du dataset
    00037  *     - type (IN)      : type numerique MED { MED_FLOAT64 , MED_INT32 , MED_INT64 }
    00038  *     - interlace (IN) : Choix du type d'entrelacement utilisé par l'appelant
    00039  *                        { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
    00040  *       - nbdim   (IN) : Dimension des éléments
    00041  *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer
    00042  *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil
    00043  *                        (référence les élements, cette taille ne prend pas en compte le nombre de pts de gauss ni la dimension )
    00044  *       - pflmod  (IN) : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBALE }.
    00045  *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
    00046  *       - ngauss  (IN) : Nombre de points de GAUSS par élément
    00047  *     - size (IN)     : Taille du tableau de valeurs
    00048  *                        (référence tous les élements, cette taille  prend en compte le nombre de pts de gauss et la dimension )
    00049  *     - val  (IN)     : valeurs du tableau
    00050  *     - modifpfl (IN) : Si psize != MED_NOPF :
    00051  *                         - modifpfl == 1   indique que la taille ou le contenu du profil a changé
    00052  *                         - modifpfl == 0   indique que la taille ou le contenu du profil n'a pas changé
    00053  * - Resultat : 0 en cas de succes, -1 sinon
    00054  */
    00055
    00056 void  _MEDdatasetNumEcrire232(int dummy,...) {
    00057
    00058   va_list params;
    00059
    00060   med_idt         pere;
    00061   char *          nom;
    00062   med_type_champ  type;
    00063   med_mode_switch interlace;
    00064   med_size        nbdim, fixdim, psize, * pfltab, *size;
    00065   med_mode_profil pflmod;
    00066   med_int         ngauss,modifpfl;
    00067   unsigned char   *val;
    00068   med_err *       fret;
    00069
    00070   med_idt    dataset=0, dataspace=0, memspace=0;
    00071   med_size   start_mem[1],start_data[1],*pflmem=NULL,*pfldsk=NULL;
    00072   med_size   stride[1],count[1],pcount[1],pflsize[1];
    00073   med_size   datasetsize[1], countncmp=0;
    00074   med_err    ret=-1;
    00075   int        i=0,j=0,index=0,type_hdf=0;
    00076   int        dim=0, firstdim=0, dimutil=0, lastdim=0 ;
    00077   int        datasetsizeEqualTosizespace = 0;
    00078   med_mode_acces MED_MODE_ACCES;
    00079
    00080   va_start(params,dummy);
    00081   pere      = va_arg(params,med_idt);
    00082   nom       = va_arg(params,char *);
    00083   type      = va_arg(params,med_type_champ);
    00084   interlace = va_arg(params,med_mode_switch);
    00085   nbdim     = va_arg(params,med_size);
    00086   fixdim    = va_arg(params,med_size);
    00087   psize     = va_arg(params,med_size);
    00088   pflmod    = va_arg(params,med_mode_profil);
    00089   modifpfl  = va_arg(params,med_int);
    00090   pfltab    = va_arg(params,med_size *);
    00091   ngauss    = va_arg(params,med_int);
    00092   size      = va_arg(params,med_size *);
    00093   val       = va_arg(params,  unsigned char *);
    00094   fret      = va_arg(params,  med_err *);
    00095
    00096
    00097   if ( (MED_MODE_ACCES = _MEDmodeAcces(pere) ) == MED_UNDEF_MODE_ACCES ) {
    00098     MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
    00099     goto ERROR;
    00100   }
    00101
    00102   if ( MED_MODE_ACCES == MED_LECTURE) {
    00103     MESSAGE("Impossible d'écrire un dataset en mode MED_LECTURE.");
    00104     goto ERROR;
    00105   };
    00106
    00107   switch(type)
    00108     {
    00109     case MED_FLOAT64 :
    00110       type_hdf = H5T_NATIVE_DOUBLE;
    00111       break;
    00112
    00113     case MED_INT32 :
    00114       type_hdf = H5T_NATIVE_INT;
    00115       break;
    00116
    00117     case MED_INT64 :
    00118       type_hdf = H5T_NATIVE_LONG;
    00119       break;
    00120
    00121     default :
    00122       goto ERROR;
    00123     }
    00124
    00125   /* Calcul de la taille du dataset cible*/
    00126   if ( psize == MED_NOPF )
    00127     datasetsize[0] = size[0];
    00128   else
    00129     datasetsize[0] = psize*ngauss*nbdim;
    00130
    00131   /* On s'assure de l'existence d'un dataset.
    00132      S'il n'existe pas, il est crée en mode MED_LECTURE_ECRITURE, une
    00133      erreur est retournée en mode MED_LECTURE_AJOUT.
    00134      S'il existe on lit sa taille. */
    00135   if ( (dataset = H5Dopen(pere,nom)) < 0) {
    00136
    00137     if ((dataspace = H5Screate_simple(1,datasetsize,NULL)) < 0) {
    00138       MESSAGE("Impossible de créer un dataspace de taille : ");
    00139       ISCRUTE_size(datasetsize[0]);
    00140       goto ERROR;
    00141     }
    00142     if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace,
    00143                              H5P_DEFAULT)) < 0) {
    00144       MESSAGE("Impossible de créer un le dataset de nom : ");
    00145       SSCRUTE(nom);
    00146       goto ERROR;
    00147     }
    00148
    00149   } else {
    00150
    00151     /* L'ajout s'entend au niveau de l'entité dataset qui ne doit pas préexister */
    00152     if ( MED_MODE_ACCES == MED_LECTURE_AJOUT )  {
    00153       MESSAGE("Impossible de créer un nouveau dataset en mode MED_LECTURE_AJOUT.");
    00154       goto ERROR;
    00155     }
    00156
    00157     if ( (dataspace = H5Dget_space(dataset)) <0 ) {
    00158       MESSAGE("Impossible de déterminer la taille du dataset existant : ");
    00159       ISCRUTE_int(dataset);
    00160       goto ERROR;
    00161     }
    00162
    00163     {
    00164       hsize_t   sizespace   [H5S_MAX_RANK];
    00165       hsize_t   maxsizespace[H5S_MAX_RANK];
    00166
    00167       H5Sget_simple_extent_dims(dataspace, sizespace, maxsizespace);
    00168       datasetsizeEqualTosizespace = ( (sizespace[0]) == datasetsize[0] );
    00169     }
    00170
    00171     /* Si un dataset prexiste en MED_LECTURE_ECRITURE
    00172        Il est possible de compléter/écraser
    00173        les valeurs du dataset par les nouvelles valeurs si :
    00174        - sa taille  ne change pas
    00175        - son profil ne change pas (taille ou contenu)
    00176     */
    00177
    00178     if ( ( !datasetsizeEqualTosizespace ) || ( psize != MED_NOPF && modifpfl ) ) {
    00179       H5Dclose(dataset);
    00180       if (H5Gunlink(pere, nom) < 0) goto ERROR;
    00181       if ( (dataset = H5Dcreate(pere,nom,type_hdf,dataspace,H5P_DEFAULT)) < 0)
    00182         goto ERROR;
    00183     }
    00184
    00185   }
    00186
    00187   /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
    00188   if ( fixdim > nbdim ) {
    00189     MESSAGE("Impossible d'écrire sur une dimension fixée non comprise entre 0 et le nombre de dimensions : ");
    00190     ISCRUTE_size(nbdim);
    00191     goto ERROR;
    00192   }
    00193
    00194   switch(interlace) {  /* switch Interlace */
    00195   case MED_FULL_INTERLACE :
    00196
    00197     /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00198     if ( fixdim != MED_ALL) {
    00199       firstdim = fixdim-1;
    00200       lastdim  = fixdim;
    00201       dimutil  = 1;
    00202     }
    00203     else        {
    00204       firstdim = 0;
    00205       lastdim  = nbdim;
    00206       dimutil  = nbdim;
    00207     }
    00208
    00209     /* ancienne formule             */
    00210     /* count [0] = (*size)/(nbdim); */
    00211     count[0] = datasetsize[0] / nbdim;
    00212
    00213
    00214     if ( psize == MED_NOPF ) {
    00215
    00216       tracepfl(printf("%s branche 1 : %lld\n", __FILE__, fixdim));
    00217
    00218       /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00219       if ( (memspace = H5Screate_simple (1, size, NULL)) <0) {
    00220         MESSAGE("Impossible de créer un memspace de taille : ");
    00221         ISCRUTE_size(*size);
    00222         goto ERROR;
    00223       }
    00224
    00225       stride[0] = nbdim;
    00226
    00227       for (dim=firstdim; dim < lastdim; dim++) {
    00228
    00229         start_mem[0] = dim;
    00230         if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride,
    00231                                          count, NULL)) <0) {
    00232           MESSAGE("Impossible d'effectuer une sélection sur le memspace  : ");
    00233           ISCRUTE(memspace);
    00234           goto ERROR;
    00235         }
    00236
    00237         start_data[0] = dim*count[0];
    00238         if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00239                                          count, NULL)) <0) {
    00240           MESSAGE("Impossible d'effectuer une sélection sur le dataspace  : ");
    00241           ISCRUTE_int(dataspace);
    00242           goto ERROR;
    00243         }
    00244
    00245         if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,
    00246                             H5P_DEFAULT, val)) < 0) {
    00247           MESSAGE("Erreur à l'écriture du dataset : ");
    00248           ISCRUTE_int(dataset);
    00249           MESSAGE("en mode MED_FULL_INTERLACE sans profil");
    00250           goto ERROR;
    00251         }
    00252       }
    00253
    00254     } else { /* psize != MED_NOPF */
    00255
    00256       pflsize [0] = psize*ngauss*nbdim;
    00257       pcount  [0] = psize*ngauss*dimutil;
    00258       pflmem      = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00259       pfldsk      = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00260
    00261       switch(pflmod) { /* gestion des du mode GLOBAL/COMPACT ne entrelacement FULL_INTERLACE*/
    00262       case MED_GLOBAL :
    00263
    00264         tracepfl(printf("%s branche 2 : %lld\n", __FILE__, fixdim));
    00265
    00266         /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00267         if ( (memspace = H5Screate_simple (1, size, NULL)) <0) {
    00268           MESSAGE("Impossible de créer un memspace de taille : ");
    00269           ISCRUTE_size(*size);
    00270           goto ERROR;
    00271         }
    00272
    00273         for (dim=firstdim; dim < lastdim; dim++) {
    00274
    00275           for (i=0; i < psize; i++) {              /* i balaye les élements du profil */
    00276             for (j=0; j < ngauss; j++) {
    00277               index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00278               pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
    00279               /* ancienne formule                                       */
    00280               /* pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; */
    00281               pfldsk[index] = dim*count[0] + i*ngauss+j;
    00282             }
    00283           }
    00284         }
    00285
    00286         if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0) {
    00287           MESSAGE("Impossible d'effectuer une sélection sur le memspace  : ");
    00288           ISCRUTE(memspace);
    00289           goto ERROR;
    00290         }
    00291
    00292         if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0) {
    00293           MESSAGE("Impossible d'effectuer une sélection sur le dataspace  : ");
    00294           ISCRUTE_int(dataspace);
    00295           goto ERROR;
    00296         }
    00297
    00298         break;
    00299
    00300       case MED_COMPACT :
    00301
    00302         tracepfl(printf("%s branche 3 : %lld\n", __FILE__, fixdim));
    00303
    00304         /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00305         /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00306         /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00307
    00308         if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) {
    00309           MESSAGE("Impossible de créer un memspace de taille : ");
    00310           ISCRUTE_size(pflsize[0]);
    00311           goto ERROR;
    00312         }
    00313
    00314         for (dim=firstdim; dim < lastdim; dim++) {
    00315
    00316           for (i=0; i < psize; i++) {              /* i balaye les élements du profil */
    00317             for (j=0; j < ngauss; j++) {
    00318               index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00319               pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
    00320               /* ancienne formule                                       */
    00321               /* pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; */
    00322               pfldsk[index] = dim*count[0] + i*ngauss+j;
    00323             }
    00324           }
    00325         }
    00326
    00327         if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0) {
    00328           MESSAGE("Impossible d'effectuer une sélection sur le memspace  : ");
    00329           ISCRUTE(memspace);
    00330           goto ERROR;
    00331         }
    00332
    00333         if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)  {
    00334           MESSAGE("Impossible d'effectuer une sélection sur le dataspace  : ");
    00335           ISCRUTE_int(dataspace);
    00336           goto ERROR;
    00337         }
    00338
    00339         break;
    00340
    00341       default :
    00342         MESSAGE("Impossible de déterminer le mode d'utilisation du profil (MED_GLOBAL/MED_COMPACT)");
    00343         goto ERROR;
    00344       }
    00345
    00346       if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0){
    00347         MESSAGE("Erreur à l'écriture du dataset : ");
    00348         ISCRUTE_int(dataset);
    00349         MESSAGE("en mode FULL_INTERLACE avec profil");
    00350         goto ERROR;
    00351       }
    00352
    00353       free(pflmem);pflmem=NULL;
    00354       free(pfldsk);pfldsk=NULL;
    00355
    00356     } /* psize != MED_NOPF */
    00357
    00358
    00359     break;
    00360
    00361   case MED_NO_INTERLACE :
    00362
    00363     /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00364
    00365     /* ancienne formule           */
    00366     /* count [0] = (*size)/nbdim; */
    00367     count[0] = datasetsize[0] / nbdim;
    00368
    00369     if ( psize == MED_NOPF ) { /* psize == MED_NOPF, MED_NO_INTERLACE */
    00370
    00371       tracepfl(printf("%s branche 4 : %lld\n", __FILE__, fixdim));
    00372
    00373       if ( fixdim != MED_ALL)
    00374         start_data[0] = (fixdim-1)*count[0];
    00375       else {
    00376         count[0] = *size;
    00377         start_data[0] =  0;
    00378       };
    00379
    00380       if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00381                                        count, NULL)) <0) {
    00382         MESSAGE("Impossible d'effectuer une sélection sur le dataspace  : ");
    00383         ISCRUTE_int(dataspace);
    00384         goto ERROR;
    00385       }
    00386
    00387       if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,
    00388                           H5P_DEFAULT, val)) < 0) {
    00389         MESSAGE("Erreur à l'écriture du dataset : ");
    00390         ISCRUTE_int(dataset);
    00391         MESSAGE("en mode MED_NO_INTERLACE sans profil");
    00392         goto ERROR;
    00393       }
    00394
    00395     } else {  /* psize != MED_NOPF, MED_NO_INTERLACE */
    00396
    00397       if ( fixdim != MED_ALL) {
    00398         firstdim = fixdim-1;
    00399         lastdim  = fixdim;
    00400         dimutil  = 1;
    00401       } else {
    00402         firstdim = 0;
    00403         lastdim  = nbdim;
    00404         dimutil  = nbdim;
    00405       }
    00406
    00407       pflsize [0] = psize*ngauss*nbdim;
    00408       pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */
    00409       pfldsk     = (med_size *) malloc(sizeof(med_size)*pcount[0]);
    00410
    00411       switch(pflmod) { /*switch plfmod pour GLOBAL/COMPACT */
    00412       case MED_GLOBAL :
    00413
    00414         tracepfl(printf("%s branche 5 : %lld\n", __FILE__, fixdim));
    00415
    00416         /* ajout de memspace pour le compactage */
    00417
    00418         /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00419         /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00420         /*  que l'utilisateur a toutes les coordonées stockées, même s'il en demande qu'une */
    00421
    00422         if ( (memspace = H5Screate_simple (1, size, NULL)) <0) {
    00423           MESSAGE("Impossible dde créer le memspace de taille ");
    00424           ISCRUTE_size(*size);
    00425           goto ERROR;
    00426         }
    00427
    00428         pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00429         countncmp  = size[0] / nbdim;
    00430
    00431         for (dim=firstdim; dim < lastdim; dim++) {
    00432
    00433           for (i=0; i < psize; i++) {              /* i balaye le nbre d'élements du profil                */
    00434             for (j=0; j < ngauss; j++) {
    00435               index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00436               pflmem[index] = dim*countncmp + (pfltab[i]-1)*ngauss+j;
    00437               /* ancienne formule                                       */
    00438               /* pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; */
    00439               pfldsk[index] = dim*count[0] + i*ngauss+j;
    00440             }
    00441           }
    00442         }
    00443
    00444         if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pflmem ) ) <0) {
    00445           MESSAGE("Impossible d'effectuer une sélection sur le memspace  : ");
    00446           ISCRUTE(memspace);
    00447           goto ERROR;
    00448         }
    00449
    00450         if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0) {
    00451           MESSAGE("Impossible d'effectuer une sélection sur le dataspace  : ");
    00452           ISCRUTE_int(dataspace);
    00453           goto ERROR;
    00454         }
    00455
    00456         if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) {
    00457           MESSAGE("Erreur à l'écriture du dataset : ");
    00458           ISCRUTE_int(dataset);
    00459           MESSAGE("en mode NO_INTERLACE avec profil GLOBAL");
    00460           goto ERROR;
    00461         }
    00462
    00463         free(pflmem);pflmem=NULL;
    00464
    00465         break;
    00466
    00467       case MED_COMPACT :
    00468
    00469         tracepfl(printf("%s branche 6 : %lld\n", __FILE__, fixdim));
    00470
    00471         /* memspace est en fait inutile pour le compactage */
    00472
    00473         /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00474         /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00475         /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00476
    00477         if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0) {
    00478           MESSAGE("Impossible de créer le memspace de taille : ");
    00479           ISCRUTE_llong(pflsize[0]);
    00480           goto ERROR;
    00481         }
    00482
    00483         pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00484
    00485         /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
    00486
    00487         index = 0;
    00488         for (dim=firstdim; dim < lastdim; dim++) {
    00489
    00490           for (i=0; i < psize; i++) {              /* i balaye le nbre d'élements du profil                */
    00491             for (j=0; j < ngauss; j++) {
    00492               /*FORMULATION 1ere : index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);*/
    00493               /*FORMULATION 1ere : pflmem[index] = dim*(psize*ngauss) + i*ngauss+j;*/
    00494               pflmem[index] = ( (dim*psize) + i )*ngauss + j;
    00495               /* ancienne formule                                       */
    00496               /* pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j; */
    00497               pfldsk[index] = dim*count[0] + i*ngauss+j;
    00498               index++;
    00499             }
    00500           }
    00501         }
    00502
    00503         if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pflmem ) ) <0) {
    00504           MESSAGE("Impossible d'effectuer une sélection sur le memspace  : ");
    00505           ISCRUTE(memspace);
    00506           goto ERROR;
    00507         }
    00508
    00509         if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0) {
    00510           MESSAGE("Impossible d'effectuer une sélection sur le dataspace  : ");
    00511           ISCRUTE_int(dataspace);
    00512           goto ERROR;
    00513         }
    00514
    00515         if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0) {
    00516           MESSAGE("Erreur à l'écriture du dataset : ");
    00517           ISCRUTE_int(dataset);
    00518           MESSAGE("en mode MED_NO_INTERLACE avec profil COMPACT");
    00519           goto ERROR;
    00520         }
    00521         free(pflmem);pflmem=NULL;
    00522
    00523         break;
    00524
    00525       default :
    00526         MESSAGE("Impossible de déterminer le mode d'utilisation du profil (MED_GLOBAL/MED_COMPACT en entrelacement MED_NO_INTERLACE");
    00527         goto ERROR;
    00528
    00529       }
    00530       free(pfldsk);pfldsk=NULL;
    00531
    00532     } /* fin du else ( psize != MED_NOPF ) */
    00533
    00534     break;
    00535
    00536   default :
    00537     MESSAGE("Mode d'entrelacement inconnu.");
    00538     goto ERROR;
    00539   }
    00540
    00541   ret = 0;
    00542
    00543  ERROR:
    00544
    00545   if (pflmem) free(pflmem);
    00546   if (pfldsk) free(pfldsk);
    00547
    00548   if ( memspace ) if ( (ret = H5Sclose(memspace)) < 0) {
    00549     MESSAGE("Impossible de fermer le memspace : ");
    00550     ISCRUTE(memspace);  ret = -1;
    00551   }
    00552
    00553   if ( dataspace ) if ( (ret = H5Sclose(dataspace)) < 0) {
    00554     MESSAGE("Impossible de fermer le dataspace : ");
    00555     ISCRUTE_int(dataspace); ret = -1;
    00556   }
    00557
    00558   if ( dataset ) if ( (ret = H5Dclose(dataset)) < 0) {
    00559     MESSAGE("Impossible de fermer le dataset : ");
    00560     ISCRUTE_int(dataset);   ret = -1;
    00561   }
    00562
    00563   va_end(params);
    00564   *fret = ret;
    00565   return;
    00566 }