# MAJ_21_22_champs.c

Aller à la documentation de ce fichier.

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