# MEDdatasetNumLire232.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 : _MEDdatasetNumLire
    00033  * - Description : lecture 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
    00038  *     - interlace (IN) : Choix du type d'entrelacement demandé par l'appelant { MED_FULL_INTERLACE(x1,y1,z1,x2,...)) , MED_NO_INTERLACE(x1,x2,y1,y2,z1,z2) }
    00039  *       - nbdim   (IN) : Dimension des éléments
    00040  *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer à partir de 1..oo
    00041  *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil
    00042  *       - pflmod  (IN) : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBAL }.
    00043  *       - pflcmp  (IN) : MED_PFL_NON_COMPACT = fichier profil non compacté, MED_PFL_COMPACT = fichier profil compacté
    00044  *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
    00045  *       - ngauss  (IN) : Nombre de points de GAUSS par élément
    00046  *     - nbelem (IN)    : Taille du tableau de valeurs
    00047  *                        (référence tous les élements, cette taille  prend en compte le nombre de pts de gauss et la dimension )
    00048  *                        (n'est utile que pour la lecture en mode MED_GLOBAL d'un champ avec profil compacté : pflcmp = MED_PFL_COMPACT)
    00049  *     - val  (OUT)    : valeurs du tableau
    00050  * - Resultat : 0 en cas de succes, -1 sinon
    00051  *  Equivalent à l'ancienne routine si .....,MED_NO_INTERLACE,1,MED_ALL,MED_NOPF,0,1 (peu importe),....
    00052  */
    00053
    00054
    00055 void  _MEDdatasetNumLire232(int dummy,...) {
    00056
    00057   va_list params;
    00058
    00059   med_idt              pere;
    00060   char                *nom;
    00061   med_type_champ       type;
    00062   med_mode_switch interlace;
    00063   med_size        nbdim,fixdim,psize,*pfltab;
    00064   med_mode_profil pflmod;
    00065   med_int         ngauss,nbelem;
    00066   med_lecture_profil pflcmp;
    00067   unsigned char   *val;
    00068   med_err         *fret;
    00069
    00070   med_idt    dataset, dataspace = 0, memspace = 0;
    00071   med_size   start_mem[1],start_data[1],*pflmem=0,*pfldsk=0;
    00072   med_size   stride[1],count[1],pcount[1],size[1],pflsize[1];
    00073   med_err    ret;
    00074   int        i,j,index,type_hdf;
    00075   hid_t      datatype;
    00076   size_t     typesize;
    00077   int        dim, firstdim, dimutil, lastdim;
    00078   med_size   sizencmp[1];
    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   pflcmp    = va_arg(params,med_lecture_profil);
    00090   pfltab    = va_arg(params,med_size *);
    00091   ngauss    = va_arg(params,med_int);
    00092   nbelem    = va_arg(params,med_int);
    00093   val       = va_arg(params,  unsigned char *);
    00094   fret      = va_arg(params,  med_err *);
    00095
    00096
    00097   /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
    00098   if ( fixdim > nbdim  )
    00099     goto Fail;
    00100
    00101   switch(type)
    00102     {
    00103     case MED_FLOAT64 :
    00104       type_hdf = H5T_NATIVE_DOUBLE;
    00105       break;
    00106
    00107     case MED_INT32 :
    00108       type_hdf = H5T_NATIVE_INT;
    00109       break;
    00110
    00111     case MED_INT64 :
    00112       type_hdf = H5T_NATIVE_LONG;
    00113       break;
    00114
    00115     default :
    00116       goto Fail;
    00117     }
    00118
    00119   /* Ouverture du Dataset à lire */
    00120   if ((dataset = H5Dopen(pere,nom)) < 0)
    00121     goto Fail;
    00122
    00123   /* Interrogation de la taille du dataset */
    00124   if ( (datatype  = H5Dget_type(dataset )) < 0) goto Fail;
    00125   if ( (typesize  = H5Tget_size(datatype)) == 0) goto Fail;
    00126 #if 1
    00127   {
    00128   hid_t   space;
    00129   hsize_t   sizespace[H5S_MAX_RANK];
    00130   hsize_t   maxsizespace[H5S_MAX_RANK];
    00131   int       ndims;
    00132
    00133   space = H5Dget_space(dataset);
    00134   ndims = H5Sget_simple_extent_dims(space, sizespace, maxsizespace);
    00135   H5Sclose(space);
    00136   size[0] = sizespace[0];
    00137   }
    00138 #else
    00139   size[0] = H5Dget_storage_size(dataset) / typesize;
    00140 #endif
    00141   if ( H5Tclose(datatype) < 0) goto Fail;
    00142
    00143
    00144   /* verification (facultative) de la taille du dataset */
    00145   if ( psize != MED_NOPF) {
    00146     if ( pflcmp == MED_PFL_COMPACT ) {
    00147       if (size[0] != psize * ngauss * nbdim)
    00148         goto Fail;
    00149     }
    00150   }
    00151
    00152   /* Create dataspace */
    00153   if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
    00154     goto Fail;
    00155
    00156   switch(interlace) {
    00157     case MED_FULL_INTERLACE :
    00158
    00159       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00160       if ( fixdim != MED_ALL) {
    00161             firstdim = fixdim-1;
    00162             lastdim  = fixdim;
    00163             dimutil  = 1;
    00164           }
    00165       else      {
    00166             firstdim = 0;
    00167             lastdim = nbdim;
    00168             dimutil  = nbdim;
    00169           }
    00170
    00171       count [0] = (*size)/(nbdim);
    00172
    00173
    00174       /*rem: Pas de vérification de l'assertion (*size)=n*nbdim */
    00175       if ( psize == MED_NOPF ) {
    00176
    00177         tracepfl(printf("%s branche 1 : %lld\n", __FILE__, fixdim));
    00178
    00179             /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00180             if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
    00181               goto Fail;
    00182
    00183             stride[0] = nbdim;
    00184
    00185             for (dim=firstdim; dim < lastdim; dim++) {
    00186
    00187               start_mem[0] = dim;
    00188               if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride,
    00189                                            count, NULL)) <0)
    00190                 goto Fail;
    00191
    00192               start_data[0] = dim*count[0];
    00193               if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00194                                            count, NULL)) <0)
    00195                 goto Fail;
    00196
    00197               if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,
    00198                              H5P_DEFAULT, val)) < 0)
    00199                 goto Fail;
    00200             }
    00201
    00202       }
    00203       else {
    00204
    00205             pflsize [0] = psize*ngauss*nbdim;
    00206             pcount  [0] = psize*ngauss*dimutil;
    00207             pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00208             pfldsk     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00209
    00210             switch(pflmod) { /* switch pflmod pour FULL_INTERLACE*/
    00211               case MED_GLOBAL :
    00212
    00213             tracepfl(printf("%s branche 2 : %lld - %d\n", __FILE__, fixdim, pflcmp));
    00214
    00215                 /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00216             if (pflcmp == MED_PFL_COMPACT)
    00217               sizencmp[0] = nbelem * nbdim;
    00218             else
    00219               sizencmp[0] = size[0];
    00220             if ( (memspace = H5Screate_simple (1, sizencmp, NULL)) <0)
    00221               goto Fail;
    00222
    00223                 for (dim=firstdim; dim < lastdim; dim++) {
    00224
    00225                   for (i=0; i < psize; i++)              /* i balaye les élements du profil */
    00226                     for (j=0; j < ngauss; j++) {
    00227                           index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00228                           pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
    00229                           if (pflcmp == MED_PFL_COMPACT)
    00230                             pfldsk[index] = dim*count[0] + i*ngauss+j;
    00231                           else
    00232                             pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00233                     }
    00234                 }
    00235
    00236                 if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00237                   goto Fail;
    00238
    00239                 if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00240                   goto Fail;
    00241
    00242                 break;
    00243
    00244               case MED_COMPACT :
    00245
    00246             tracepfl(printf("%s branche 3 : %lld - %d\n", __FILE__, fixdim, pflcmp));
    00247
    00248                 /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00249                 /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00250                 /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00251
    00252                 if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
    00253                   goto Fail;
    00254
    00255                 for (dim=firstdim; dim < lastdim; dim++) {
    00256
    00257                   for (i=0; i < psize; i++)              /* i balaye les élements du profil */
    00258                     for (j=0; j < ngauss; j++) {
    00259                           index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00260                           pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
    00261                           if (pflcmp == MED_PFL_COMPACT)
    00262                             pfldsk[index] = dim*count[0] + i*ngauss+j;
    00263                           else
    00264                             pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00265                     }
    00266                 }
    00267
    00268                 if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00269                   goto Fail;
    00270
    00271                 if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00272                   goto Fail;
    00273
    00274                 break;
    00275
    00276               default :
    00277                 goto Fail;
    00278             }
    00279
    00280             if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00281               goto Fail;
    00282
    00283             free(pflmem);
    00284             free(pfldsk);
    00285       }
    00286
    00287       break;
    00288
    00289     case MED_NO_INTERLACE :
    00290
    00291       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00292
    00293       count[0] = (*size)/nbdim;
    00294
    00295       if ( psize == MED_NOPF ) {
    00296
    00297         tracepfl(printf("%s branche 4 : %d\n", __FILE__, fixdim));
    00298
    00299             if ( fixdim != MED_ALL)
    00300               start_data[0] = (fixdim-1)*count[0];
    00301             else {
    00302               count[0] = *size;
    00303               start_data[0] =  0;
    00304             };
    00305
    00306             if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00307                                          count, NULL)) <0)
    00308               goto Fail;
    00309
    00310             if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,
    00311                            H5P_DEFAULT, val)) < 0)
    00312               goto Fail;
    00313
    00314       }
    00315       else {
    00316
    00317             if ( fixdim != MED_ALL) {
    00318               firstdim = fixdim-1;
    00319               lastdim  = fixdim;
    00320               dimutil  = 1;
    00321             }
    00322         else    {
    00323               firstdim = 0;
    00324               lastdim  = nbdim;
    00325               dimutil  = nbdim;
    00326             }
    00327
    00328             pflsize [0] = psize*ngauss*nbdim;   /* taille du memspace (toutes les composantes) */
    00329             pcount  [0] = psize*ngauss*dimutil; /* taille des indexes de selection, pflmem et pfldsk  */
    00330             /*nom pas très coherent avec count !!! A revoir */
    00331             pfldsk      = (med_size *) malloc(sizeof(med_size)*pcount[0]);
    00332
    00333             switch(pflmod) { /*switch plfmod pour NO_INTERLACE */
    00334               case MED_GLOBAL :
    00335
    00336             tracepfl(printf("%s branche 5 : %lld - %d\n", __FILE__, fixdim, pflcmp));
    00337
    00338                 if ( pflcmp == MED_PFL_COMPACT ) {
    00339                   pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00340                   sizencmp[0] = nbelem * nbdim;
    00341               if ( (memspace = H5Screate_simple (1, sizencmp, NULL)) <0)
    00342                     goto Fail;
    00343                 }
    00344
    00345                 for (dim=firstdim; dim < lastdim; dim++) {
    00346
    00347                   for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
    00348                         for (j=0; j < ngauss; j++) {
    00349                           index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00350                           if ( pflcmp == MED_PFL_COMPACT ) {
    00351                             pflmem[index] = dim*nbelem+(pfltab[i]-1)*ngauss+j;
    00352                             pfldsk[index] = dim*count[0] + i*ngauss+j;
    00353                           }
    00354                           else {
    00355                             pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00356                           }
    00357                         }
    00358                 }
    00359
    00360                 if ( pflcmp == MED_PFL_COMPACT ) {
    00361                   if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00362                     goto Fail;
    00363
    00364                   if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00365                     goto Fail;
    00366
    00367                   if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00368                     goto Fail;
    00369
    00370                   free(pflmem);
    00371             }
    00372             else {
    00373
    00374                   if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00375                     goto Fail;
    00376
    00377                   if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
    00378                     goto Fail;
    00379                 }
    00380
    00381                 break;
    00382
    00383               case MED_COMPACT :
    00384
    00385             tracepfl(printf("%s branche 6 : %lld - %d\n", __FILE__, fixdim, pflcmp));
    00386
    00387                 if ( pflcmp == MED_PFL_NON_COMPACT ) {
    00388               /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00389                   /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00390                   /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00391
    00392                   if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
    00393                     goto Fail;
    00394
    00395                   /*La taille de pflmem n'est pas forcément égale à celle de memspace, ex : choix de lire 1 composante*/
    00396                   pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00397                 }
    00398
    00399                 /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
    00400
    00401                 index = 0;
    00402                 for (dim=firstdim; dim < lastdim; dim++) {
    00403                   for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil */
    00404                         for (j=0; j < ngauss; j++) {
    00405                           /*FORMULATION 1ere : index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);*/
    00406                           /*FORMULATION 2sd  : index = ( (dim-firstdim)*psize + i )*ngauss + j;   */
    00407                           /*FORMULATION 1ere : pflmem[index] = dim*(psize*ngauss) + i*ngauss+j;*/
    00408                           if ( pflcmp == MED_PFL_NON_COMPACT ) {
    00409                     pflmem[index] = ( (dim*psize) + i )*ngauss + j;
    00410                             pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;
    00411                           }
    00412                   else {
    00413                     pfldsk[index] = dim*count[0] + i*ngauss+j;
    00414                   }
    00415                           index++;
    00416                         }
    00417                 }
    00418
    00419                 if ( pflcmp == MED_PFL_NON_COMPACT ) {
    00420               if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00421                     goto Fail;
    00422
    00423                   if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00424                     goto Fail;
    00425
    00426                   if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00427                     goto Fail;
    00428
    00429                   free(pflmem);
    00430                 }
    00431             else {
    00432                   if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00433                     goto Fail;
    00434
    00435                   if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
    00436                     goto Fail;
    00437             }
    00438
    00439                 break;
    00440
    00441               default :
    00442                 goto Fail;
    00443
    00444             }
    00445
    00446             free(pfldsk);
    00447
    00448       };
    00449
    00450       break;
    00451
    00452     default :
    00453       goto Fail;
    00454   }
    00455
    00456
    00457
    00458   if (memspace)
    00459     if ((ret = H5Sclose(memspace)) < 0)
    00460       goto Fail;
    00461
    00462   if ((ret = H5Sclose(dataspace)) < 0)
    00463     goto Fail;
    00464
    00465   if ((ret = H5Dclose(dataset)) < 0)
    00466     goto Fail;
    00467
    00468  Success:
    00469   va_end(params);
    00470   *fret=0;
    00471   return;
    00472
    00473  Fail:
    00474   va_end(params);
    00475   *fret = -1;
    00476   return;
    00477 }