MED fichier
test11.c
Aller à la documentation de ce fichier.
1 /* This file is part of MED.
2  *
3  * COPYRIGHT (C) 1999 - 2016 EDF R&D, CEA/DEN
4  * MED is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * MED is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public License
15  * along with MED. If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 /******************************************************************************
19  * - Nom du fichier : test11.c
20  *
21  * - Description : lecture de champs de resultats MED
22  *
23  *****************************************************************************/
24 
25 #include <med.h>
26 #define MESGERR 1
27 #include "med_utils.h"
28 #include <string.h>
29 
30 #ifdef DEF_LECT_ECR
31 #define MODE_ACCES MED_ACC_RDWR
32 #elif DEF_LECT_AJOUT
33 #define MODE_ACCES MED_ACC_RDEXT
34 #else
35 #define MODE_ACCES MED_ACC_CREAT
36 #endif
37 
38 #ifndef USER_INTERLACE
39 #define USER_INTERLACE MED_FULL_INTERLACE
40 #endif
41 
42 #define USER_MODE MED_COMPACT_STMODE
43 
44 med_err getFieldsOn(med_idt fid, char * nomcha, med_field_type typcha, med_int ncomp,
45  med_entity_type entite, med_switch_mode stockage, med_int ncstp);
46 
47 int main (int argc, char **argv)
48 
49 
50 {
51  med_err ret,lret;
52  med_idt fid;
53  char * fichier = NULL;
54  char maa[MED_NAME_SIZE+1]="";
55  char desc[MED_COMMENT_SIZE+1]="";
56  char pflname[MED_NAME_SIZE+1]="",nomlien[MED_NAME_SIZE+1]="";
57  char _meshname [MED_NAME_SIZE+1]="";
58  char _dtunit [MED_SNAME_SIZE+1]="";
59  char locname[MED_NAME_SIZE+1]="";
60  char * lien = NULL;
61  char *comp= NULL, *unit= NULL;
62  char nomcha [MED_NAME_SIZE+1]="";
63  med_int mdim=0,sdim=0,ncomp,ncha,npro,nln,pflsize,*pflval,nval;
64  med_int _ncstp=0,ngauss=0,nloc=0,locsdim=0,lnsize=0;
65  int t1,t2,t3;
66  med_field_type typcha;
67  med_geometry_type type_geo;
68  med_float *refcoo, *gscoo, *wg;
69  int i,j;
70  med_bool _local;
71 
72  char dtunit[MED_SNAME_SIZE+1]="";
73  char nomcoo[3*MED_SNAME_SIZE+1]="";
74  char unicoo[3*MED_SNAME_SIZE+1]="";
75  char geointerpname[MED_NAME_SIZE+1]="";
76  char ipointstructmeshname[MED_NAME_SIZE+1]="";
77  med_mesh_type type;
78  med_sorting_type sort;
79  med_int nstep=0;
80  med_axis_type rep;
81  med_int nsectionmeshcell;
82  med_geometry_type sectiongeotype;
83 
84  if (argc != 2) {
85  MESSAGE("Aucun nom de fichier precise, fichier test10.med utilise ");
86  fichier = "test10.med";
87  } else {
88  fichier = argv[1];
89  };
90 
91 
92  /* Ouverture du fichier med */
93  if ((fid = MEDfileOpen(fichier,MED_ACC_RDONLY)) < 0){
94  MESSAGE("Erreur a l'ouverture du fichier : ");SSCRUTE(fichier);
95  return -1;
96  }
97 
98  ret = 0;
99 
100 
101  /* Lecture des infos concernant le premier maillage */
102  if ( MEDmeshInfo( fid, 1, maa, &sdim, &mdim, &type, desc, dtunit, &sort,
103  &nstep, &rep, nomcoo,unicoo) < 0 ) {
104  MESSAGE("Erreur a la lecture des informations sur le maillage : ");SSCRUTE(maa);
105  return -1;
106  } else {
107  printf("Maillage de nom : |%s| , de dimension : "IFORMAT" , et de type %d\n",maa,mdim,type);
108  printf("\t -Dimension de l'espace : "IFORMAT"\n",sdim);
109  printf("\t -Description du maillage : %s\n",desc);
110  printf("\t -Noms des axes : |%s|\n",nomcoo);
111  printf("\t -Unités des axes : |%s|\n",unicoo);
112  printf("\t -Type de repère : %d\n",rep);
113  printf("\t -Nombre d'étapes de calcul : "IFORMAT"\n",nstep);
114  printf("\t -Unité des dates : |%s|\n",dtunit);
115  }
116 
117 
118  /* combien de champs dans le fichier */
119  if ((ncha = MEDnField(fid)) < 0) {
120  MESSAGE("Impossible de lire le nombre de champs : ");ISCRUTE(ncha);
121  return ncha;
122  }
123 
124  printf("Nombre de champs : "IFORMAT" \n",ncha);
125 
126  /* lecture de tous les champs */
127  for (i =0;i<ncha;i++) {
128  lret = 0;
129  printf("\nChamp numero : %d \n",i+1);
130 
131  /* Lecture du nombre de composantes */
132  if ((ncomp = MEDfieldnComponent(fid,i+1)) < 0) {
133  MESSAGE("Erreur a la lecture du nombre de composantes : "); ISCRUTE(ncomp);
134  ret = -1; continue;
135  }
136 
137  /* Lecture du type du champ, des noms des composantes et du nom de l'unite*/
138  comp = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
139  EXIT_IF(comp == NULL,NULL,NULL);
140  unit = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
141  EXIT_IF(unit == NULL,NULL,NULL);
142 
143  if ( MEDfieldInfo(fid,i+1,nomcha,_meshname,&_local,&typcha,comp,unit,_dtunit,&_ncstp) < 0 ) {
144  MESSAGE("Erreur a la demande d'information sur les champs : ");
145  ISCRUTE_int(i+1);SSCRUTE(nomcha);ISCRUTE_int(typcha);SSCRUTE(comp);SSCRUTE(unit);
146  ISCRUTE(ncomp);
147  ret = -1; continue;
148  }
149 
150 
151  printf("Nom du champ : |%s| de type %d\n",nomcha,typcha);
152  printf("Nombre de composantes : |"IFORMAT"|\n",ncomp);
153  printf("Nom des composantes : |%s|\n",comp);
154  printf("Unites des composantes : |%s| \n",unit);
155  printf("Unites des dates : |%s| \n",_dtunit);
156  printf("Le maillage associé est |%s|\n",_meshname);
157  printf("Nombre de séquences de calcul |"IFORMAT"|\n",_ncstp);
158 
159  /* Le maillage reference est-il porte par un autre fichier */
160  if ( !_local ) {
161 
162  if ( (lnsize=MEDlinkInfoByName(fid,_meshname) ) < 0 ) {
163  MESSAGE("Erreur a la lecture de la taille du lien : ");
164  SSCRUTE(_meshname);
165  ret = -1;
166  } else {
167 
168  lien = malloc((lnsize+1)*sizeof(char));
169  EXIT_IF(lien == NULL,NULL,NULL);
170 
171  if ( MEDlinkRd(fid,_meshname, lien) < 0 ) {
172  MESSAGE("Erreur a la lecture du lien : ");
173  SSCRUTE(_meshname);SSCRUTE(lien);
174  ret = -1;
175  } else {
176  printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",_meshname,lien);
177  }
178  free(lien);
179  }
180  }
181 
182  free(comp);
183  free(unit);
184 
185 
186  lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NODE, USER_INTERLACE,_ncstp );
187 
188  if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_CELL, USER_INTERLACE,_ncstp );
189  else { MESSAGE("Erreur a la lecture des champs aux noeuds "); ret = -1; continue;}
190 
191  if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_DESCENDING_FACE,USER_INTERLACE,_ncstp);
192  else { MESSAGE("Erreur a la lecture des champs aux mailles "); ret = -1; continue;}
193 
194  if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_DESCENDING_EDGE,USER_INTERLACE,_ncstp);
195  else {MESSAGE("Erreur a la lecture des champs aux faces "); ret = -1; continue;}
196 
197  if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NODE_ELEMENT,USER_INTERLACE,_ncstp);
198  else {MESSAGE("Erreur a la lecture des champs aux aretes"); ret = -1; continue;}
199 
200  /*TODO */
201 /* if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_STRUCT_ELEMENT,USER_INTERLACE,_ncstp); */
202 /* else {MESSAGE("Erreur a la lecture des champs aux éléments de structure"); ret = -1; continue;} */
203 
204  if (lret != 0) {MESSAGE("Erreur a la lecture des champs aux noeuds des mailles "); ret = -1;};
205  }
206 
207 
208  /* Interrogation des profils */
209  npro = MEDnProfile(fid);
210 
211  printf("\nNombre de profils stockes : "IFORMAT"\n\n",npro);
212  for (i=1 ; i <= npro ; i++ ) {
213  if ( MEDprofileInfo(fid, i, pflname, &nval) < 0) {
214  MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE_int(i);
215  ret = -1;continue;
216  }
217  printf("\t- Profil n°%i de nom |%s| et de taille "IFORMAT"\n",i,pflname,nval);
218  pflval = (med_int*) malloc(sizeof(med_int)*nval);
219  if ( MEDprofileRd(fid, pflname, pflval) < 0) {
220  MESSAGE("Erreur a la lecture des valeurs du profil : ");
221  SSCRUTE(pflname);
222  ret = -1;
223  } else {
224  printf("\t");
225  for (j=0;j<nval;j++) printf(" "IFORMAT" ",*(pflval+j));
226  printf("\n\n");
227  }
228  free(pflval);
229  }
230 
231  /* Interrogation des liens */
232  nln = MEDnLink(fid);
233 
234  printf("\nNombre de liens stockes : "IFORMAT"\n\n",nln);
235  for (i=1 ; i <= nln ; i++ ) {
236  if ( MEDlinkInfo(fid, i, nomlien, &nval) < 0) {
237  MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE_int(i);
238  ret = -1;continue;
239  }
240  printf("\t- Lien n°%i de nom |%s| et de taille "IFORMAT"\n",i,nomlien,nval);
241 
242  lien = malloc((nval+1)*sizeof(char));
243  EXIT_IF(lien == NULL,NULL,NULL);
244 
245  if ( MEDlinkRd(fid, nomlien, lien ) < 0 ) {
246  MESSAGE("Erreur a la lecture du lien : ");
247  SSCRUTE(nomlien);SSCRUTE(lien);
248  ret = -1;
249  } else {
250  lien[nval] = '\0';
251  printf("\t\t|%s|\n\n",lien);
252  }
253  free(lien);
254  }
255 
256  /* Interrogation des localisations des points de GAUSS */
257  nloc = MEDnLocalization(fid);
258 
259  printf("\nNombre de localisations stockees : "IFORMAT"\n\n",nloc);
260  for (i=1 ; i <= nloc ; i++ ) {
261  if ( MEDlocalizationInfo(fid, i, locname, &type_geo, &locsdim,&ngauss,
262  geointerpname, ipointstructmeshname,&nsectionmeshcell,
263  &sectiongeotype) < 0) {
264  MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE_int(i);
265  ret = -1;continue;
266  }
267  printf("\t- Loc. n°%i de nom |%s| de dimension |"IFORMAT"| avec "IFORMAT" pts de GAUSS \n",i,locname,locsdim,ngauss);
268  t1 = (type_geo%100)*(type_geo/100);
269  t2 = ngauss*(type_geo/100);
270  t3 = ngauss;
271  refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
272  gscoo = (med_float *) malloc(sizeof(med_float)*t2 );
273  wg = (med_float *) malloc(sizeof(med_float)*t3 );
274 
275  if ( MEDlocalizationRd(fid, locname, USER_INTERLACE, refcoo, gscoo, wg ) < 0) {
276  MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
277  SSCRUTE(locname);
278  ret = -1;
279  } else {
280  printf("\t Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
281  for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
282  printf("\n");
283  printf("\t Localisation des points de GAUSS : \n\t\t");
284  for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
285  printf("\n");
286  printf("\t Poids associes aux points de GAUSS :\n\t\t");
287  for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
288  printf("\n\n");
289  }
290  free(refcoo);
291  free(gscoo);
292  free(wg);
293  }
294 
295 
296  /* fermeture du fichier */
297  if ( MEDfileClose(fid) < 0) return -1;
298 
299  return ret;
300 }
301 
302 med_err getFieldsOn(med_idt fid, char * nomcha, med_field_type typcha, med_int ncomp,
303  med_entity_type entite, med_switch_mode stockage, med_int ncstp) {
304 
305  int j,k,l,m,n,nb_geo=0;
306  med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,*vale=NULL,nval;
307  med_int numdt=0,numo=0,_nprofile;
308  med_float *valr=NULL,dt=0.0;
309  med_err ret=0;
310  char pflname [MED_NAME_SIZE+1]="";
311  char locname [MED_NAME_SIZE+1]="";
312  char * lien = NULL;
313  char dt_unit [MED_SNAME_SIZE+1]="unknown";
314 
315 
316  med_geometry_type * type_geo;
317 
318  const char * const * AFF;
319  const char * const * AFF_ENT=MED_GET_ENTITY_TYPENAME+1;
320  switch (entite) {
321  case MED_NODE :
322  type_geo = MED_GET_NODE_GEOMETRY_TYPE;
323  nb_geo = MED_N_NODE_FIXED_GEO;
325  break;
326  case MED_CELL :
327  case MED_NODE_ELEMENT :
328  type_geo = MED_GET_CELL_GEOMETRY_TYPE;
329  nb_geo = MED_N_CELL_FIXED_GEO;
331  break;
332  case MED_DESCENDING_FACE :
333  type_geo = MED_GET_FACE_GEOMETRY_TYPE;
334  nb_geo = MED_N_FACE_FIXED_GEO;
336  break;
337  case MED_DESCENDING_EDGE :
338  type_geo = MED_GET_EDGE_GEOMETRY_TYPE;
339  nb_geo = MED_N_EDGE_FIXED_GEO;
341  break;
342  }
343 
344  for (k=1;k<=nb_geo;k++) {
345 
346  /* Combien de (PDT,NOR) a lire */
347  nbpdtnor = ncstp;
348  if (nbpdtnor < 1 ) continue;
349 
350  for (j=0;j<nbpdtnor;j++) {
351 
352  if ( MEDfieldComputingStepInfo(fid,nomcha,j+1, &numdt, &numo, &dt ) <0) {
353  MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
354  ISCRUTE(numdt); ISCRUTE(numo);
355  ret = -1; continue;
356  }
357 
358  if ( (_nprofile = MEDfieldnProfile(fid,nomcha,numdt,numo,entite,type_geo[k],
359  pflname,locname ) ) < 0 ) {
360  MESSAGE("Erreur a la demande du nombre de profils referencés par le champ : ");
361  SSCRUTE(nomcha);
362  ISCRUTE(numdt); ISCRUTE(numo);
363  ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
364  SSCRUTE(AFF_ENT[(int)entite]);SSCRUTE(AFF[k]);
365  ret = -1; continue;
366  };
367 
368  for (l=0;l<_nprofile;l++) {
369 
370 
371  if ( (nval = MEDfieldnValueWithProfile(fid, nomcha, numdt, numo, entite, type_geo[k],
372  l+1, USER_MODE, pflname,&pflsize,
373  locname, &ngauss) ) < 0 ) {
374  MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
375  SSCRUTE(nomcha);ISCRUTE(numdt);ISCRUTE(numo);
376  ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
378  ret = -1; continue;
379  };
380 
381  printf("\n +Pas de Temps n."IFORMAT" (%f) [%s], n. d'ordre "IFORMAT", avec "IFORMAT" valeur(s) par entité.\n",numdt,dt,dt_unit,numo,ngauss);
382  printf("\t- Il y a "IFORMAT" entités qui portent des valeurs en mode %i. Chaque entite %s\
383  de type geometrique %s associes au profile |%s| a "IFORMAT" valeurs associées \n",
384  nval,USER_MODE,AFF_ENT[(int)entite],AFF[k],pflname,ngauss);
385 
386  /*Lecture des valeurs du champ */
387  if (typcha == MED_FLOAT64) {
388 
389 
390  valr = (med_float*) calloc(ncomp*nval*ngauss,sizeof(med_float));
391  EXIT_IF(valr == NULL,NULL,NULL);
392 
393  if (MEDfieldValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],
394  USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
395  (unsigned char*) valr) < 0 ) {
396  MESSAGE("Erreur a la lecture des valeurs du champ : ");
397  SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
398  ISCRUTE(numdt);ISCRUTE(numo);
399  ret = -1;
400  }
401 
402  } else {
403 
404  vale = (med_int*) calloc(ncomp*nval*ngauss,sizeof(med_int));
405  EXIT_IF(vale == NULL,NULL,NULL);
406 
407  if (MEDfieldValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],
408  USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
409  (unsigned char*) vale) < 0 ) {
410  MESSAGE("Erreur a la lecture des valeurs du champ : ");
411  SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
412  ISCRUTE(numdt);ISCRUTE(numo);
413  ret = -1;
414  };
415 
416 
417  }
418 
419  if ( strlen(locname) )
420  printf("\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
421 
422  if (entite == MED_NODE_ELEMENT)
423  ngroup = (type_geo[k] % 100);
424  else
425  ngroup = ngauss;
426 
427  switch (stockage) {
428 
429  case MED_FULL_INTERLACE :
430  printf("\t- Valeurs :\n\t");
431  for (m=0;m<(nval*ngauss)/ngroup;m++) {
432  printf("|");
433  for (n=0;n<ngroup*ncomp;n++)
434  if (typcha == MED_FLOAT64)
435  printf(" %f ",*(valr+(m*ngroup*ncomp)+n));
436  else
437  printf(" "IFORMAT" ",*(vale+(m*ngroup*ncomp)+n));
438 
439  }
440  break;
441 
442  /*Affichage en fonction du profil à traiter*/
443  case MED_NO_INTERLACE :
444  printf("\t- Valeurs :\n\t");
445  for (m=0;m<ncomp;m++) {
446  printf("|");
447  for (n=0;n<(nval*ngauss);n++)
448  if (typcha == MED_FLOAT64)
449  printf(" %f ",*(valr+(m*nval)+n));
450  else
451  printf(" "IFORMAT" ",*(vale+(m*nval)+n));
452  }
453  break;
454  }
455 
456  printf("|\n");
457  if (typcha == MED_FLOAT64) {
458  if ( valr ) {free(valr);valr = NULL;}}
459  else
460  if (vale) { free(vale);vale = NULL; }
461 
462  /*Lecture du profil associe */
463  if (strcmp(pflname,MED_NO_PROFILE) == 0 )
464  printf("\t- Profil : MED_NO_PROFILE\n");
465  else {
466 
467  if ( (pflsize = MEDprofileSizeByName(fid,pflname)) <0 ) {
468  MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
469  SSCRUTE(pflname);
470  ret = -1; continue;
471  }
472 
473  printf("\t- Profil : |%s| de taille "IFORMAT"\n",pflname,pflsize);
474 
475  pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
476  EXIT_IF(pflval == NULL,NULL,NULL);
477  if ( MEDprofileRd(fid,pflname,pflval) <0) {
478  MESSAGE("Erreur a la lecture des valeurs du profil : ");
479  SSCRUTE(pflname);
480  ret = -1;
481  }
482  printf("\t");
483  for (m=0;m<pflsize;m++) printf(" "IFORMAT" ",*(pflval+m));
484  printf("\n");
485  free(pflval);
486 
487  }
488 
489  }
490  }
491  } /* fin for sur les mailles*/
492 
493  return ret;
494 }
495 
Definition: med.h:136
MEDC_EXPORT med_int MEDlinkInfoByName(const med_idt fid, const char *const meshname)
Cette routine permet de lire les informations sur un lien dans un fichier MED.
med_err getFieldsOn(med_idt fid, char *nomcha, med_field_type typcha, med_int ncomp, med_entity_type entite, med_switch_mode stockage, med_int ncstp)
Definition: test11.c:302
herr_t med_err
Definition: med.h:310
MEDC_EXPORT med_err MEDlinkRd(const med_idt fid, const char *const meshname, char *const link)
Cette routine permet de lire un lien dans un fichier MED.
Definition: MEDlinkRd.c:37
const char *const MED_GET_ENTITY_TYPENAME[MED_N_ENTITY_TYPES+2]
Definition: MEDiterators.c:33
#define MED_N_FACE_FIXED_GEO
Definition: med.h:223
MEDC_EXPORT med_int MEDnProfile(const med_idt fid)
Cette routine permet de lire le nombre de profil dans un fichier MED.
Definition: MEDnProfile.c:37
MEDC_EXPORT med_int MEDnLocalization(const med_idt fid)
Cette routine permet de lire le nombre de localisations de points d'intégration contenues dans un fic...
#define MESSAGE(chaine)
Definition: med_utils.h:316
#define MED_N_CELL_FIXED_GEO
Definition: med.h:219
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
Definition: MEDfileOpen.c:41
med_switch_mode
Definition: med.h:89
#define USER_MODE
Definition: test11.c:42
double med_float
Definition: med.h:314
#define ISCRUTE_int(entier)
Definition: med_utils.h:307
med_mesh_type
Definition: med.h:124
const char * MED_GET_NODE_GEOMETRY_TYPENAME[MED_N_NODE_FIXED_GEO+2]
Definition: MEDiterators.c:149
#define IFORMAT
Definition: med_utils.h:144
med_geometry_type MED_GET_FACE_GEOMETRY_TYPE[MED_N_FACE_FIXED_GEO+2]
Definition: MEDiterators.c:101
#define MED_ALL_CONSTITUENT
Definition: med.h:279
MEDC_EXPORT med_err MEDprofileInfo(const med_idt fid, const int profileit, char *const profilename, med_int *const profilesize)
Cette routine permet de lire les informations sur un profil dans un fichier MED.
MEDC_EXPORT med_err MEDfieldInfo(const med_idt fid, const int ind, char *const fieldname, char *const meshname, med_bool *const localmesh, med_field_type *const fieldtype, char *const componentname, char *const componentunit, char *const dtunit, med_int *const ncstp)
Cette fonction permet de lire les informations concernant le champ d'indice ind . ...
Definition: MEDfieldInfo.c:42
med_geometry_type MED_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
Definition: MEDiterators.c:44
MEDC_EXPORT med_int MEDnLink(const med_idt fid)
Cette routine permet la lecture du nombre de lien dans un fichier MED.
Definition: MEDnLink.c:34
MEDC_EXPORT med_err MEDprofileRd(const med_idt fid, const char *const profilename, med_int *const profilearray)
Cette routine permet de lire un profil dans un fichier MED.
Definition: MEDprofileRd.c:39
MEDC_EXPORT med_err MEDlinkInfo(const med_idt fid, const int linkit, char *const meshname, med_int *const linksize)
Cette routine permet de lire les informations sur un lien dans un fichier MED.
Definition: MEDlinkInfo.c:38
const char *const MED_GET_FACE_GEOMETRY_TYPENAME[MED_N_FACE_FIXED_GEO+2]
Definition: MEDiterators.c:114
med_sorting_type
Definition: med.h:289
MEDC_EXPORT med_int MEDfieldnProfile(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type enttype, const med_geometry_type geotype, char *const defaultprofilename, char *const defaultlocalizationname)
Cette fonction permet de lire le nombre de profils référencés dans un champ pour une séquence de calc...
med_entity_type
Definition: med.h:136
#define MED_N_EDGE_FIXED_GEO
Definition: med.h:227
med_geometry_type MED_GET_NODE_GEOMETRY_TYPE[MED_N_NODE_FIXED_GEO+2]
Definition: MEDiterators.c:143
MEDC_EXPORT med_err MEDmeshInfo(const med_idt fid, const int meshit, char *const meshname, med_int *const spacedim, med_int *const meshdim, med_mesh_type *const meshtype, char *const description, char *const dtunit, med_sorting_type *const sortingtype, med_int *const nstep, med_axis_type *const axistype, char *const axisname, char *const axisunit)
Cette routine permet de lire les informations relatives à un maillage dans un fichier.
Definition: MEDmeshInfo.c:43
MEDC_EXPORT med_int MEDfieldnComponent(const med_idt fid, const int ind)
Cette fonction lit le nombre de composantes d'un champ.
int med_int
Definition: med.h:316
med_axis_type
Definition: med.h:238
Definition: med.h:136
MEDC_EXPORT med_int MEDfieldnValueWithProfile(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const int profileit, const med_storage_mode storagemode, char *const profilename, med_int *const profilesize, char *const localizationname, med_int *const nintegrationpoint)
Cette fonction permet de lire le nombre de valeurs à lire dans un champ pour une séquence de calcul...
MEDC_EXPORT med_int MEDnField(const med_idt fid)
Cette fonction permet de lire le nombre de champs dans un fichier.
Definition: MEDnField.c:35
med_field_type
Definition: med.h:155
MEDC_EXPORT med_int MEDprofileSizeByName(const med_idt fid, const char *const profilename)
Cette routine permet de lire la taille d'un profil dont on connait le nom.
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
Definition: MEDfileClose.c:30
#define EXIT_IF(expression, message, arg)
Definition: med_utils.h:335
#define MED_NO_PROFILE
Definition: med.h:261
#define MED_COMMENT_SIZE
Definition: med.h:72
#define ISCRUTE(entier)
Definition: med_utils.h:306
MEDC_EXPORT med_err MEDlocalizationRd(const med_idt fid, const char *const localizationname, const med_switch_mode switchmode, med_float *const elementcoordinate, med_float *const ipointcoordinate, med_float *const weight)
Cette routine permet la lecture d'une localisation localizationname de points d'intégration dans/auto...
#define MED_N_NODE_FIXED_GEO
Definition: med.h:231
MEDC_EXPORT med_err MEDfieldComputingStepInfo(const med_idt fid, const char *const fieldname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt)
Cette fonction permet de lire les informations caractérisant une séquence de calcul : numéro de pas d...
hid_t med_idt
Definition: med.h:309
#define MED_SNAME_SIZE
Definition: med.h:75
#define MED_NAME_SIZE
Definition: med.h:74
MEDC_EXPORT med_err MEDlocalizationInfo(const med_idt fid, const int localizationit, char *const localizationname, med_geometry_type *const geotype, med_int *const spacedimension, med_int *const nipoint, char *const geointerpname, char *const sectionmeshname, med_int *const nsectionmeshcell, med_geometry_type *const sectiongeotype)
Cette routine permet d'obtenir la description de la localisation de points d'intégration n° localizat...
int main(int argc, char **argv)
Definition: test11.c:47
#define USER_INTERLACE
Definition: test11.c:39
med_bool
Definition: med.h:240
const char * MED_GET_EDGE_GEOMETRY_TYPENAME[MED_N_EDGE_FIXED_GEO+2]
Definition: MEDiterators.c:135
med_geometry_type MED_GET_EDGE_GEOMETRY_TYPE[MED_N_EDGE_FIXED_GEO+2]
Definition: MEDiterators.c:127
MEDC_EXPORT med_err MEDfieldValueWithProfileRd(const med_idt fid, const char *const fieldname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_storage_mode storagemode, const char *const profilename, const med_switch_mode switchmode, const med_int componentselect, unsigned char *const value)
Cette fonction permet de lire les valeurs d'un champ définies sur des entités d'un maillage pour une ...
int med_geometry_type
Definition: med.h:179
const char *const MED_GET_CELL_GEOMETRY_TYPENAME[MED_N_CELL_FIXED_GEO+2]
Definition: MEDiterators.c:72
#define SSCRUTE(chaine)
Definition: med_utils.h:315