# MEDdatasetNumLire231.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 : _MEDdatasetNumLire
    00026  * - Description : lecture 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
    00031  *     - 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) }
    00032  *       - nbdim   (IN) : Dimension des éléments
    00033  *       - fixdim  (IN) : MED_ALL ou n° de la dimension a enregistrer à partir de 1..oo
    00034  *     - psize     (IN) : Taille du profil à utiliser, MED_NOPF si pas de profil
    00035  *       - pflmod  (IN) : Indique comment lire les informations en mémoire { MED_COMPACT, MED_GLOBAL }.
    00036  *       - pfltab  (IN) : Tableau contenant les n° déléments à traiter (1....oo)
    00037  *       - ngauss  (IN) : Nombre de points de GAUSS par élément
    00038  *     - val  (OUT)    : valeurs du tableau
    00039  * - Resultat : 0 en cas de succes, -1 sinon
    00040  *  Equivalent à l'ancienne routine si .....,MED_NO_INTERLACE,1,MED_ALL,MED_NOPF,0,1 (peu importe),....
    00041  */
    00042
    00043
    00044 void  _MEDdatasetNumLire231(int dummy,...) {
    00045
    00046   va_list params;
    00047
    00048   med_idt              pere;
    00049   char                *nom;
    00050   med_type_champ       type;
    00051   med_mode_switch interlace;
    00052   med_size        nbdim,fixdim,psize,*pfltab;
    00053   med_mode_profil pflmod;
    00054   med_int         ngauss,nbelem;
    00055   med_lecture_profil pflcmp;
    00056   unsigned char   *val;
    00057   med_err         *fret;
    00058
    00059   med_idt    dataset, dataspace = 0, memspace = 0;
    00060   med_size   start_mem[1],start_data[1],*pflmem=0,*pfldsk=0;
    00061   med_size   stride[1],count[1],pcount[1],size[1],pflsize[1];
    00062   med_err    ret;
    00063   int        i,j,index,type_hdf;
    00064   hid_t      datatype;
    00065   size_t     typesize;
    00066   int        dim, firstdim, dimutil, lastdim;
    00067
    00068   va_start(params,dummy);
    00069   pere      = va_arg(params,med_idt);
    00070   nom       = va_arg(params,char *);
    00071   type      = va_arg(params,med_type_champ);
    00072   interlace = va_arg(params,med_mode_switch);
    00073   nbdim     = va_arg(params,med_size);
    00074   fixdim    = va_arg(params,med_size);
    00075   psize     = va_arg(params,med_size);
    00076   pflmod    = va_arg(params,med_mode_profil);
    00077   pflcmp    = va_arg(params,med_lecture_profil);
    00078   pfltab    = va_arg(params,med_size *);
    00079   ngauss    = va_arg(params,med_int);
    00080   nbelem    = va_arg(params,med_int);
    00081   val       = va_arg(params,  unsigned char *);
    00082   fret      = va_arg(params,  med_err *);
    00083
    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   /* Ouverture du Dataset à lire */
    00108   if ((dataset = H5Dopen(pere,nom)) < 0)
    00109     goto Fail;
    00110
    00111   /* Interrogation de la taille du dataset */
    00112   if ( (datatype  = H5Dget_type(dataset )) < 0) goto Fail;
    00113   if ( (typesize  = H5Tget_size(datatype)) == 0) goto Fail;
    00114   size[0] = H5Dget_storage_size(dataset) / typesize;
    00115   if ( H5Tclose(datatype) < 0) goto Fail;
    00116
    00117   /* Create dataspace */
    00118   if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
    00119     goto Fail;
    00120
    00121   switch(interlace)
    00122     {
    00123     case MED_FULL_INTERLACE :
    00124
    00125       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00126       if ( fixdim != MED_ALL)
    00127         {
    00128           firstdim = fixdim-1;
    00129           lastdim  = fixdim;
    00130           dimutil  = 1;
    00131         } else  {
    00132           firstdim = 0;
    00133           lastdim = nbdim;
    00134           dimutil  = nbdim;
    00135         }
    00136
    00137       count [0] = (*size)/(nbdim);
    00138
    00139
    00140       /*rem: Pas de vérification de l'assertion (*size)=n*nbdim */
    00141       if ( psize == MED_NOPF ) {
    00142
    00143         /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00144         if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
    00145           goto Fail;
    00146
    00147         stride[0] = nbdim;
    00148
    00149         for (dim=firstdim; dim < lastdim; dim++) {
    00150
    00151           start_mem[0] = dim;
    00152           if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride,
    00153                                            count, NULL)) <0)
    00154             goto Fail;
    00155
    00156           start_data[0] = dim*count[0];
    00157           if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00158                                            count, NULL)) <0)
    00159             goto Fail;
    00160
    00161           if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,
    00162                              H5P_DEFAULT, val)) < 0)
    00163             goto Fail;
    00164         }
    00165
    00166       } else {
    00167
    00168         pflsize [0] = psize*ngauss*nbdim;
    00169         pcount  [0] = psize*ngauss*dimutil;
    00170         pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00171         pfldsk     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00172
    00173         switch(pflmod) { /* switch pflmod pour FULL_INTERLACE*/
    00174         case MED_GLOBAL :
    00175
    00176           /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
    00177           if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
    00178             goto Fail;
    00179
    00180           for (dim=firstdim; dim < lastdim; dim++) {
    00181
    00182             for (i=0; i < psize; i++)              /* i balaye les élements du profil */
    00183               for (j=0; j < ngauss; j++) {
    00184                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00185                 pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
    00186                 pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00187               }
    00188           }
    00189
    00190           if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00191             goto Fail;
    00192
    00193           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00194             goto Fail;
    00195
    00196           break;
    00197
    00198         case MED_COMPACT :
    00199
    00200           /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00201           /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00202           /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00203
    00204           if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
    00205             goto Fail;
    00206
    00207           for (dim=firstdim; dim < lastdim; dim++) {
    00208
    00209             for (i=0; i < psize; i++)              /* i balaye les élements du profil */
    00210               for (j=0; j < ngauss; j++) {
    00211                 index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00212                 pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
    00213                 pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;
    00214               }
    00215           }
    00216
    00217           if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00218             goto Fail;
    00219
    00220           if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00221             goto Fail;
    00222
    00223           break;
    00224
    00225         default :
    00226           goto Fail;
    00227         }
    00228
    00229         if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00230           goto Fail;
    00231
    00232         free(pflmem);
    00233         free(pfldsk);
    00234       }
    00235
    00236       break;
    00237
    00238     case MED_NO_INTERLACE :
    00239
    00240       /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
    00241
    00242       count[0] = (*size)/nbdim;
    00243
    00244       if ( psize == MED_NOPF ) {
    00245
    00246         if ( fixdim != MED_ALL)
    00247           start_data[0] = (fixdim-1)*count[0];
    00248         else {
    00249           count[0] = *size;
    00250           start_data[0] =  0;
    00251         };
    00252
    00253         if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL,
    00254                                          count, NULL)) <0)
    00255           goto Fail;
    00256
    00257         if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,
    00258                            H5P_DEFAULT, val)) < 0)
    00259           goto Fail;
    00260
    00261       } else {
    00262
    00263         if ( fixdim != MED_ALL)
    00264           {
    00265             firstdim = fixdim-1;
    00266             lastdim  = fixdim;
    00267             dimutil  = 1;
    00268           } else        {
    00269             firstdim = 0;
    00270             lastdim  = nbdim;
    00271             dimutil  = nbdim;
    00272           }
    00273
    00274         pflsize [0] = psize*ngauss*nbdim;   /* taille du memspace (toutes les composantes) */
    00275         pcount  [0] = psize*ngauss*dimutil; /* taille des indexes de selection, pflmem et pfldsk  */
    00276         /*nom pas très coherent avec count !!! A revoir */
    00277         pfldsk      = (med_size *) malloc(sizeof(med_size)*pcount[0]);
    00278
    00279         switch(pflmod)
    00280           { /*switch plfmod pour NO_INTERLACE */
    00281           case MED_GLOBAL :
    00282
    00283             for (dim=firstdim; dim < lastdim; dim++) {
    00284
    00285               for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
    00286                 for (j=0; j < ngauss; j++) {
    00287                   index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
    00288                   pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;
    00289                 }
    00290             }
    00291
    00292             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00293               goto Fail;
    00294
    00295             if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
    00296               goto Fail;
    00297
    00298             break;
    00299
    00300           case MED_COMPACT :
    00301
    00302             /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
    00303             /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
    00304             /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */
    00305
    00306             if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
    00307               goto Fail;
    00308
    00309             /*La taille de pflmem n'est pas forcément égale à celle de memspace, ex : choix de lire 1 composante*/
    00310             pflmem     = (med_size *) malloc (sizeof(med_size)*pcount[0]);
    00311
    00312             /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
    00313
    00314             index = 0;
    00315             for (dim=firstdim; dim < lastdim; dim++) {
    00316               for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil */
    00317                 for (j=0; j < ngauss; j++) {
    00318                   /*FORMULATION 1ere : index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);*/
    00319                   /*FORMULATION 2sd  : index = ( (dim-firstdim)*psize + i )*ngauss + j;   */
    00320                   /*FORMULATION 1ere : pflmem[index] = dim*(psize*ngauss) + i*ngauss+j;*/
    00321                   pflmem[index] = ( (dim*psize) + i )*ngauss + j;
    00322                   pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;
    00323                   index++;
    00324                 }
    00325             }
    00326
    00327             if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, pcount[0], HDF5_SELECT_BUG pflmem ) ) <0)
    00328               goto Fail;
    00329
    00330             if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,pcount[0], HDF5_SELECT_BUG pfldsk ) ) <0)
    00331               goto Fail;
    00332
    00333             if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
    00334               goto Fail;
    00335
    00336             free(pflmem);
    00337
    00338             break;
    00339
    00340           default :
    00341             goto Fail;
    00342
    00343           }
    00344
    00345         free(pfldsk);
    00346
    00347       };
    00348
    00349       break;
    00350
    00351     default :
    00352       goto Fail;
    00353     }
    00354
    00355
    00356
    00357   if (memspace)
    00358     if ((ret = H5Sclose(memspace)) < 0)
    00359       goto Fail;
    00360
    00361   if ((ret = H5Sclose(dataspace)) < 0)
    00362     goto Fail;
    00363
    00364   if ((ret = H5Dclose(dataset)) < 0)
    00365     goto Fail;
    00366
    00367  Success:
    00368   va_end(params);
    00369   *fret=0;
    00370   return;
    00371
    00372  Fail:
    00373   va_end(params);
    00374   *fret = -1;
    00375   return;
    00376 }