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

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