# 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 }