MEDdatasetNumEcrire232.c

Aller à la documentation de ce fichier.
00001 /*  This file is part of MED.
00002  *
00003  *  COPYRIGHT (C) 1999 - 2015  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 }

Généré le Thu Oct 8 14:26:16 2015 pour MED fichier par  doxygen 1.6.1