MEDdatasetNumLire231.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  * - 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 }

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