MAJ_21_22_champs.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 #ifndef MESGERR
00020 #define MESGERR 1
00021 #endif
00022 
00023 #include "med_config.h"
00024 #include "med_outils.h"
00025 #include <string.h>
00026 
00027 /* #ifdef __cplusplus */
00028 /* } */
00029 /* #endif */
00030 
00031 #include "med_utils.h"
00032 
00033 #include "med_hdfi21.h"
00034 #include "med_hdfi231.h"
00035 #include "med21.h"
00036 
00037 #include "MAJ_21_22.h"
00038 
00039 void MAJ_21_22_champs(med_idt fid)
00040 {
00041   med_idt gid,eid,pid,mid,did,aid;
00042   med_err ret;
00043   int n,i,j,k;
00044   char nom[MED_TAILLE_NOM+1];
00045   char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
00046   char maillage[MED_TAILLE_NOM+1];
00047   med_int type;
00048   char *comp, *unit;
00049   char *nouvelle_chaine;
00050   med_int ncomp;
00051   int nent, npdt;
00052   char noment[MED_TAILLE_NOM+1];
00053   char nompdt[2*MED_MAX_PARA+1];
00054   char oldunidt[ANCIEN_MED_TAILLE_PNOM+1];
00055   char unitdt[MED_TAILLE_PNOM+1];
00056   char tmp[MED_TAILLE_DESC+1];
00057   med_int att;
00058   char profil[MED_TAILLE_NOM+1];
00059   char gauss[MED_TAILLE_NOM+1];
00060   char modele[3];
00061   med_float *valr;
00062   med_int nval;
00063   hid_t hdf_type;
00064   med_size dimd[1];
00065   med_float pdt;
00066   
00067 
00068   /* Lecture du nombre de champs */
00069   n = 0;
00070   _MEDnObjets(fid,(char *)(MED_CHA),&n);
00071   EXIT_IF(n < 0,"Erreur a la lecture du nombre de champ",NULL);
00072 
00073   for (i=0;i<n;i++) {
00074     /* on recupere le nom du champ */
00075     ret = _MEDobjetIdentifier(fid,(char *) MED_CHA,i,nom);
00076     EXIT_IF(ret < 0,"Identification d'un champ",NULL);
00077     fprintf(stdout,"  >>> Normalisation du champ [%s] \n",nom);
00078 
00079     /* on accede au champ */
00080     strcpy(chemin,(char *)(MED_CHA));
00081     strcat(chemin,nom);
00082     gid = _MEDdatagroupOuvrir(fid,chemin); 
00083     EXIT_IF(gid < 0,"Accès au champ",nom);
00084 
00085     /* Lecture du nombre de composantes */ 
00086     ret = _MEDattrEntierLire(gid,(char *)(MED_NOM_NCO),&ncomp);
00087     EXIT_IF(ret < 0,"Lecture du nombre de composante",NULL);
00088 
00089     /* Lecture du type du champ */
00090     ret = _MEDattrEntierLire(gid,(char *)(MED_NOM_TYP),&type);
00091     EXIT_IF(ret < 0,"Lecture du type du champ",NULL);
00092 
00093     /* Normalisation des nom et unites des composantes */
00094     comp = (char *) malloc(ncomp*ANCIEN_MED_TAILLE_PNOM+1);
00095     EXIT_IF(comp == NULL,NULL,NULL);
00096     unit = (char *) malloc(ncomp*ANCIEN_MED_TAILLE_PNOM+1);
00097     EXIT_IF(unit == NULL,NULL,NULL);
00098     nouvelle_chaine = (char *) malloc(ncomp*MED_TAILLE_PNOM+1);
00099     EXIT_IF(nouvelle_chaine == NULL,NULL,NULL);
00100 
00101     ret = _MEDattrStringLire(gid,(char *)(MED_NOM_NOM),ncomp*ANCIEN_MED_TAILLE_PNOM,comp);
00102     EXIT_IF(ret < 0,"Lecture des noms des composantes du champ",NULL);
00103     _MED23v30stringConvert(nouvelle_chaine, MED_TAILLE_PNOM,
00104                            comp, ANCIEN_MED_TAILLE_PNOM, ncomp );
00105 /*     MAJ_21_22_chaine(comp,nouvelle_chaine,ncomp); */
00106     H5Adelete(gid,(char *)(MED_NOM_NOM));
00107     ret = _MEDattrStringEcrire(gid,(char *)(MED_NOM_NOM),MED_TAILLE_PNOM*ncomp,nouvelle_chaine);
00108     EXIT_IF(ret < 0,"Ecriture des nouveaux noms des composantes du champ",NULL);  
00109     free(comp);
00110 
00111     ret = _MEDattrStringLire(gid,(char *)(MED_NOM_UNI),ncomp*ANCIEN_MED_TAILLE_PNOM,unit);
00112     EXIT_IF(ret < 0,"Lecture des unités des composantes du champ",NULL);
00113     _MED23v30stringConvert(nouvelle_chaine, MED_TAILLE_PNOM,
00114                            unit, ANCIEN_MED_TAILLE_PNOM, ncomp );
00115 /*     MAJ_21_22_chaine(unit,nouvelle_chaine,ncomp); */
00116     H5Adelete(gid,(char *)(MED_NOM_UNI));
00117     ret = _MEDattrStringEcrire(gid,(char *)(MED_NOM_UNI),MED_TAILLE_PNOM*ncomp,nouvelle_chaine);
00118     EXIT_IF(ret < 0,"Ecriture des nouvelles unités des composantes du champ",NULL);  
00119     free(unit);
00120 
00121     free(nouvelle_chaine);
00122     fprintf(stdout,"  ... Normalisation des noms et unités des composantes effectuée...\n");
00123 
00124     /* On ajoute le groupe HDF correspondant au maillage */
00125     /* On recupere le nom du maillage par defaut */
00126     nent = 0;
00127     _MEDnObjets(gid,(char *)("./"),&nent);
00128     EXIT_IF(nent < 0,"Erreur a la lecture du nombre d'entité dans un champ",NULL);
00129     for (j=0;j<nent;j++) {
00130       /* on recupere le nom du groupe HDF correspondant a l'entite */ 
00131       ret = _MEDobjetIdentifier(gid,(char *)("./"),j,noment);
00132       EXIT_IF(ret < 0,"Identification des objets de niveau 1 dans le champ",NULL);
00133 
00134       /* On ouvre le groupe HDF */
00135       eid = _MEDdatagroupOuvrir(gid,noment);
00136       EXIT_IF(eid < 0,"Ouverture du groupe HDF de niveau 1",NULL);
00137 
00138       /* On recupere le nombre de pas de temps */
00139       npdt = 0;
00140       _MEDnObjets(eid,(char *)("./"),&npdt);
00141       EXIT_IF(nent < 0,"Erreur a la lecture du nombre de pas de temps",NULL);
00142       /* On traite chaque pas de temps */
00143       for (k=0;k<npdt;k++) {
00144         /* On recupere le nom du groupe HDF correspondant au pas de temps */ 
00145         ret = _MEDobjetIdentifier(eid,(char *)("./"),k,nompdt);
00146         EXIT_IF(ret < 0,"Identification des objets de niveau 2 dans le champ",NULL);
00147         /* On ouvre le groupe HDF correspondant au pas de temps */
00148         pid = _MEDdatagroupOuvrir(eid,nompdt);
00149         EXIT_IF(pid < 0,"Ouverture du groupe HDF de niveau 2",NULL);
00150 
00151         /* On lit le pas de temps */
00152         aid = H5Aopen_name(pid,(char *)(MED_NOM_PDT));
00153         EXIT_IF(aid < 0,"Ouverture de l'attribut HDF MED_NOM_PDT",NULL);
00154         hdf_type = H5Aget_type(aid);
00155         EXIT_IF(hdf_type < 0,"Lecture du type de l'attribut HDF MED_NOM_PDT",NULL);
00156         ret = H5Aclose(aid);
00157         EXIT_IF(ret < 0,"Fermeture de l'attribut MED_NOM_PDT",NULL);
00158         ret = _MED21attrNumLire(pid,MED_FLOAT64,(char *)(MED_NOM_PDT),(unsigned char*)(&pdt),hdf_type);
00159         EXIT_IF(ret < 0,"Lecture du pas de temps dans MED_NOM_PDT",NULL);
00160         dimd[0] = 1;
00161         /*      printf("EGALITE des types : %d \n",H5Tequal(hdf_type,H5T_NATIVE_DOUBLE)); */
00162         /*      printf("Avant conversion : [%f]\n",pdt); */
00163         if (! H5Tequal(hdf_type,H5T_NATIVE_DOUBLE)) {
00164           ret = H5Tconvert(hdf_type,H5T_NATIVE_DOUBLE,(hsize_t)*dimd,(void *)(&pdt),NULL,0);
00165           /*    printf("Après conversion éventuelle : [%f] \n",pdt); */
00166           EXIT_IF(ret < 0,"Conversion du pas de temps",NULL);
00167         }
00168         H5Tclose(hdf_type);
00169         H5Adelete(pid,(char *)(MED_NOM_PDT));
00170         ret = _MEDattrFloatEcrire(pid,(char *)(MED_NOM_PDT),&pdt);
00171         EXIT_IF(ret < 0,"Ecriture du nouveau pas de temps",NULL);
00172 
00173         /* On met a jour l'unité du pas de temps : 8 -> 16 caractères 
00174            Si on rencontre "        " => on ecrit "" 
00175         */
00176         ret = _MEDattrStringLire(pid,(char *)(MED_NOM_UNI),ANCIEN_MED_TAILLE_PNOM,oldunidt);
00177         EXIT_IF(ret < 0,"Lecture de l'unite du pas de temps",NULL);
00178         if (! strcmp(oldunidt,ANCIEN_MED_BLANC_PNOM))
00179           strcpy(unitdt,"");
00180         else {
00181 /*        MAJ_21_22_chaine(oldunidt,unitdt,1); */
00182           _MED23v30stringConvert(unitdt, MED_TAILLE_PNOM,
00183                                  oldunidt, ANCIEN_MED_TAILLE_PNOM, 1 );
00184 
00185         }
00186         H5Adelete(pid,(char *)(MED_NOM_UNI));
00187         ret = _MEDattrStringEcrire(pid,(char *)(MED_NOM_UNI),MED_TAILLE_PNOM,unitdt);
00188         EXIT_IF(ret < 0,"Ecriture de la nouvelle unité du pas de temps",NULL);  
00189         /* On recupere le nom du maillage */
00190         ret = _MEDattrStringLire(pid,(char *)(MED_NOM_MAI),MED_TAILLE_NOM,maillage);
00191         EXIT_IF(ret < 0,"Lecture du nom du maillage du pas de temps",NULL);
00192         /* On cree le groupe HDF de niveau 3 qui porte le nom du maillage */
00193         mid = _MEDdatagroupCreer(pid,maillage);
00194         EXIT_IF(mid < 0,"Creation du groupe HDF de niveau 3",NULL);
00195         /* Déplacement de l'attribut MED_NOM_NBR */
00196         ret = _MEDattrEntierLire(pid,(char *)(MED_NOM_NBR),&nval);
00197         EXIT_IF(ret < 0,"Lecture de l'attribut MED_NOM_NBR",NULL);
00198         ret = H5Adelete(pid,(char *)(MED_NOM_NBR));
00199         EXIT_IF(ret < 0,"Destruction de l'attribut MED_NOM_NBR",NULL);
00200         ret = _MEDattrEntierEcrire(mid,(char *)(MED_NOM_NBR),&nval);
00201         EXIT_IF(ret < 0,"Ecriture de l'attribut MED_NOM_NBR au niveau 3",NULL);
00202 
00203         /* Deplacement de l'attribut MED_NOM_NGA */
00204         ret = _MEDattrEntierLire(pid,(char *)(MED_NOM_NGA),&att);
00205         EXIT_IF(ret < 0,"Lecture de l'attribut MED_NOM_NGA",NULL);
00206         if ( (att > 100) || (att < 1)) {
00207           MESSAGE("Detection d'un nombre incorrect de nombre de points de gauss, réinitialisation à 1");
00208           att=1;
00209         }
00210         ret = H5Adelete(pid,(char *)(MED_NOM_NGA));
00211         EXIT_IF(ret < 0,"Destruction de l'attribut MED_NOM_NGA",NULL);
00212         ret = _MEDattrEntierEcrire(mid,(char *)(MED_NOM_NGA),&att);
00213         EXIT_IF(ret < 0,"Ecriture de l'attribut MED_NOM_NGA au niveau 3",NULL);
00214 
00215         /* Ecriture de l'attribut MED_NOM_GAU : localisation des points de Gauss */
00216         if (att < 2)
00217           strcpy(gauss,(char *)(MED_NOM_BLANC));
00218         else {
00219           /* on prend en compte que les 3 dernières lettres de noment + nb de points de Gauss : 
00220              Exemple : "MAI.QU4" et 4 points => gauss="QU4_04_LocalisationDefaut_IMPORT */
00221           strcpy(gauss,noment+4);
00222           /* on recupere dans le nom, le nombre de points de Gauss */
00223           /*      sprintf(modele,"%0*d",2,att);*/
00224           sprintf(modele, "%02d"  ,(int) att);
00225           modele[2] = '\0';
00226           strcat(gauss,"_");
00227           strcat(gauss,modele);
00228           strcat(gauss,"_LocalisationDefaut_IMPORT");
00229           /* On ecrit en plus la localisation bidon des points de Gauss */
00230           MAJ_21_22_localisation_Gauss(fid,gauss,att);
00231         }
00232         ret = _MEDattrStringEcrire(mid,(char *)(MED_NOM_GAU),MED_TAILLE_NOM,gauss);
00233         EXIT_IF(ret < 0,"Ecriture de la localisation des points de Gauss",NULL);
00234 
00235         /* Deplacement de l'attribut MED_NOM_PFL */
00236         ret = _MEDattrStringLire(pid,(char *)(MED_NOM_PFL),MED_TAILLE_NOM,profil);
00237         EXIT_IF(ret < 0,"Lecture de l'attribut MED_NOM_PFL",NULL);
00238         ret = H5Adelete(pid,(char *)(MED_NOM_PFL));
00239         EXIT_IF(ret < 0,"Desctruction de l'attribut MED_NOM_PFL",NULL);
00240         ret = _MEDattrStringEcrire(mid,(char *)(MED_NOM_PFL),MED_TAILLE_NOM,profil);
00241         EXIT_IF(ret < 0,"Ecriture de l'attribut MED_NOM_PFL au niveau 3",NULL);
00242 
00243         /* On ferme le groupe HDF de niveau 3 */
00244         ret = _MEDdatagroupFermer(mid);
00245         EXIT_IF(ret < 0,"fermeture du groupe HDF de niveau 3",NULL);
00246 
00247         /* On deplace du niveau 2 -> 3, le dataset MED_NOM_CO 
00248            avec si type==MED_FLOAT_64 une conversion au passage */
00249         strcpy(tmp,maillage);
00250         strcat(tmp,"/");
00251         strcat(tmp,(char *)(MED_NOM_CO));
00252 
00253         if (type != MED_FLOAT64) {
00254           ret = H5Gmove(pid,(char *)(MED_NOM_CO),tmp);
00255           EXIT_IF(ret < 0,"Transfert du dataset MED_NOM_CO",NULL);
00256         } else {
00257           did = _MEDdatasetOuvrir(pid,(char *)(MED_NOM_CO));
00258           EXIT_IF(did < 0,"Ouverture du dataset HDF des valeurs",NULL);
00259           hdf_type = H5Dget_type(did);
00260           EXIT_IF(hdf_type < 0,"Lecture du type HDF de stockage des valeurs",NULL);
00261           ret = _MEDdatasetFermer(did);
00262           EXIT_IF(ret < 0,"Fermeture du dataset HDF des valeurs",NULL);
00263           valr = (med_float *) malloc(sizeof(med_float)*ncomp*nval);
00264           EXIT_IF(valr == NULL,NULL,NULL);
00265           ret = _MED21datasetNumLire(pid,(char *)(MED_NOM_CO),MED_FLOAT64,
00266                                       MED_FULL_INTERLACE,ncomp,MED_ALL,
00267                                       0,NULL,MED_NOPG,
00268                                       (unsigned char*) valr,hdf_type);
00269           EXIT_IF(ret < 0,"Lecture des valeurs du champ",NULL);
00270           H5Gunlink(pid,(char *)(MED_NOM_CO));
00271           dimd[0] = ncomp*nval;
00272           ret = H5Tconvert(hdf_type,H5T_NATIVE_DOUBLE,(hsize_t)*dimd,(void *)valr,NULL,0);
00273           EXIT_IF(ret < 0,"Conversion des valeurs",NULL);
00274           H5Tclose(hdf_type);
00275           /* On reporte les valeurs dans le groupe HDF TMP */
00276           ret = _MED231datasetNumEcrire(pid,tmp,MED_FLOAT64,MED_FULL_INTERLACE,
00277                                         ncomp,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
00278                                         (unsigned char*) valr);
00279           EXIT_IF(ret < 0,"Ecriture des valeurs après conversion",NULL);
00280           free(valr);
00281         }
00282           
00283         /* On ferme le groupe HDF de niveau 2*/
00284         ret = _MEDdatagroupFermer(pid);
00285         EXIT_IF(ret < 0,"Fermeture du groupe HDF de niveau 2",NULL);
00286       }
00287 
00288       /* On ferme le groupe HDF */
00289       ret = _MEDdatagroupFermer(eid);
00290       EXIT_IF(ret < 0,"Fermeture du groupe HDF de niveau 1",NULL);
00291     }
00292     fprintf(stdout,"  ... Normalisation de tous les pas de temps effectuée...\n");
00293 
00294     /* On ferme tout */
00295     ret = _MEDdatagroupFermer(gid);
00296     EXIT_IF(ret < 0,"Fermeture de l'accès au champ",NULL);
00297     
00298     fprintf(stdout,"  >>> Normalisation du champ [%s] : ... OK ... \n",nom);
00299   }
00300 }

Généré le Mon May 16 17:10:23 2011 pour MED fichier par  doxygen 1.6.1