MEDdatasetNumLire232.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 : _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 }

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