MED fichier

Concepts et fonctionnalités avancés sur les maillages

Créer et lire dans un maillage des éléments de type polygones quelconques

Créer et lire dans un maillage des éléments de type polyèdres quelconques

Créer et lire un maillage avec gestion des profils sur les entités

Créer et lire un maillage évolutif

Créer et lire une équivalence entre les entités d'un maillage

Créer et lire un maillage avec des éléments de structure

Ecriture et lecture en parallèle par la décomposition de domaine

# Créer et lire dans un maillage des éléments de type polygones quelconques

En plus des types géométriques prédéfinis (exemples : MED_SEG2, MED_SEG3, MED_TRIA3, ...), il est possible de définir dans un maillage non structuré des éléments qui correspondent à des polygones (mailles ou faces) quelconques.

Pour décrire la géométrie et la connectivité des mailles/faces polygones quelconques, il s'agit d'adopter la convention suivante. L'ordre de stockage des polygones est libre -i.e. n'est pas régi par l'ordre des types géométriques (donné par le nombre de sommets). Par exemple, si on a 2 polygones à 5 sommets (P5) et 1 polygone à 6 sommets (P6), on peut stocker la connectivité de ces éléments dans l'ordre suivant : P5, P6, P5. On accède à la connectivité de chaque polygone par l'intermédiaire d'un tableau d'indexation. Pour notre exemple cela revient à avoir les 2 tableaux suivants (les indexations dans MED débutent par convention à l'indice 1) :

En connectivité nodale, les entiers stockés dans le tableau de connectivité correspondent à des numéros de noeuds alors qu'en connectivité descendante, ils correspondent à des numéros d'arêtes.

## Exemple de polygone en connectivité nodale

Voici l'exemple de deux polygones. Les deux polygones sont deux hexagones symétriques. Ils partagent une arête commune la [4,7] qui doit être décrite pour chaque polygone.

Le tableau index des polygones est donc le suivant :

index
P1 | P2
--- | ---
1 | 7 | 13

Le tableau connectivity contient l'ensemble des noeuds utilisés par les arêtes des polygones

connectivity
P1 | P2
--- | ---
1 | 4 | 7 | 9 | 6 | 3 | 2 | 5 | 8 | 10 | 7 | 4

## Exemple d'utilisation de l'API MED pour l'écriture de polygones

L'écriture de la connectivité des polygones d'un maillage s'appuie sur une routine dédiée MEDmeshPolygonWr / mmhpgw qui prend en paramètres les tableaux d'indexation et de connectivité. A noter que le seul mode de stockage possible du tableau de connectivité est le mode non entrelacé.

Une fois le maillage non structuré crée, ici en dimension 2 :

if (MEDmeshCr(fid, meshname, spacedim, meshdim,
MED_UNSTRUCTURED_MESH, "A 2D mesh with 2 polygons",
"", MED_SORT_DTIT, MED_CARTESIAN, axisname, unitname) < 0)

Fichier d'exemple associé

la définition des noeuds s'effectue classiquement :

if (MEDmeshNodeCoordinateWr(fid, meshname, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_FULL_INTERLACE, nnodes, coordinates) < 0)

Fichier d'exemple associé

vient ensuite l'écriture des polygones par les tableaux index et connectivity :

if (MEDmeshPolygonWr(fid, meshname, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_CELL, MED_NODAL, indexsize, index, connectivity) < 0)

Fichier d'exemple associé

## Exemple d'utilisation de l'API MED pour la lecture de polygones

La lecture de la connectivité des polygones d'un maillage s'effectue tout d'abord par deux appels à la fonction MEDmeshnEntity / mmhnme.

Le premier appel concernant les polygones permet de récupérer la taille du tableau d'indexation (le nombre de polygone présent dans le maillage est égal à la taille de ce tableau -1).

if ((indexsize = MEDmeshnEntity(fid,meshname,MED_NO_DT,MED_NO_IT,
MED_CELL,MED_POLYGON,MED_INDEX_NODE,MED_NODAL,
&coordinatechangement, &geotransformation)) < 0)
npoly = indexsize-1;

Fichier d'exemple associé

Le second appel permet de lire la taille du tableau de connectivité pour lui allouer la mémoire necessaire.

if ((connectivitysize = MEDmeshnEntity(fid,meshname,MED_NO_DT,MED_NO_IT,
MED_CELL,MED_POLYGON,MED_CONNECTIVITY,MED_NODAL,
&coordinatechangement, &geotransformation)) < 0)

Fichier d'exemple associé

Enfin la routine MEDmeshPolygonRd / mmhpgr va lire les tableaux d'indexation et de connectivité.

index = (med_int *) malloc(sizeof(med_int)*indexsize);
connectivity = (med_int *) malloc(sizeof(med_int)*connectivitysize);
if (MEDmeshPolygonRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL, MED_NODAL, index, connectivity) < 0)

Fichier d'exemple associé

# Créer et lire dans un maillage des éléments de type polyèdres quelconques

## Polyèdres en connectivité nodale

En plus des types géométriques prédéfinis (exemples : MED_SEG2, MED_SEG3, MED_TRIA3, ...), il est possible de définir dans un maillage non structuré des éléments qui correspondent à des (mailles) polyèdres quelconques.

Pour décrire la géométrie et la connectivité des mailles polyèdres quelconques, il s'agit d'adopter la convention suivante. Pour la connectivité nodale, on accède à la connectivité via un système de double indexation :

- un premier tableau d'indexation faceindex renvoie à la liste des faces de chaque polyèdre
- un second tableau nodeindex renvoie pour chaque face à la liste des noeuds qui la compose

Voici un schéma explicitant l'utilisation des trois tableaux dans la connectivité nodale de n polyèdres :

A noter que les faces communes sont décrites 2 fois (mêmes listes de noeuds mais orientations différentes) et la normale des faces doit être extérieure.

## Exemple de polyèdres en connectivité nodale

Voici l'exemple d'une boîte constituée de 2 polyèdres. Le premier polyèdre (en bas à gauche) est constitué de 6 faces, le second (en haut à droite) de 7.

Le tableau faceindex des polyèdres est donc le suivant :

faceindex
P1 | P2
--- | ---
1 | 7 | 14

Le tableau nodeindex permet de trouver les noeuds de chaque face dans le tableau connectivity

nodeindex
F1.1 | F1.2 | F1.3 | F1.4 | F1.5 | F1.6 | F2.1 | F2.2 | F2.3 | F2.4 | F2.5 | F2.6 | F2.7
--- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | ---
1 | 6 | 12 | 17 | 20 | 23 | 27 | 33 | 36 | 42 | 47 | 53 | 56 | 59

Le tableau connectivity contient l'ensemble des noeuds utilisés par les faces des polyèdres

connectivity
P1.1 | P1.2 | P1.3 | P1.4 | P1.5 | P1.6 | P2.1 | P2.2 | P2.3 | P2.4 | P2.5 | P2.6 | P2.7
--- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | ---
1 | 2 | 9 | 3 | 10 | 1 | 12 | 5 | 6 | 11 | 2 | 2 | 11 | 6 | 3 | 9 | 3 | 6 | 5 | 3 | 5 | 10 | 1 | 10 | 5 | 12 | 3 | 13 | 7 | 8 | 15 | 4 | 3 | 4 | 10 | 4 | 15 | 8 | 16 | 5 | 10 | 3 | 6 | 14 | 7 | 13 | 5 | 16 | 8 | 7 | 14 | 6 | 3 | 10 | 5 | 3 | 5 | 6

## Exemple d'utilisation de l'API MED pour l'écriture de polyèdres en connectivité nodale

L'écriture de la connectivité des polyèdres d'un maillage s'appuie sur une routine dédiée MEDmeshPolyhedronWr / mmhphw qui prend en paramètres les tableaux d'indexation et de connectivité. A noter que le seul mode de stockage possible du tableau de connectivité est le mode non entrelacé.

L'exemple suivant propose l'écriture de la connectivité de mailles polyèdres en connectivité nodale.

Après la création classique d'un maillage non structuré :

if (MEDmeshCr(fid, meshname, spacedim, meshdim,
MED_UNSTRUCTURED_MESH, "A 3D mesh with 2 polyhedron",
"", MED_SORT_DTIT,
MED_CARTESIAN, axisname, unitname) < 0) {

Fichier d'exemple associé

Les noeuds utilisés par les polyèdres sont crées :

if (MEDmeshNodeCoordinateWr(fid, meshname,
MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_FULL_INTERLACE, nnodes, coordinates) < 0) {

Fichier d'exemple associé

Enfin, la connectivité des polyèdres est enregistrée :

if (MEDmeshPolyhedronWr(fid, meshname,
MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_CELL, MED_NODAL,
faceindexSize, faceindex,
nodeindexSize, nodeindex,
connectivity) < 0) {

Fichier d'exemple associé

A noter qu'au même titre que les autres entités d'un maillage, les polyèdres (tout comme les polygones) portent un numéro de famille (0 par défaut) et peuvent porter un nom ou un numéro optionnel.

## Exemple d'utilisation de l'API MED pour la lecture de polyèdres en connectivité nodale

La lecture de la connectivité des polyèdres d'un maillage demande une approche spécifique. Il est d'abord nécessaire d'appeler plusieurs fois la routine MEDmeshnEntity / mmhnme afin de récupérer la taille des tableaux d'indexation.

Après la lecture du nombre total de noeuds présent dans le maillage

if ((nnodes = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_NODE, MED_POINT1,
MED_COORDINATE, MED_NO_CMODE,&coordinatechangement, &geotransformation)) < 0)

Fichier d'exemple associé

nous lisons le nombre de polyèdres ( égal à la taille du tableau MED_INDEX_FACE -1 )

if ((faceindexsize = MEDmeshnEntity(fid,meshname,MED_NO_DT,MED_NO_IT,
MED_CELL,MED_POLYHEDRON,MED_INDEX_FACE,MED_NODAL,
&coordinatechangement, &geotransformation)) < 0)
npoly = faceindexsize-1;

Fichier d'exemple associé

et la taille du tableau d'indexes des noeuds MED_INDEX_NODE

if ((nodeindexsize = MEDmeshnEntity(fid,meshname,MED_NO_DT,MED_NO_IT,
MED_CELL,MED_POLYHEDRON,MED_INDEX_NODE,MED_NODAL,
&coordinatechangement, &geotransformation)) < 0)

Fichier d'exemple associé

nous lisons enfin la taille du tableau connectivity contentant les numéros des noeuds utilisés par les faces des polyèdres

if ((connectivitysize = MEDmeshnEntity(fid,meshname,MED_NO_DT,MED_NO_IT,
MED_CELL,MED_POLYHEDRON,MED_CONNECTIVITY,MED_NODAL,
&coordinatechangement, &geotransformation)) < 0)

Fichier d'exemple associé

La routine MEDmeshPolyhedronRd / mmhphr va permettre de lire les tableaux d'indexation et de connectivité

faceindex = (med_int *) malloc(sizeof(med_int)*faceindexsize);
nodeindex = (med_int *) malloc(sizeof(med_int)*nodeindexsize);
connectivity = (med_int *) malloc(sizeof(med_int)*connectivitysize);
if (MEDmeshPolyhedronRd(fid,meshname,MED_NO_DT,MED_NO_IT,MED_CELL,MED_NODAL,
faceindex,nodeindex,connectivity) < 0)

Fichier d'exemple associé

## Polyèdres en connectivité descendante

Pour la connectivité descendante, un seul niveau d'indexation suffit (faceindex).

- Le tableau connectivity contient les numéros des faces.
- Le tableau nodeindex contient alors le type géométrique de chaque face (exemple : MED_TRIA3).

A noter que dans ce cas, nodeIndexSize == connectivitySize .

Voici un schéma explicitant l'utilisation des trois tableaux dans la connectivité descendante de n polyèdres :

# Créer et lire un maillage avec gestion des profils sur les entités

Un profil sur les entités d'un maillage permet l'écriture ou la lecture sur un sous-ensemble de ces entités. Un profil est un objet stocké dans un fichier MED. Un profil est un tableau de numéros d'entités (numérotation MED relative à un type géométrique d'élément commençant à 1) associés aux valeurs à traiter. La définition d'un profil se fait selon les conventions suivantes : les numéros d'entité utilisés pour définir un profil sont ceux de la numérotation implicite (ordre d'apparition des entités par ordre croissant). Un profil est une liste compacte : on ne met que les numéros représentatifs. Exemple : sur un maillage de 30 noeuds, si on a un champ portant sur les noeuds de numéros de référence 4, 5 et 12, le profil correspondant sera la liste (4,5,12).

La routine MEDprofileWr / mpfprw permet d'écrire un profil dans un fichier MED. Un profil est identifié par son nom (chaîne de taille MED_NAME_SIZE caractères).

A la lecture, la routine MEDnProfile / mpfnpf va lire le nombre de profil dans un fichier. Il s'agit ensuite d'itérer sur chaque profil afin de récupérer pour chacun d'eux : le nom et la taille du tableau du profil avec la routine MEDprofileInfo / mpfpfi, le tableau des numéros d'entités avec MEDprofileRd / mpfprr.

Lorsqu'on connaît le nom du profil, la routine permet MEDprofileSizeByName / mpfpsn de lire la taille du tableau.

Au niveau de l'API sur les maillages, l'utilisation des profils est possible en écriture ou en lecture des coordonées des noeuds et de la connectivité des éléments d'un maillage non structuré avec les routines : MEDmeshNodeCoordinateWithProfileWr / mmhcow pour l'écriture des coordonnées, MEDmeshNodeCoordinateWithProfileRd / mmhcor pour la lecture des coordonnées, MEDmeshElementConnectivityWithProfileWr / mmhypw pour l'écriture des connectivités, MEDmeshElementConnectivityWithProfileRd / mmhypr pour la lecture des connectivités. A noter également la routine MEDmeshnEntityWithProfile / mmhnep qui peut récupérer le nombre d'entité à lire selon un profil donné.

Pour toutes ces routines, il est possible de spécifier le mode de stockage des tableaux de coordonnées ou de connectivité en mémoire. Deux modes sont possibles : le mode MED_GLOBAL_STMODE indique que le stockage utilisé contient en mémoire toutes les valeurs relatives à toutes les entités d'un même type ; le mode MED_COMPACT_STMODE indique que le stockage utilisé est compact et ne contient en mémoire que le sous-ensemble de valeurs relatives au profil.

# Créer et lire un maillage évolutif

Dans MED, un maillage peut évoluer par étape, chaque étape étant estampillée par un couple <pas de temps, numéro d'ordre> à l'instar des étapes de calcul d'un champ de résultat.

Une évolution peut porter un maillage déformable à topologie constante (les coordonnées des noeuds ou d'un sous-ensemble des noeuds sont modifiées à chaque étape), un maillage à déformation solide (selon une matrice de transformation pour chaque étape applicable aux coordonnées des noeuds), un maillage redéfinissable (les connectivités des mailles changent au cours des étapes).

A la création d'une étape de calcul, les informations de l'étape précédente inchangées sont automatiquement reportées : coordonnées, connectivités, numéros optionnels, noms optionnels, numéros de famille. Il est donc possible de créer une étape d'évolution sans avoir à y reporter toutes ces données. L'utilisateur a la responsabilité de maintenir la cohérence des informations covariantes au cours des différentes étapes.

A noter qu'un champ de résultat repose désormais sur une étape d'évolution existante d'un maillage (par défaut l'étape initiale <MED_NO_DT, MED_NO_IT>). Il est nécessaire de stocker le maillage initial <MED_NO_DT, MED_NO_IT> avant toute évolution.

Au cours des évolutions d'un maillage, les types géométriques d'éléments doivent rester identiques. Si de nouveaux types géométriques apparaissent, il faut créer un nouveau maillage.

Pour ce qui concerne l'écriture des maillages déformables à topologie constante, il faut utiliser la routine MEDmeshNodeCoordinateWithProfileWr / mmhcow en passant en paramètre le pas de temps et ou le numéro d'ordre correspondant à l'étape, le profil sélectionnant les noeuds dont les coordonnées sont modifiées, le tableau des nouvelles coordonnées.

Le cas d'utilisation suivant après création du maillage initial, créée 2 évolutions successives de sous-ensembles des coordonnées des noeuds du maillage.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* How to create an unstructured mesh
*
* Use case 6 : a 2D unstructured mesh with the following features
* computin steps, profiles and nodes coordinates evolution.
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
int main (int argc, char **argv) {
med_idt fid;
const char meshname[MED_NAME_SIZE+1] = "2D unstructured mesh";
const med_int spacedim = 2;
const med_int meshdim = 2;
const char axisname[2*MED_SNAME_SIZE+1] = "x y ";
const char unitname[2*MED_SNAME_SIZE+1] = "cm cm ";
const med_float initial_coordinates[30] = { 2.,1., 7.,1., 12.,1., 17.,1., 22.,1.,
2.,6., 7.,6., 12.,6., 17.,6., 22.,6.,
2.,11., 7.,11., 12.,11., 17.,11., 22.,11.};
const med_int nnodes = 15;
const med_int triaconnectivity[24] = { 1,7,6, 2,7,1, 3,7,2, 8,7,3,
13,7,8, 12,7,13, 11,7,12, 6,7,11 };
const med_int ntria3 = 8;
const med_int quadconnectivity[16] = {3,4,9,8, 4,5,10,9,
15,14,9,10, 13,8,9,14};
const med_int nquad4 = 4;
/* new coordinates (step 1) for nodes 13, 14 and 15 */
const med_float new_coordinates_step1 [6] = { 12.,15., 17.,15., 22.,15.};
const char profile1name[MED_NAME_SIZE+1] = "UPPER_QUAD4_PROFILE";
const med_int profile1[3] = {13, 14, 15};
const med_int profile1size = 3;
/* new coordinates (step 2) for nodes 8, 9 and 10 */
const med_float new_coordinates_step2 [6] = { 12.,10., 17.,10., 22.,10.};
const char profile2name[MED_NAME_SIZE+1] = "MIDDLE_QUAD4_PROFILE";
const med_int profile2[3] = {8, 9, 10};
const med_int profile2size = 3;
int ret=-1;
/* open MED file */
fid = MEDfileOpen("UsesCase_MEDmesh_6.med",MED_ACC_CREAT);
if (fid < 0) {
MESSAGE("ERROR : file creation ...");
goto ERROR;
}
/* write a comment in the file */
if (MEDfileCommentWr(fid,"A 2D unstructured mesh : 15 nodes, 12 cells") < 0) {
MESSAGE("ERROR : write file description ...");
goto ERROR;
}
/* create the profiles in the file */
if (MEDprofileWr(fid, profile1name, profile1size, profile1 ) < 0) {
MESSAGE("ERROR : create profile ...");
goto ERROR;
}
if (MEDprofileWr(fid, profile2name, profile2size, profile2 ) < 0) {
MESSAGE("ERROR : create profile ...");
goto ERROR;
}
/* mesh creation : a 2D unstructured mesh */
if (MEDmeshCr(fid, meshname, spacedim, meshdim, MED_UNSTRUCTURED_MESH,
"A 2D unstructured mesh","",MED_SORT_DTIT,MED_CARTESIAN, axisname, unitname) < 0) {
MESSAGE("ERROR : mesh creation ...");
goto ERROR;
}
/* initial nodes coordinates in a cartesian axis in full interlace mode
(X1,Y1, X2,Y2, X3,Y3, ...)
*/
if (MEDmeshNodeCoordinateWithProfileWr(fid, meshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_COMPACT_STMODE, MED_NO_PROFILE,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
nnodes, initial_coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
goto ERROR;
}
/* cells connectiviy is defined in nodal mode */
if (MEDmeshElementConnectivityWithProfileWr(fid, meshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_CELL, MED_TRIA3, MED_NODAL,
MED_COMPACT_STMODE, MED_NO_PROFILE,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
ntria3, triaconnectivity) < 0) {
MESSAGE("ERROR : triangular cells connectivity ...");
goto ERROR;
}
if (MEDmeshElementConnectivityWithProfileWr(fid, meshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_CELL, MED_QUAD4, MED_NODAL,
MED_COMPACT_STMODE, MED_NO_PROFILE,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
nquad4, quadconnectivity) < 0) {
MESSAGE("ERROR : quadrangular cells connectivity ...");
goto ERROR;
}
/*
* Mesh deformation (nodes coordinates) in 2 steps
* The nodes modified are identified by a profile
*/
/* STEP 1 : dt1 = 5.5, it = 1*/
if (MEDmeshNodeCoordinateWithProfileWr(fid, meshname, 1, 1, 5.5,
MED_COMPACT_STMODE, profile1name,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
nnodes, new_coordinates_step1 ) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
goto ERROR;
}
/* STEP 2 : dt2 = 8.9, it = 1*/
if (MEDmeshNodeCoordinateWithProfileWr(fid, meshname, 2, 1, 8.9,
MED_COMPACT_STMODE, profile2name,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
nnodes, new_coordinates_step2 ) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
goto ERROR;
}
/* create family 0 : by default, all mesh entities family number is 0 */
if (MEDfamilyCr(fid, meshname,MED_NO_NAME, 0, 0, MED_NO_GROUP) < 0) {
MESSAGE("ERROR : familly 0 creation ...");
goto ERROR;
}
ret=0;
ERROR:
/* close MED file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : close file ...");
ret=-1;
}
return ret;
}

A la lecture des maillages déformables à topologie constante, une fois la lecture du maillage initiale effectuée, il faut itérer sur les différentes étapes d'évolution présentes dans le maillage (le nombre d'étape est lue par les routines MEDmeshInfoByName / mmhmin ou MEDmeshInfo / mmhmii) et à chaque étape : récupérer les valeurs du pas de temps et du numéro d'itération avec la routine MEDmeshComputationStepInfo / mmhcsi ; déterminer la nature du changement parmi les cas possibles pré-cités avec la routine MEDmeshnEntityWithProfile / mmhnep et également récupérer le nombre de noeuds à lire selon le mode de stockage mémoire passé en paramètre ; lire les nouvelles coordonnées des noeuds avec la routine MEDmeshNodeCoordinateWithProfileRd / mmhcor.

C'est ce que fait le cas d'utilisation suivant.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Use case 7 : read a 2D unstructured mesh with nodes coordinates modifications
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
int main (int argc, char **argv) {
med_idt fid;
const char meshname[MED_NAME_SIZE+1] = "2D unstructured mesh";
char meshdescription[MED_COMMENT_SIZE+1]="";
med_int meshdim;
med_int spacedim;
med_sorting_type sortingtype;
med_int nstep;
med_mesh_type meshtype;
med_axis_type axistype;
char axisname[2*MED_SNAME_SIZE+1]="";
char unitname[2*MED_SNAME_SIZE+1]="";
char dtunit[MED_SNAME_SIZE+1]="";
med_float *coordinates = NULL;
med_int nnodes = 0;
med_int *triaconnectivity = NULL;
med_int ntria3 = 0;
med_int *quadconnectivity = NULL;
med_int nquad4 = 0;
med_bool coordinatechangement;
med_bool geotransformation;
int i, it;
med_int profilesize;
char profilename[MED_NAME_SIZE+1]="";
med_int numdt, numit;
med_float dt;
int ret=-1;
/* open MED file with READ ONLY access mode */
fid = MEDfileOpen("UsesCase_MEDmesh_6.med",MED_ACC_RDONLY);
if (fid < 0) {
MESSAGE("ERROR : open file in READ ONLY ACCESS mode ...");
goto ERROR;
}
/*
* ... we know that the MED file has only one mesh,
* a real code would check ...
*/
/* read mesh informations : mesh dimension, space dimension ... */
if (MEDmeshInfoByName(fid, meshname, &spacedim, &meshdim, &meshtype, meshdescription,
dtunit, &sortingtype, &nstep, &axistype, axisname, unitname) < 0) {
MESSAGE("ERROR : mesh info ...");
goto ERROR;
}
/* read how many nodes in the mesh */
if ((nnodes = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NO_GEOTYPE,
MED_COORDINATE, MED_NO_CMODE,&coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
/*
* ... we know that we only have MED_TRIA3 and MED_QUAD4 in the mesh,
* a real code would check all MED geometry cell types ...
*/
/* read how many triangular cells in the mesh */
if ((ntria3 = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,MED_TRIA3,
MED_CONNECTIVITY, MED_NODAL,&coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of MED_TRIA3 ...");
goto ERROR;
}
/* read how many quadrangular cells in the mesh */
if ((nquad4 = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,MED_QUAD4,
MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of MED_QUAD4 ...");
goto ERROR;
}
/* read mesh nodes coordinates in the initial mesh */
if ((coordinates = (med_float*) malloc(sizeof(med_float)*nnodes*spacedim)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshNodeCoordinateRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
free(coordinates);
goto ERROR;
}
/* read cells connectivity in the initial mesh */
if ((triaconnectivity = (med_int *) malloc(sizeof(med_int)*ntria3*3)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshElementConnectivityRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,
MED_TRIA3, MED_NODAL, MED_FULL_INTERLACE, triaconnectivity) < 0) {
MESSAGE("ERROR : MED_TRIA3 connectivity ...");
free(triaconnectivity);
goto ERROR;
}
free(triaconnectivity);
if ((quadconnectivity = (med_int *) malloc(sizeof(med_int)*nquad4*4)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshElementConnectivityRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,
MED_QUAD4, MED_NODAL, MED_FULL_INTERLACE, quadconnectivity) < 0) {
MESSAGE("ERROR : MED_QUAD4 connectivity ...");
free(quadconnectivity);
goto ERROR;
}
free(quadconnectivity);
/*
* ... we know that the family number of nodes and elements is 0, a real code would check ...
*/
/* read nodes coordinates changements step by step */
for (it=1;it<nstep;it++) {
if (MEDmeshComputationStepInfo(fid, meshname, it+1,
&numdt, &numit, &dt) < 0) {
MESSAGE("ERROR : Computing step info ...");
SSCRUTE(meshname);
goto ERROR;
}
/* test changement : for nodes coordinates */
if ((nnodes = MEDmeshnEntityWithProfile(fid, meshname, numdt, numit,
MED_NODE, MED_NO_GEOTYPE,
MED_COORDINATE, MED_NO_CMODE,
MED_GLOBAL_STMODE, profilename, &profilesize,
&coordinatechangement, &geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
/* if coordinates have changed, then read the new coordinates */
if (coordinatechangement) {
if (MEDmeshNodeCoordinateWithProfileRd(fid, meshname, numdt, numit,
MED_GLOBAL_STMODE,profilename,
MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,
coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
free(coordinates);
goto ERROR;
}
}
}
free(coordinates);
ret=0;
ERROR:
/* close MED file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : close file");
ret=-1;
}
return ret;
}

Le cas d'utilisation suivant propose une approche plus générique dans la lecture des maillages déformables à topologie constante.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Use case 8 : read a 2D unstructured mesh with coordinates nodes
* modifications (generic approach)
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
int main (int argc, char **argv) {
med_idt fid;
med_int nmesh;
char meshname[MED_NAME_SIZE+1]="";
char meshdescription[MED_COMMENT_SIZE+1]="";
med_int meshdim;
med_int spacedim;
med_sorting_type sortingtype;
med_int nstep;
med_mesh_type meshtype;
med_axis_type axistype;
char *axisname;
char *unitname;
char dtunit[MED_SNAME_SIZE+1]="";
med_float *coordinates = NULL;
med_int ngeo = 0;
med_int nnodes = 0;
med_int *connectivity = NULL;
med_bool coordinatechangement;
med_bool geotransformation;
int i, it, j;
med_int profilesize;
char profilename[MED_NAME_SIZE+1]="";
med_int numdt, numit;
med_float dt;
med_geometry_type geotype;
med_geometry_type *geotypes = MED_GET_CELL_GEOMETRY_TYPE;
int ret=-1;
/* open MED file with READ ONLY access mode */
fid = MEDfileOpen("UsesCase_MEDmesh_6.med",MED_ACC_RDONLY);
if (fid < 0) {
MESSAGE("ERROR : open file in READ ONLY ACCESS mode ...");
goto ERROR;
}
/* read how many mesh in the file */
if ((nmesh = MEDnMesh(fid)) < 0) {
MESSAGE("ERROR : read how many mesh ...");
goto ERROR;
}
for (i=0;i<nmesh;i++) {
/* read computation space dimension */
if ((spacedim = MEDmeshnAxis(fid, i+1)) < 0) {
MESSAGE("ERROR : read computation space dimension ...");
goto ERROR;
}
/* memory allocation */
if ((axisname = (char*) malloc(MED_SNAME_SIZE*spacedim+1)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if ((unitname = (char*) malloc(MED_SNAME_SIZE*spacedim+1)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
/* read mesh informations : meshname, mesh dimension, mesh type ... */
if (MEDmeshInfo(fid, i+1, meshname, &spacedim, &meshdim, &meshtype, meshdescription,
dtunit, &sortingtype, &nstep,
&axistype, axisname, unitname) < 0) {
MESSAGE("ERROR : mesh info ...")
free(axisname);
free(unitname);
goto ERROR;
}
free(axisname);
free(unitname);
/* read how many nodes in the mesh */
if ((nnodes = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NONE,
MED_COORDINATE, MED_NO_CMODE,&coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
/* read mesh nodes coordinates */
if ((coordinates = (med_float*) malloc(sizeof(med_float)*nnodes*spacedim)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshNodeCoordinateRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
free(coordinates);
goto ERROR;
}
/* read all MED geometry cell types */
for (it=1; it<=MED_N_CELL_FIXED_GEO; it++) {
geotype = geotypes[it];
if ((ngeo = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,geotype,
MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of cell ...");
ISCRUTE_int(geotype);
goto ERROR;
}
if (ngeo) {
/* read cells connectivity in the mesh */
if ((connectivity = (med_int *) malloc(sizeof(med_int)*ngeo*(geotype%100))) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshElementConnectivityRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,
geotype, MED_NODAL, MED_FULL_INTERLACE, connectivity) < 0) {
MESSAGE("ERROR : cell connectivity ...");
ISCRUTE_int(geotype);
free(connectivity);
goto ERROR;
}
/* memory deallocation */
free(connectivity);
connectivity = NULL;
}
}
/* read nodes coordinates changements step by step */
for (it=1;it<nstep;it++) {
if (MEDmeshComputationStepInfo(fid, meshname, it+1,
&numdt, &numit, &dt) < 0) {
MESSAGE("ERROR : Computing step info ...");
SSCRUTE(meshname);
goto ERROR;
}
/* test changement : for nodes coordinates */
if ((nnodes = MEDmeshnEntityWithProfile(fid, meshname, numdt, numit,
MED_NODE, MED_NONE,
MED_COORDINATE, MED_NO_CMODE,
MED_GLOBAL_STMODE, profilename, &profilesize,
&coordinatechangement, &geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
/* if only coordinates have changed, then read the new coordinates */
/* to verify if there is a matrix transformation => UsesCase_MEDmesh12. */
if (coordinatechangement && geotransformation) {
if (MEDmeshNodeCoordinateWithProfileRd(fid, meshname, numdt, numit,
MED_GLOBAL_STMODE,profilename,
MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,
coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
free(coordinates);
goto ERROR;
}
}
}
}
free(coordinates);
ret=0;
ERROR:
/* close MED file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : close file");
ret=-1;
}
return ret;
}

Pour ce qui concerne l'écriture des maillages avec déformation solide, il faut utiliser la routine MEDmeshNodeCoordinateTrsfWr / mmhtfw en passant en paramètre le pas de temps et ou le numéro d'ordre correspondant à l'étape et la matrice de transformation. Cette matrice comporte 7 valeurs réelles : les trois premières définissent la translation à appliquer selon l'ordre des axes définis pour le maillage et les quatres suivantes définissent une rotation phi par le quarternion (p4,p5-7) où p4 est le scalaire et p5-7 le vecteur décrit suivant l'ordre des axes définis pour le maillage. S'il y a moins de trois axes définis, les paramètres inutiles à la transformation doivent être à zéro.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* How to create an unstructured mesh
*
* Use case 9 : a 2D unstructured mesh with moving grid
* transformation
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
int main (int argc, char **argv) {
med_idt fid;
const char meshname[MED_NAME_SIZE+1] = "2D unstructured mesh";
const med_int spacedim = 2;
const med_int meshdim = 2;
const char axisname[2*MED_SNAME_SIZE+1] = "x y ";
const char unitname[2*MED_SNAME_SIZE+1] = "cm cm ";
const med_float initial_coordinates[30] = { 2.,1., 7.,1., 12.,1., 17.,1., 22.,1.,
2.,6., 7.,6., 12.,6., 17.,6., 22.,6.,
2.,11., 7.,11., 12.,11., 17.,11., 22.,11.};
const med_int nnodes = 15;
const med_int triaconnectivity[24] = { 1,7,6, 2,7,1, 3,7,2, 8,7,3,
13,7,8, 12,7,13, 11,7,12, 6,7,11 };
const med_int ntria3 = 8;
const med_int quadconnectivity[16] = {3,4,9,8, 4,5,10,9,
15,14,9,10, 13,8,9,14};
const med_int nquad4 = 4;
/* matrix transformation (step 1) : rotation about the Y-axis : 45 degrees */
const med_float tansfMatrix_step1 [7] = { 0.0, 0.0, 0.0, 0.92388, 0.0, 0.38268, 0.0 };
/* matrix transformation (step 2) : rotation about the Y-axis : 90 degrees */
const med_float tansfMatrix_step2 [7] = { 0.0, 0.0, 0.0, 0.707, 0.0, 0.707, 0.0 };
int ret=-1;
/* open MED file */
fid = MEDfileOpen("UsesCase_MEDmesh_9.med",MED_ACC_CREAT);
if (fid < 0) {
MESSAGE("ERROR : file creation ...");
goto ERROR;
}
/* write a comment in the file */
if (MEDfileCommentWr(fid,"A 2D unstructured mesh : 15 nodes, 12 cells") < 0) {
MESSAGE("ERROR : write file description ...");
goto ERROR;
}
/* mesh creation : a 2D unstructured mesh */
if (MEDmeshCr(fid, meshname, spacedim, meshdim, MED_UNSTRUCTURED_MESH,
"A 2D structured mesh","",MED_SORT_DTIT,MED_CARTESIAN, axisname, unitname) < 0) {
MESSAGE("ERROR : mesh creation ...");
goto ERROR;
}
/* nodes coordinates in a cartesian axis in full interlace mode
(X1,Y1, X2,Y2, X3,Y3, ...) with no iteration and computation step
*/
if (MEDmeshNodeCoordinateWithProfileWr(fid, meshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_COMPACT_STMODE, MED_NO_PROFILE,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
nnodes, initial_coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
goto ERROR;
}
/* cells connectiviy is defined in nodal mode */
if (MEDmeshElementConnectivityWithProfileWr(fid, meshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_CELL, MED_TRIA3, MED_NODAL,
MED_COMPACT_STMODE, MED_NO_PROFILE,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
ntria3, triaconnectivity) < 0) {
MESSAGE("ERROR : triangular cells connectivity ...");
goto ERROR;
}
if (MEDmeshElementConnectivityWithProfileWr(fid, meshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_CELL, MED_QUAD4, MED_NODAL,
MED_COMPACT_STMODE, MED_NO_PROFILE,
MED_FULL_INTERLACE, MED_ALL_CONSTITUENT,
nquad4, quadconnectivity) < 0) {
MESSAGE("ERROR : quadrangular cells connectivity ...");
goto ERROR;
}
/*
* Mesh deformation (nodes coordinates) in 2 steps
* A rotation by step for each node
*/
/* STEP 1 : dt1 = 5.5, it = 1*/
if ( MEDmeshNodeCoordinateTrsfWr(fid, meshname, 1, 1, 5.5, tansfMatrix_step1) < 0) {
MESSAGE("Erreur a l'ecriture de la transformation géométrique n°1");
goto ERROR;
}
/* STEP 2 : dt2 = 8.9, it = 1*/
if ( MEDmeshNodeCoordinateTrsfWr(fid, meshname, 2, 2, 8.9, tansfMatrix_step2 ) < 0) {
MESSAGE("Erreur a l'ecriture de la transformation géométrique n°2");
goto ERROR;
}
/* create family 0 : by default, all mesh entities family number is 0 */
if (MEDfamilyCr(fid, meshname,MED_NO_NAME, 0, 0, MED_NO_GROUP) < 0) {
MESSAGE("ERROR : create family ...");
goto ERROR;
}
ret=0;
ERROR:
/* close MED file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : close file ...");
ret=-1;
}
return ret;
}

A la lecture des maillages avec déformation solide, une fois la lecture du maillage initiale effectuée, il faut itérer sur les différentes étapes d'évolution présentes dans le maillage (le nombre d'étape est lue par les routines MEDmeshInfoByName / mmhmin ou MEDmeshInfo / mmhmii) et à chaque étape : récupérer les valeurs du pas de temps et du numéro d'itération avec la routine MEDmeshComputationStepInfo / mmhcsi ; déterminer la nature du changement parmi les cas possibles pré-cités avec la routine MEDmeshnEntityWithProfile / mmhnep et également vérifier la présence de la matrice de transformation ; lire la matrice de transformation avec la routine MEDmeshNodeCoordinateTrsfRd / mmhtfr.

Le cas d'utilisation suivant permet de lire de manière générique un maillage évolutif, à la fois s'il s'agit d'un maillage déformable à topologie constante ou d'un maillage avec déformation solide.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Use case 12 : read a 2D unstructured mesh with moving grid (generic approach)
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
int main (int argc, char **argv) {
med_idt fid;
med_int nmesh;
char meshname[MED_NAME_SIZE+1]="";
char meshdescription[MED_COMMENT_SIZE+1]="";
med_int meshdim;
med_int spacedim;
med_sorting_type sortingtype;
med_int nstep;
med_mesh_type meshtype;
med_axis_type axistype;
char *axisname;
char *unitname;
char dtunit[MED_SNAME_SIZE+1]="";
med_float *coordinates = NULL;
med_int ngeo = 0;
med_int nnodes = 0;
med_int *connectivity = NULL;
med_bool coordinatechangement;
med_bool geotransformation;
med_bool matrixtransformation;
med_int matrixsize;
med_float matrix[7]={ 0, 0, 0, 0, 0, 0, 0};
int i, it, j;
med_int profilesize;
char profilename[MED_NAME_SIZE+1]="";
med_int numdt, numit;
med_float dt;
med_geometry_type geotype;
med_geometry_type *geotypes = MED_GET_CELL_GEOMETRY_TYPE;
int ret=-1;
/* open MED file with READ ONLY access mode */
fid = MEDfileOpen("UsesCase_MEDmesh_9.med",MED_ACC_RDONLY);
if (fid < 0) {
MESSAGE("ERROR : open file in READ ONLY ACCESS mode ...");
goto ERROR;
}
/* read how many mesh in the file */
if ((nmesh = MEDnMesh(fid)) < 0) {
MESSAGE("ERROR : read how many mesh ...");
goto ERROR;
}
for (i=0;i<nmesh;i++) {
/* read computation space dimension */
if ((spacedim = MEDmeshnAxis(fid, i+1)) < 0) {
MESSAGE("ERROR : read computation space dimension ...");
goto ERROR;
}
/* memory allocation */
if ((axisname = (char*) malloc(MED_SNAME_SIZE*spacedim+1)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if ((unitname = (char*) malloc(MED_SNAME_SIZE*spacedim+1)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
/* read mesh informations : meshname, mesh dimension, mesh type ... */
if (MEDmeshInfo(fid, i+1, meshname, &spacedim, &meshdim, &meshtype, meshdescription,
dtunit, &sortingtype, &nstep,
&axistype, axisname, unitname) < 0) {
MESSAGE("ERROR : mesh info ...");
free(axisname);
free(unitname);
goto ERROR;
}
free(axisname);
free(unitname);
/* read how many nodes in the mesh */
if ((nnodes = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NONE,
MED_COORDINATE, MED_NO_CMODE,&coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
/* read mesh nodes coordinates */
if ((coordinates = (med_float*) malloc(sizeof(med_float)*nnodes*spacedim)) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshNodeCoordinateRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
free(coordinates);
goto ERROR;
}
/* read all MED geometry cell types */
for (it=1; it<= MED_N_CELL_FIXED_GEO; it++) {
geotype = geotypes[it];
if ((ngeo = MEDmeshnEntity(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,geotype,
MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of cell ...");
ISCRUTE_int(geotype);
goto ERROR;
}
if (ngeo) {
/* read cells connectivity in the mesh */
if ((connectivity = (med_int *) malloc(sizeof(med_int)*ngeo*(geotype%100))) == NULL) {
MESSAGE("ERROR : memory allocation ...");
goto ERROR;
}
if (MEDmeshElementConnectivityRd(fid, meshname, MED_NO_DT, MED_NO_IT, MED_CELL,
geotype, MED_NODAL, MED_FULL_INTERLACE, connectivity) < 0) {
MESSAGE("ERROR : cell connectivity ...");
ISCRUTE_int(geotype);
free(connectivity);
goto ERROR;
}
/* memory deallocation */
free(connectivity);
connectivity = NULL;
}
}
/* read nodes coordinates changements step by step */
for (it=1;it<nstep;it++) {
if (MEDmeshComputationStepInfo(fid, meshname, it+1,
&numdt, &numit, &dt) < 0) {
MESSAGE("ERROR : Computing step info ...");
SSCRUTE(meshname);
goto ERROR;
}
/* test changement : for nodes coordinates */
if ((nnodes = MEDmeshnEntityWithProfile(fid, meshname, numdt, numit,
MED_NODE, MED_NONE,
MED_COORDINATE, MED_NO_CMODE,
MED_GLOBAL_STMODE, profilename, &profilesize,
&coordinatechangement, &geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
/* if only coordinates have changed, then read the new coordinates */
if (coordinatechangement && geotransformation) {
if (MEDmeshNodeCoordinateWithProfileRd(fid, meshname, numdt, numit,
MED_GLOBAL_STMODE,profilename,
MED_FULL_INTERLACE,MED_ALL_CONSTITUENT,
coordinates) < 0) {
MESSAGE("ERROR : nodes coordinates ...");
free(coordinates);
goto ERROR;
}
}
if (coordinatechangement && ! geotransformation) {
matrixsize = MEDmeshnEntity(fid,meshname,numdt,numit,
MED_NODE,MED_NONE,MED_COORDINATE_TRSF,MED_NODAL,&coordinatechangement,
&matrixtransformation);
if (matrixsize < 0) {
MESSAGE("ERROR : matrix transformation ...");
goto ERROR;
}
if (matrixtransformation) {
if ( MEDmeshNodeCoordinateTrsfRd(fid, meshname, numdt, numit, matrix) < 0 ) {
MESSAGE("ERROR : read transformation matrix ...");
goto ERROR;
}
}
}
}
}
free(coordinates);
ret=0;
ERROR:
/* close MED file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : close file");
ret=-1;
}
return ret;
}

# Créer et lire une équivalence entre les entités d'un maillage

La notion d'équivalence permet de gérer des listes de correspondances mettant en relation deux à deux des entités de même type (deux noeuds, deux mailles, deux arêtes ou deux faces). Voici quelques exemples :

- Dans le cadre d'une symétrie de révolution, un bord de domaine est associé à un autre bord. Ces bords n'étant pas des volumes, les mailles en correspondances sont dans ce cas des mailles 2D.
- Dans le cadre de voisinages non conformes, on veut mémoriser une liste de mailles 3D liées. La notion d'équivalence est parfaite et concise.

## Création d'une équivalence entre entités d'un même maillage

Une équivalence est identifiée par son nom (chaîne de MED_NAME_SIZE caractères) et possède une description (chaîne d'au plus MED_COMMENT_SIZE). La création d'équivalences est optionnelle. Un fichier peut contenir zéro ou plusieurs équivalences pour chaque maillage local au fichier. La routine MEDequivalenceCr / meqcre permet la création d'équivalences d'entités d'un maillage.

if (MEDequivalenceCr(fid,maa,equ,des) < 0)

Fichier d'exemple associé

## Ecriture des correspondances d'une équivalence entre entités de même type

Une fois l'équivalence créée, il ne reste plus qu'à y associer les correspondances d'entitées par l'intermédiaire d'un tableau de correspondances. Si l'on décrit des correspondances sur des types d'entités différents ou sur différentes étapes d'évolution du maillage, plusieurs tableaux de correspondances peuvent apparaîtres dans une équivalence. Les numéros d'entités en correspondances apparaissent sous forme d'une suite de pairs dans un tableau de correspondances.

Voici un exemple :

correspondence
C1 | C2 | C3
--- | --- | ---
1 | 2 | 3 | 4 | 5 | 6

Le tableau de correspondances appliqué à des entités de type MED_TRIA3 (triangle à 3 noeuds) décrit les 3 correspondances suivantes :

- (triangle numéro 1 , triangle numéro 2), (triangle numéro 3 , triangle numéro 4), (triangle numéro 5 , triangle numéro 6).

Les numéros d'entités utilisés sont ceux de la numérotation implicite des entités même si une numérotation optionnelle est présente (régle invariante dans MED).

La routine MEDequivalenceCorrespondenceWr / meqcow permet d'écrire un tableau de correspondances à une étape d'évolution du maillage ( ( MED_NO_DT , MED_NO_IT ); par défaut) et pour un type d'entité . Si le type d'entité est un élément, il faut préciser le type géométrique de l'élément.

if (MEDequivalenceCorrespondenceWr(fid,maa,equ,MED_NO_DT,MED_NO_IT,
MED_CELL,MED_TRIA3,ncor,cor) < 0)

Fichier d'exemple associé

## Lectures des équivalences

La découverte des équivalences définies sur un maillage se fait par itération. Le nombre d'équivalences sur lesquelles itérer est renvoyé par la routine MEDnEquivalence / meqneq.

if ((nequ = MEDnEquivalence(fid,maa)) < 0)

Fichier d'exemple associé

Chaque appel à MEDequivalenceInfo / meqeqi renvoie ensuite l'ensemble des informations relatives à une équivalence, à savoir :

- Nom de l'équivalence
- Description de l'équivalence
- Nombre d'étapes d'évolution du maillage pour lesquelles au moins un tableau de correspondance existe
- Nombre de correspondances existantes pour l'étape par défaut ( MED_NO_DT , MED_NO_IT )

for (i = 0;i<nequ;i++) {
ret = MEDequivalenceInfo(fid,nommaa,i+1,equ,des,&nstep,&nocstpncor);

Fichier d'exemple associé

Si le maillage concerné ne possède qu'une étape d'évolution (obligatoirement ( MED_NO_DT , MED_NO_IT ) ) ou s'il n'y a qu'une étape d'évolution de maillage pour laquelle l'équivalence est définie et que le nombre de correspondances pour l'étape par défaut ( MED_NO_DT , MED_NO_IT ) est non nul, il n'est pas necessaire d'inspecter les différentes étapes par des appels itératifs à MEDequivalenceComputingStepInfo / meqcsi.

## Lectures des équivalences pour différentes étapes d'évolution du maillage

Si l'équivalence est définie sur plusieurs étapes d'évolution de maillage la fonction MEDequivalenceComputingStepInfo / meqcsi permet d'obtenir les informations suivantes pour chaque étape :

- Numéro de pas de temps de l'étape de calcul (MED_NO_DT si pas de numéro de pas de temps).
- Numéro d'itération de l'étape de calcul (MED_NO_IT si pas de numéro d'itération).
- Nombre de tableaux de correspondances sur l'étape de calcul.

for (_cstpit=1; _cstpit <= nstep; ++_cstpit) {
ret = MEDequivalenceComputingStepInfo (fid, nommaa, equ, _cstpit,
& _numdt, &_numit,&nocstpncor);

Fichier d'exemple associé

## Lectures des correspondances d'une équivalence entre entités –de même type– à une étape d'évolution du maillage

La fonction MEDequivalenceCorrespondenceSize / meqcsz lit le nombre de correspondances d'une étape d'évolution du maillage et permet de dimensionner le tableau de correspondances. Cette fonction peut être appelée pour chaque couple ( type d'entité , type géométrique) présent dans le maillage si l'on n'a pas d'information concernant la présence d'équivalence sur des entités particulières.

ret = MEDequivalenceCorrespondenceSize(fid,nommaa,equ,_numdt,_numit,MED_NODE,MED_NONE,&ncor);
if (ncor > 0) {
cor = (med_int*) malloc(sizeof(med_int)*ncor*2);

Fichier d'exemple associé

Une fois le tableau de correspondances dimensionné, la fonction MEDequivalenceCorrespondenceRd / meqcor permet de lire le tableau de correspondance pour un type d'entité et une étape d'évolution du maillage fixés.

ret= MEDequivalenceCorrespondenceRd(fid,nommaa,equ,_numdt,_numit,
MED_NODE,MED_NONE,cor);

Fichier d'exemple associé

## Liens vers les fichiers exemples utilisés

- Fichier d'exemple test12.c

- Fichier d'exemple test13.c

- Fichier d'exemple test13b.c

# Créer et lire un maillage avec des éléments de structure

MED permet de créer des modèles d'éléments de structure. Un modèle d'élément est propre à un fichier qui doit être celui de(s) maillage(s) de calcul qui utilisent le modèle. Il peut y avoir plusieurs modèles d'éléments de structures dans un même fichier. Une fois le modèle défini, l'élément de structure devient un nouveau type d'élément d'un maillage de calcul au même titre que les autres types d'éléments pré-définis dans le modèle.

Le modèle MED réserve des noms de modèles pour les particules (MED_PARTICLE_NAME), les billes (MED_BALL_NAME) et les poutres (MED_BEAM_NAME). Cette liste de noms réservés est amenée à s'étoffer au fil des versions de MED, de fait tous les noms de modèle commençant par « MED_ » sont également réservés. A chaque nom de modèle réservé ou fixé par l'utilisateur est associé un numéro de type géométrique unique au fichier. Ce numéro complète les numéros existants pour les types géométriques éléments finis. Le numéro de type d'un élément de structure est utilisable comme celui des types géométriques classiques pour s'informer de la présence du type d'élément dans un maillage de calcul. Le type d'entité de ce type d'élément est MED_STRUCT_ELEMENT.

Un modèle de structure utilisé dans un fichier doit être complètement défini dans ce fichier. Ainsi les maillages et les champs s'appuyant sur des élements de ce modèle pourront être relus par tout code s'intéressant aux éléments de structure. La description d'un modèle d'élément de structure peut s'appuyer sur un maillage support.

Si le modèle ne contient pas de maillage support, chaque élément de structure associé au modèle, s'appuie sur les noeuds du maillage de calcul pour se positionner. C'est le cas par exemple du modèle pré-défini des particules. Les coordonnées de ces noeuds peuvent évoluer au cours du temps selon le principe des maillages évolutifs présentés précédemment.

Un maillage support contient 1 ou plusieurs noeuds et éventuellement des mailles. La connectivité des éléments de structure y est uniquement décrite en mode nodal. Les noeuds d'un maillage support sont définis indépendamment des maillages de calcul. Ces noeuds ne sont pas référencés dans les maillages de calculs. Les coordonnées des noeuds sont définies dans un espace de dimension égale à celle de l'élément de structure. Le repère de coordonnées est propre à la description du modèle de l'élément. Les mailles définies dans un maillage support sont indépendantes des maillages de calcul et ne sont pas référencées dans les maillages de calcul. S'il y a des mailles dans le maillage support, la connectivité des éléments de structure référence des numéros de mailles dans les maillages de calcul. Il ne peut y avoir qu'un seul type géométrique de maille dans un maillage support. Dans un maillage support, il est pas utile d'écrire les numéros de familles (toutes les entités sont rattachées à la famille 0 par défaut), les numéros optionnels, les noms optionnels des entités du maillage. Un maillage support ne peut contenir de polygones ou polyèdres quelconques.

Les caractéristiques d'un élément de structure sont décrites par des attributs. Il existe deux types d'attributs caractéristiques : des attributs caractéristiques à valeur constante pour tous les éléments du modèle (ou attributs caractéristiques du modèle), des attributs caractéristiques à valeur variable selon les éléments du modèle (la valeur est alors définie au niveau des éléments dans les maillage de calcul). Les attributs caractéristiques sont typé par les types MED standards (entier, réel, chaîne de caractères de taille MED_NAME_SIZE). Un attribut peut comporter plusieurs composantes au même titre qu'un champ.

La création d'un modèle d'élément de structure se fait avec la routine MEDstructElementCr / msecre. Un modèle est identifié par son nom qui est une chaîne de MED_NAME_SIZE caractères. La création d'un attribut caractéristique à valeur variable se fait avec la routine MEDstructElementVarAttCr / msevac. La création d'un attribut caractéristique du modèle se fait avec les routines MEDstructElementConstAttWr / mseraw, mseiaw, msesaw. La routine MEDmeshStructElementVarAttWr / mmhraw, mmhiaw, mmhsaw permet d'écrire les valeurs d'un attribut à valeur variable, l'appel à cette routine se faisant au moment de la création d'un maillage de calcul. Les routines MEDstructElementConstAttWr / mseraw, mseiaw, msesaw et MEDstructElementConstAttWithProfileWr / mserpw, mseipw, msespw permettent d'écrire les valeurs d'un attribut constant respectivement sans et avec un profil.

La création d'un maillage support se fait avec une routine spécifique MEDsupportMeshCr / msmcre. L'écriture des coordonnées des noeuds et de la connectivité des mailles se fait avec les mêmes routines que celles utilisées pour les maillages de calcul. Un maillage support est identifié par son nom qui est une chaîne de MED_NAME_SIZE caractères.

Le cas d'utilisation suivant définit 3 modèles d'éléments de structure différents pour les particules, les billes et les poutres. Les deux derniers modèles s'appuient sur des maillages support également définis dans le fichier. Des éléments de structure qui correspondent à ces modèles sont finalement utilisés dans un maillage de calcul.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* StructElement use case 1 : write struct elements model in a file
* STEP 1 : suppport mesh creation
* STEP 2 : struct element model creation
* STEP 3 : computation mesh creation
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
int main (int argc, char **argv) {
med_idt fid;
char elementname[MED_NAME_SIZE+1]="";
const char ballsupportname[MED_NAME_SIZE+1]="BALL_SUPPORT_MESH";
const char beamsupportname[MED_NAME_SIZE+1]="BEAM_SUPPORT_MESH";
const char computmeshname[MED_NAME_SIZE+1]="COMPUT_MESH";
const char beamsectionname[MED_NAME_SIZE+1]="BEAM_SECTION_MESH";
const med_int elementdim = 3;
med_int nnode;
med_geometry_type geotype=MED_NONE;
med_int ncomp;
const med_float ballmeshnodescoo[3] = {0.0, 0.0, 0.0 };
const med_float beammeshnodescoo[3*7] = {0.0,0.0,0.0,
0.0,0.0,2.0,
0.0,0.0,4.0,
0.0,0.0,5.0,
0.0,0.0,7.0,
0.0,0.0,10.0,
0.0,0.0,11.0 };
const med_float beamsectioncoo[9*3] = {-0.2,-0.2,0.0,
0.0,-0.2,0.0,
0.2,-0.2,0.0,
-0.2, 0.0,0.0,
0.0, 0.0,0.0,
0.2, 0.0,0.0,
-0.2, 0.2,0.0,
0.0, 0.2,0.0,
0.2, 0.2,0.0 };
const med_int seg2connectivity[2*6] = {1,2, 2,3, 3,4, 4,5, 5,6, 6,7};
med_int spacedim, meshdim,nseg2;
/* 123456789012345612345678901234561234567890123456 */
const char axisname[3*MED_SNAME_SIZE+1] = "x y z ";
const char unitname[3*MED_SNAME_SIZE+1] = "cm cm cm ";
const med_float attvalue[6] = {0.2,0.3,0.4,0.4,0.3,0.2};
/* 1234567890123456789012345678901234567890123456789012345678901234 */
const char attprovalue[2*MED_NAME_SIZE+1] = {"EXTREMITY_1_____________________________________________________" \
"EXTREMITY_2_____________________________________________________" };
const char profilename[MED_NAME_SIZE+1] = "EXTREMITY_PROFILE_NAME";
const med_int profilesize = 2;
const med_int profile[2] = {1,6};
const med_float meshcoo[3*12] = { 0.0, 0.0, 0.0,
1.1, 1.1, 1.1,
2.2, 2.2, 2.2,
10., 10., 10.,
12., 12., 12.,
60., 20., 20.,
70., 20., 20.,
80., 20., 20.,
90., 20., 20.,
100., 20., 20.,
110., 20., 20.,
120., 20., 20.
};
const med_int beamconnectivity[12] = { 6,7,
7,8,
8,9,
9,10,
10,11,
11,12 };
med_int nentity;
const med_int labels[3] = { 1, 2, 3 }; /* nodes numbers */
const med_int ballconnectivity[2] = { 4, 5 }; /* nodes numbers */
const med_float balldiameter[2] = { 2.0, 5.8 };
const med_int nquad4=4;
const med_int beamsectionconnectivity[4*4] = { 4,5,2,1,
5,6,3,2,
7,8,5,4,
8,9,6,5};
int ret=-1;
/* file creation */
fid = MEDfileOpen("UsesCase_MEDstructElement_1.med",MED_ACC_CREAT);
if (fid < 0) {
MESSAGE("ERROR : file creation");
goto ERROR;
}
/* STEP 1 : support meshes creation */
spacedim = 3;
meshdim = 3;
/* Mesh 1 : support mesh for ball model */
if (MEDsupportMeshCr(fid, ballsupportname, spacedim, meshdim, "Support mesh for a ball model",
MED_CARTESIAN, axisname, unitname) < 0) {
MESSAGE("ERROR : creating a support mesh ...");
goto ERROR;
}
/* 1 node and no cell in the mesh */
nnode = 1;
if (MEDmeshNodeCoordinateWr(fid, ballsupportname, MED_NO_DT, MED_NO_IT, 0.0,
MED_FULL_INTERLACE, nnode, ballmeshnodescoo) < 0) {
MESSAGE("ERROR : write nodes coordinates ...");
goto ERROR;
}
/* Mesh 2 :support mesh for beam model */
if (MEDsupportMeshCr(fid, beamsupportname, spacedim, meshdim, "Support mesh for a beam model",
MED_CARTESIAN, axisname, unitname) < 0) {
MESSAGE("ERROR : creating a support mesh ...");
goto ERROR;
}
/* 7 nodes and 6 MED_SEG2 */
nnode = 7;
if (MEDmeshNodeCoordinateWr(fid, beamsupportname, MED_NO_DT, MED_NO_IT, 0.0,
MED_FULL_INTERLACE, nnode, beammeshnodescoo) < 0) {
MESSAGE("ERROR : write nodes coordinates ...");
goto ERROR;
}
nseg2 = 6;
if (MEDmeshElementConnectivityWr(fid, beamsupportname, MED_NO_DT, MED_NO_IT, 0.0, MED_CELL, MED_SEG2,
MED_NODAL, MED_FULL_INTERLACE, nseg2, seg2connectivity) < 0) {
MESSAGE("ERROR : write cells connectivity ...");
goto ERROR;
}
/* Mesh 3 : support mesh to define a section for integration points of
a struct element */
if (MEDsupportMeshCr(fid, beamsectionname, spacedim, meshdim, "Support mesh for a section of the beam model",
MED_CARTESIAN, axisname, unitname) < 0) {
MESSAGE("ERROR : creating a support mesh ...");
goto ERROR;
}
nnode = 9;
if (MEDmeshNodeCoordinateWr(fid, beamsectionname, MED_NO_DT, MED_NO_IT, 0.0,
MED_FULL_INTERLACE, nnode, beamsectioncoo) < 0) {
MESSAGE("ERROR : write nodes coordinates ...");
goto ERROR;
}
if (MEDmeshElementConnectivityWr(fid, beamsectionname, MED_NO_DT, MED_NO_IT, 0.0, MED_CELL, MED_QUAD4,
MED_NODAL, MED_FULL_INTERLACE, nquad4, beamsectionconnectivity) < 0) {
MESSAGE("ERROR : write cells connectivity ...");
goto ERROR;
}
/* STEP 2 */
/* particle model creation : no support mesh */
strcpy(elementname,MED_PARTICLE_NAME);
if ((geotype = MEDstructElementCr(fid, elementname, elementdim, MED_NO_MESHNAME,
MED_NONE,MED_NONE)) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
ncomp=1;
if (MEDstructElementVarAttCr(fid, elementname,
MED_PARTICLE_LABEL, MED_ATT_INT, ncomp) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
/* ball model creation */
strcpy(elementname,MED_BALL_NAME);
if ((geotype = MEDstructElementCr(fid, elementname, elementdim, ballsupportname,
MED_NODE,MED_NONE)) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
ncomp=1;
if (MEDstructElementVarAttCr(fid, elementname,
MED_BALL_DIAMETER, MED_ATT_FLOAT64, ncomp) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
/* A beam */
strcpy(elementname,MED_BEAM_NAME);
if ((geotype = MEDstructElementCr(fid, elementname, elementdim, beamsupportname,
MED_CELL,MED_SEG2)) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
ncomp=1;
/* a first constant attribute */
if (MEDstructElementConstAttWr(fid, elementname,
MED_BEAM_THICKNESS, MED_ATT_FLOAT64, ncomp,
MED_CELL,(void*) attvalue) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
/* a second constant attribute defined with a profile for the first and the
last segment */
/* create the profile */
if (MEDprofileWr(fid, profilename, profilesize, profile ) < 0) {
MESSAGE("ERROR : create profile ...");
goto ERROR;
}
/* write the constant attribute */
if (MEDstructElementConstAttWithProfileWr(fid,
elementname,
"BEAM_EXTREMITIES_LABELS",
MED_ATT_NAME,
ncomp,
MED_CELL,
profilename,
(void*) attprovalue) < 0) {
MESSAGE("ERROR : creating struct element");
goto ERROR;
}
/* STEP 3 : Computation mesh creation */
/* mesh creation */
if (MEDmeshCr(fid, computmeshname, spacedim, meshdim, MED_UNSTRUCTURED_MESH,
"Computation mesh", "s", MED_SORT_DTIT,
MED_CARTESIAN, axisname, unitname) < 0) {
MESSAGE("ERROR : creating computation mesh ...");
goto ERROR;
}
/* mesh node creation */
nnode = 12;
if (MEDmeshNodeCoordinateWr(fid, computmeshname, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_FULL_INTERLACE, nnode, meshcoo) < 0) {
MESSAGE("ERROR : writing nodes coordinates ...");
goto ERROR;
}
/* 1 beam */
nentity = 1;
SSCRUTE(elementname);
geotype = MEDstructElementGeotype(fid,elementname);
ISCRUTE_int(geotype);
if (MEDmeshElementConnectivityWr(fid,computmeshname, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_STRUCT_ELEMENT, geotype, MED_NODAL,
MED_FULL_INTERLACE, nentity, beamconnectivity) < 0 ) {
MESSAGE("ERROR : beam connectivity ...");
goto ERROR;
}
/* Get the dynamic geometry type of each struct element model.
Then for each type, write the connectivity and variable(s) attribute(s) */
/* 3 particles in the mesh */
strcpy(elementname,MED_PARTICLE_NAME);
geotype = MEDstructElementGeotype(fid,elementname);
nentity = 3;
ISCRUTE_int(geotype);
if (MEDmeshElementConnectivityWr(fid, computmeshname, MED_NO_DT, MED_NO_IT, 0.0,
MED_STRUCT_ELEMENT, geotype , MED_NODAL, MED_FULL_INTERLACE,
nentity, 0) < 0) {
MESSAGE("ERROR : writing particles connectivity ...");
goto ERROR;
}
/* no support mesh => no connectivity, the particles are localized with an association between
the mesh nodes and the label attribute defined in the struct model */
if (MEDmeshStructElementVarAttWr(fid, computmeshname, MED_NO_DT, MED_NO_IT,
geotype, MED_PARTICLE_LABEL,
nentity, labels) < 0 ) {
MESSAGE("ERROR : writing variable attributes ...");
goto ERROR;
}
/* 2 balls */
strcpy(elementname,MED_BALL_NAME);
nentity = 2;
geotype = MEDstructElementGeotype(fid,elementname);
if (MEDmeshElementConnectivityWr(fid,computmeshname, MED_NO_DT, MED_NO_IT, MED_UNDEF_DT,
MED_STRUCT_ELEMENT, geotype, MED_NODAL,
MED_FULL_INTERLACE, nentity, ballconnectivity) < 0 ) {
MESSAGE("ERROR : writing balls connectivity");
goto ERROR;
}
/* variable attribute : write ball diameter */
if (MEDmeshStructElementVarAttWr(fid, computmeshname, MED_NO_DT, MED_NO_IT,
geotype, MED_BALL_DIAMETER,
nentity, balldiameter) < 0 ) {
MESSAGE("ERROR : writing variable attributes ...");
goto ERROR;
}
ret=0;
ERROR:
/* close file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : file closing");
ret=-1;
}
return ret;
}

La routine MEDstructElementInfoByName / msesin permet de récupérer les informations relatives à un modèle d'élément de structure dont on connaît le nom. Un autre mode d'accès en lecture consiste à utiliser la routine MEDnStructElement / msense pour lire le nombre de modèle dans un fichier. Il s'agit ensuite d'itérer sur ces modèles. La routine MEDstructElementInfo / msesei permet de lire à chaque itération les informations relatives à un modèle d'élément de structure. Pour ce qui concerne la lecture des attributs constants, la routine MEDstructElementConstAttInfo / msecai permet de lire les informations relatives à ce type d'attribut et les routines MEDstructElementConstAttRd / mserar, mseiar, msesar permettent de lire les valeurs d'un attribut constant sans et avec un profil. Pour ce qui concerne les attributs variables, la routine MEDstructElementVarAttInfo / msevai permet de lire les informations relatives à ce type d'attribut et les routines MEDmeshStructElementVarAttRd / mmhrar, mmhiar, mmhsar permettent de lire les valeurs d'un attribut variable.

A noter également l'existence : de la routine MEDstructElementName / msesen qui à partir du numéro de type géométrique de l'élément de structure, fournit le nom de cet élément ; de la routine MEDstructElementGeotype / msesgt qui à partir du nom de l'élément renvoie son type. Enfin la routine MEDstructElementAttSizeof / mseasz renvoie la taille en octets du type élémentaire d'un attribut constant ou variable, ce qui permet d'allouer correctement la taille des tableaux pour lire les valeurs des attributs.

La routine MEDsupportMeshInfoByName / msmsni permet de récupérer les informations relatives à un maillage support dont on connaît le nom. Un autre mode d'accès en lecture consiste à utiliser la routine MEDnSupportMesh / msmnsm afin de lire le nombre de maillage support dans un fichier. Il s'agit ensuite d'itérer sur ces maillages support et à chaque itération de lire les informations relative au maillage avec la routine MEDsupportMeshInfo / msmsmi. La lecture des coordonnées des noeuds et de la connectivité des mailles se fait avec les mêmes routines que celles utilisées pour les maillages de calcul.

Ce cas d'utilisation montre comment à partir d'un maillage de calcul, accéder aux modèles d'éléments de structure et aux maillages supports.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#include <string.h>
/*
* StructElement use case 3 : read struct element models in a file from a computation mesh
*/
int main (int argc, char **argv) {
med_idt fid;
med_int nmodels, nsmesh;
int i,j;
char elementname[MED_NAME_SIZE+1]="";
char supportmeshname[MED_NAME_SIZE+1]="";
const char computmeshname[MED_NAME_SIZE+1]="COMPUT_MESH";
med_geometry_type *geotype;
med_entity_type entitype;
med_int elementdim;
med_int nnode,ncell;
med_geometry_type geocelltype;
med_bool anyprofile=0;
med_int nconstatt, *nvaratt=NULL;
char attname[MED_NAME_SIZE+1]="";
char profilename[MED_NAME_SIZE+1]="";
med_attribute_type atttype;
med_int nattcomp;
med_entity_type attentitype;
med_int profilesize;
med_float *value=NULL;
med_int size=0;
med_int meshdim, spacedim;
char description[MED_COMMENT_SIZE+1]="";
char axisname[3*MED_SNAME_SIZE+1]="";
char axisunit[3*MED_SNAME_SIZE+1]="";
med_axis_type axistype;
med_float *coordinates=NULL;
med_bool coordinatechangement;
med_bool geotransformation;
med_int nseg2;
med_int *seg2connectivity=NULL;
med_int nentities=0;
med_sorting_type sortingtype;
med_mesh_type meshtype;
med_int nstep;
char dtunit[MED_SNAME_SIZE+1]="";
char unitname[2*MED_SNAME_SIZE+1]="";
int ret=-1;
/* open file */
fid = MEDfileOpen("UsesCase_MEDstructElement_1.med",MED_ACC_RDONLY);
if (fid < 0) {
MESSAGE("ERROR : file creation ...");
goto ERROR;
}
/*
* ... In this case, we know that the MED file has only one mesh,
* a real code would check ...
*/
/* read mesh informations : mesh dimension, space dimension ... */
if (MEDmeshInfoByName(fid, computmeshname, &spacedim, &meshdim, &meshtype, description,
dtunit, &sortingtype, &nstep, &axistype, axisname, unitname) < 0) {
MESSAGE("ERROR : mesh info ...");
goto ERROR;
}
/* read how many struct element models in the mesh ? */
if ((nmodels = MEDmeshnEntity(fid, computmeshname, MED_NO_DT, MED_NO_IT, MED_STRUCT_ELEMENT, MED_GEO_ALL,
MED_UNDEF_DATATYPE, MED_NO_CMODE,&coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of nodes ...");
goto ERROR;
}
geotype = (med_geometry_type *) malloc(sizeof(med_geometry_type)*nmodels);
nvaratt = (med_int *) malloc(sizeof(med_int)*nmodels);
/* Get the name and the geotype of each struct element model used in the computation mesh.
For each struct element geotype read the connectivity and the attribute(s)
The mesh support may be read if needed.
*/
for (i=0;i<nmodels;i++) {
/* read the geotype */
if (MEDmeshEntityInfo(fid, computmeshname, MED_NO_DT, MED_NO_IT, MED_STRUCT_ELEMENT,i+1,elementname,(geotype+i)) < 0) {
MESSAGE("ERROR : name and type of MED_STRUCT_ELEMENT ...");
goto ERROR;
}
/* read how many MED_STRUCT_ELEMENT of type *(geotype+i) there is in the mesh */
if ((nentities = MEDmeshnEntity(fid, computmeshname, MED_NO_DT, MED_NO_IT, MED_STRUCT_ELEMENT,*(geotype+i),
MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of MED_STRUCT_ELEMENT ...");
goto ERROR;
}
/* read informations about the model */
if (MEDstructElementInfoByName(fid, elementname, geotype+i, &elementdim,
supportmeshname, &entitype, &nnode, &ncell,
&geocelltype, &nconstatt, &anyprofile, nvaratt+i) < 0) {
MESSAGE("ERROR : struct element models information ...");
goto ERROR;
}
/* read support mesh */
/* TODO : Ceci est optionnel dans ce usescase */
if (strcmp(supportmeshname,"")) {
if ( MEDsupportMeshInfoByName(fid, supportmeshname, &spacedim, &meshdim, description,
&axistype, axisname, axisunit) < 0 ) {
MESSAGE("ERROR : read information about mesh support ...");
goto ERROR;
}
ISCRUTE(nnode);
/* read how many nodes in the support mesh */
/* Ceci est optionnel dans ce usescase */
if ((nnode = MEDmeshnEntity(fid, supportmeshname, MED_NO_DT, MED_NO_IT, MED_NODE, MED_NONE,
MED_COORDINATE, MED_NO_CMODE,&coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : read number of nodes ...");
goto ERROR;
}
ISCRUTE(nnode);
/* read support mesh nodes coordinates */
/* Ceci est optionnel dans ce usescase */
coordinates = (med_float*) malloc(sizeof(med_float)*nnode*spacedim);
if (MEDmeshNodeCoordinateRd(fid, supportmeshname, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
coordinates) < 0) {
MESSAGE("ERROR : read nodes coordinates ...");
free(coordinates);
goto ERROR;
}
/* free memory */
free(coordinates);
/* read how many MED_SEG2 cells in the support mesh */
/* Ceci est optionnel dans ce usescase */
if ((nseg2 = MEDmeshnEntity(fid, supportmeshname, MED_NO_DT, MED_NO_IT, MED_CELL,geocelltype,
MED_CONNECTIVITY, MED_NODAL, &coordinatechangement,
&geotransformation)) < 0) {
MESSAGE("ERROR : number of MED_SEG2 ...");
goto ERROR;
}
ISCRUTE(nseg2);
ISCRUTE(ncell);
/* read MED_SEG2 connectivity in the support mesh */
if (nseg2 > 0) {
seg2connectivity = (med_int *) malloc(sizeof(med_int)*nseg2*2);
if (MEDmeshElementConnectivityRd(fid, supportmeshname, MED_NO_DT, MED_NO_IT, MED_CELL,
geocelltype, MED_NODAL, MED_FULL_INTERLACE, seg2connectivity) < 0) {
MESSAGE("ERROR : MED_SEG2 connectivity ...");
free(seg2connectivity);
goto ERROR;
}
free(seg2connectivity);
}
}
/* read constant attribute(s) */
/* Optionnel pour ce usescase (cf. usescase lecture modèle) */
for (j=0; j<nconstatt; j++) {
if ( MEDstructElementConstAttInfo(fid, elementname, j+1,
attname, &atttype, &nattcomp, &attentitype,
profilename, &profilesize) < 0) {
MESSAGE("ERROR : const attribute information ...");
goto ERROR;
}
/* if there is a profile => read the profile, see UsesCase_MEDprofile_2 */
/* memory allocation */
if (profilesize != 0)
size = profilesize*nattcomp*MEDstructElementAttSizeof(atttype);
else
if (attentitype== MED_NODE)
size = nnode*nattcomp*MEDstructElementAttSizeof(atttype);
else
size = ncell*nattcomp*MEDstructElementAttSizeof(atttype);
if ( atttype == MED_ATT_NAME) ++size;
ISCRUTE(size);
value = (med_float *) malloc(size);
/* read attribute(s) value(s) */
if ( MEDstructElementConstAttRd(fid, elementname, attname, (unsigned char *)value ) < 0 ) {
MESSAGE("ERROR : const attribute value ...");
free(value);
goto ERROR;
}
/* memory deallocation */
free(value);
}
/* read variable attribute(s) */
for (j=0; j<*(nvaratt+i); j++) {
/* read informations about the attribute */
if ( MEDstructElementVarAttInfo(fid, elementname, j+1,
attname, &atttype, &nattcomp) < 0) {
MESSAGE("ERROR : var attribute information ...");
goto ERROR;
}
/* memory allocation */
size = nentities*nattcomp*MEDstructElementAttSizeof(atttype);
if ( atttype == MED_ATT_NAME) ++size;
ISCRUTE(size);
value = (med_float *) malloc((size)*sizeof(char));
/* read attribute values */
if (MEDmeshStructElementVarAttRd(fid, computmeshname, MED_NO_DT, MED_NO_IT,
*(geotype+i), attname, value ) < 0) {
MESSAGE("ERROR : read variable attributes values ...");
free(value);
goto ERROR;
}
/* free memory */
free(value);
}
}
ret=0;
ERROR:
/* free memory */
free(geotype);
free(nvaratt);
/* close file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : file closing ...");
ret=-1;
}
return ret;
}

# Ecriture et lecture en parallèle par la décomposition de domaine

En vue de calculs parallèles, le domaine de calcul est subdivisé en sous-domaines où se répartissent les maillages. Classiquement, chaque sous-domaine sera traité par un seul processeur qui aura uniquement accès aux données des autres sous-domaines par l'intermédiaire de messages.

Du point de vue du stockage, un maillage distribué a la même structure qu'un maillage MED classique mais ses composantes (entités géométrique, familles, groupes) peuvent être réparties sur plusieurs sous-domaines affectés à des processeurs disjoints. Lors de cette distribution certains sommets, faces, arêtes ou mailles se retrouvent sur la frontière commune de deux sous-domaines. L'ensemble de ces éléments communs à deux sous-domaines constitue un joint. Dans un cadre très général, les éléments communs à deux sous-domaines peuvent apparaître comme : la jointure de deux maillages qui se correspondent parfaitement (on parle alors de raccordement conforme), la jointure de deux maillages de pavage différent (raccordement non conforme), le recouvrement de deux maillages qu'il soit conforme ou non.

La notion de joint est assez générale pour permettre de stocker ces trois types d'interface. Elle consiste à donner la liste des couples des numéros correspondant des entités en regard vues du domaine local et vues du domaine distant.

Un maillage distribué est donc entièrement déterminé par la donnée des maillages affectés à chacun des sous-domaines, par la définition de « joints » - raccord entre les maillages de sous-domaines voisins, par une numérotation globale optionnelle des entités.

Comme les maillages sont distribués, les données MED s'y rattachant peuvent être stockées dans plusieurs fichiers. La liste de ces fichiers est rassemblée dans un fichier maître au format ASCII. Ce fichier permet de repérer où se trouvent stockées les parties de maillages distribuées correspondant à chaque sous-domaine. Il contient : un entête d'identification ; le nombre de sous-domaines sur lesquels sont distribués les maillages ; les informations nécessaires pour repérer les parties de maillages affectées à chaque sous-domaine. Pour ce faire, il y a autant de lignes que de parties de maillages distribués. Chaque ligne se compose : du nom de maillage global, du numéro de sous-domaine concerné, du nom de maillage local correspondant au maillage global sur ce sous-domaine, du nom de la machine hébergeant le fichier MED contenant ces informations (ce nom peut éventuellement être une adresse IP de la machine et ne comportera pas de blanc), du chemin absolu ou relatif menant à ce fichier

Le fichier ASCII sera au format unix, et le retour à la ligne est un caractère ASCII 10 (caractère Carriage Return seul sans caractère Line Feed comme sous windows). Dans les chemins, les sous répertoires seront délimités par le caractère '/'. Toute ligne commençant par '#' sera ignorée par la librairie (commentaires). Mais un '#' en cours de ligne ne sera pas interprété comme un commentaire.
Les fichiers MED correspondant à chaque sous-domaine sont repérés par leur chemin absolu ou relatif dans le système de fichier. Dans le cas relatif, l'accès aux fichiers depuis la librairie pourra dépendre de la machine ou du système d'exploitation sur lequel on s'exécute. A charge de l'utilisateur de vérifier l'interprétation cohérente des chemins de fichiers relatifs.

Voici un exemple de fichier maître, décrivant la répartition de 2 maillages VIT et TEMP sur 4 sous domaines disjoints. Le calcul s'effectue sur un solide (où seule est définie la température) baignée d'un liquide (ou sont définies les vitesses et températures)

    # MED Fichier v3.0
    #
    # Nombre de sous-domaines
    4
    #
    # fichiers MED par sous-domaine
    VIT 1 VIT_1 localhost /absolute/path/fichier_dom_1
    VIT 2 VIT_2 localhost /absolute/path/fichier_dom_2
    TEMP 1 TEMP_1 localhost /absolute/path/fichier_dom_1
    TEMP 2 TEMP_2 localhost /absolute/path/fichier_dom_2
    TEMP 3 TEMP_3 localhost /absolute/path/fichier_dom_3
    TEMP 4 TEMP_4 localhost /absolute/path/fichier_dom_4

La création ou la transformation du fichier maître est à la charge du découpeur. On suppose que ce fichier est cohérent dans l'utilisation de la librairie.

A l'écriture, les routines disponibles permettent de : créer un joint dans un maillage (MEDsubdomainJointCr / msdjcr) ; écrire un tableau de correspondances entre binômes d'entités du maillage dans un joint (MEDsubdomainCorrespondenceWr / msdcrw) ; écrire la numérotation globale associée à un type d'entité pour la repérer sur le domaine global (MEDmeshGlobalNumberWr / mmhgnw).

A la lecture, les routines disponibles permettent de : lire le nombre de joints dans un maillage (MEDnSubdomainJoint / msdnjn) ; lire les informations concernant un joint (MEDsubdomainJointInfo / msdjni), lire le nombre de couple en correspondance d'un type donné dans un joint (MEDsubdomainComputingStepInfo / msdcsi) ; lire le nombre d'entités en correspondance dans un joint pour un couple d'entités et une étape de calcul donnés (MEDsubdomainCorrespondenceSize / msdcsz); lire les informations sur les couples d'entités en correspondance dans un joint pour une étape de calcul donnée (MEDsubdomainCorrespondenceSizeInfo / msdszi) ; lire un tableau de correspondances entre binômes d'entités du maillage dans un joint (MEDsubdomainCorrespondenceRd / msdcrr) ; lire la numérotation globale associée à un type d'entité pour la repérer sur le domaine global (MEDmeshGlobalNumberRd / mmhgnr).

Les cas d'utilisation suivant illustrent comment écrire et lire des maillages avec des joints et un système de numérotation global.

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : test29.c
*
* - Description : ecriture d'un joint dans un maillage MED
*
*****************************************************************************/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#ifdef DEF_LECT_ECR
#define MODE_ACCES MED_ACC_RDWR
#elif DEF_LECT_AJOUT
#define MODE_ACCES MED_ACC_RDEXT
#else
#define MODE_ACCES MED_ACC_CREAT
#endif
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_NAME_SIZE+1]= "maa1";
char jnt[MED_NAME_SIZE+1] = "joint";
char des_jnt[MED_COMMENT_SIZE+1] = "joint avec le sous-domaine 2";
char maa_distant[MED_NAME_SIZE+1]= "maa1";
med_int dom_dist = 2;
med_int mdim = 3;
med_int ncor = 3;
med_int cor[6] = {1,2,3,4,5,6};
med_int cor2[6] = {10,20,30,40,50,60};
char nomcoo[3*MED_SNAME_SIZE+1] = "x y z ";
char unicoo[3*MED_SNAME_SIZE+1] = "cm cm cm ";
/* Creation du fichier "test29.med" */
if ((fid = MEDfileOpen("test29.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test29.med");
return -1;
}
if (MEDmeshCr( fid, maa, mdim, mdim, MED_UNSTRUCTURED_MESH,
"un maillage pour test29","s", MED_SORT_DTIT,
MED_CARTESIAN, nomcoo, unicoo) < 0) {
MESSAGE("Erreur a la creation du maillage : "); SSCRUTE(maa);
return -1;
}
/* Creation du joint */
if (MEDsubdomainJointCr(fid,maa,jnt,des_jnt,dom_dist,maa_distant) < 0) {
MESSAGE("Erreur a la creation du joint");
return -1;
}
/* Ecriture de la correspondance Noeud, Noeud */
if (MEDsubdomainCorrespondenceWr(fid,maa,jnt,MED_NO_DT,MED_NO_IT,
MED_NODE,MED_NONE,MED_NODE,MED_NONE,ncor,cor) < 0) {
MESSAGE("Erreur a l'ecriture du tableau des correspondances (noeud,noeud)");
return -1;
}
/* Ecriture de la correspondance Noeud Maille */
if (MEDsubdomainCorrespondenceWr(fid,maa,jnt,MED_NO_DT,MED_NO_IT,
MED_NODE,MED_NONE,MED_CELL,MED_TRIA3,ncor,cor2) < 0) {
MESSAGE("Erreur a l'ecriture du tableau des correspondances (noeud,maille TRIA3)");
return -1;
}
/* Fermeture du fichier */
if (MEDfileClose(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
return 0;
}
/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : test30.c
*
* - Description : lecture des joints d'un maillage MED.
*
*****************************************************************************/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#ifdef DEF_LECT_ECR
#define MODE_ACCES MED_ACC_RDWR
#elif DEF_LECT_AJOUT
#define MODE_ACCES MED_ACC_RDEXT
#else
#define MODE_ACCES MED_ACC_CREAT
#endif
int afficheCorres(med_idt fid, char *maa, char *jnt,
med_entity_type typ_ent_local, med_geometry_type typ_geo_local,
med_entity_type typ_ent_distant, med_geometry_type typ_geo_distant,
char *type);
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
char maa[MED_NAME_SIZE+1],maa_dist[MED_NAME_SIZE+1];
med_int mdim,sdim;
med_int njnt,ncor,ndom,nc;
char jnt[MED_NAME_SIZE+1],corr[MED_NAME_SIZE+1];
char des[MED_COMMENT_SIZE+1];
char dtunit[MED_SNAME_SIZE+1]="";
char nomcoo[3*MED_SNAME_SIZE+1];
char unicoo[3*MED_SNAME_SIZE+1];
med_axis_type rep;
med_mesh_type type;
med_sorting_type sort;
med_int nstep=0,njstep=0,nodtitncor=0,nentity=0;
med_entity_type typ_ent_local,typ_ent_distant;
med_geometry_type typ_geo_local,typ_geo_distant;
int i,j,k;
if (argc != 2) {
MESSAGE("Il faut passer un fichier MED en paramètre");
return -1;
}
/* Ouverture du fichier passe en argument en lecture seule */
if ((fid = MEDfileOpen(argv[1],MED_ACC_RDONLY)) < 0) {
MESSAGE("Erreur à l'ouverture du fichier : "); SSCRUTE(argv[1]);
return -1;
}
if ((sdim=MEDmeshnAxis(fid, 1)) <0) {
MESSAGE("Erreur à la lecture de la dimension de l'espace du maillage :");
SSCRUTE(maa);
return -1;
}
/* Lecture des infos concernant le premier maillage */
if ( MEDmeshInfo( fid, 1, maa, &sdim, &mdim, &type, des, dtunit, &sort,
&nstep, &rep, nomcoo,unicoo) < 0 ) {
MESSAGE("Erreur a la lecture des informations sur le maillage : ");SSCRUTE(maa);
return -1;
} else {
printf("Maillage de nom : |%s| , de dimension : "IFORMAT" , et de type %d\n",maa,mdim,type);
printf("\t -Dimension de l'espace : "IFORMAT"\n",sdim);
printf("\t -Description du maillage : |%s|\n",des);
printf("\t -Noms des axes : |%s|\n",nomcoo);
printf("\t -Unités des axes : |%s|\n",unicoo);
printf("\t -Type de repère : %d\n",rep);
printf("\t -Nombre d'étapes de calcul : "IFORMAT"\n",nstep);
printf("\t -Unité des dates : |%s|\n\n",dtunit);
}
/* Lecture du nombre de joints */
if ((njnt = MEDnSubdomainJoint(fid,maa)) < 0) {
MESSAGE("Erreur a la lecture du nombre de joints");
return -1;
}
printf("Nombre de joints : "IFORMAT" \n",njnt);
/* Lecture de tous les joints du maillage */
for (i = 0;i<njnt;i++) {
printf("Joint numero : %d \n",i+1);
/* Lecture des infos sur le joints */
if (MEDsubdomainJointInfo(fid,maa,i+1,jnt,des,&ndom,maa_dist,&njstep,&nodtitncor) < 0) {
MESSAGE("Erreur a la lecture du joint d'indice");
ISCRUTE_int(i+1);
return -1;
}
printf("Nom du joint: |%s| \n",jnt);
printf("Description du joint : |%s| \n",des);
printf("Domaine en regard : "IFORMAT" \n",ndom);
printf("Maillage distant : |%s| \n",maa_dist);
printf("Nombre d'étapes de calcul : "IFORMAT" \n",njstep);
printf("Nombre de correspondance pour (NO_DT,NO_IT) : "IFORMAT" \n",nodtitncor);
/* lecture des correspondances une par une
en connaissant leur type a priori */
/* Lecture de la correspondance Noeud Noeud */
afficheCorres(fid,maa,jnt,MED_NODE,0,MED_NODE,0,"noeud/noeud");
/* Lecture de la correspondance Noeud Maille */
afficheCorres(fid,maa,jnt,MED_NODE,0,MED_CELL,MED_TRIA3,"noeud/TRIA3");
/* lecture des correspondances une par une
sans connaitre leur type a priori
-> utilisation de la fonction MEDjointTypeCorres */
ncor=1;
while ( ncor <= nodtitncor ) {
ISCRUTE(ncor);
if ( MEDsubdomainCorrespondenceSizeInfo(fid,maa,jnt,MED_NO_DT,MED_NO_IT,ncor,
&typ_ent_local,&typ_geo_local,&typ_ent_distant,&typ_geo_distant,
&nentity) < 0 ) {
MESSAGE("Erreur a la lecture des infos sur le nombre d'entite en regard");
return -1;
}
/* Lecture de la correspondance Noeud Noeud */
afficheCorres(fid,maa,jnt,typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,"------");
ncor++;
}
}
/* Fermeture du fichier */
if (MEDfileClose(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier ");
return -1;
}
return ret;
}
int afficheCorres(med_idt fid, char *maa, char *jnt,
med_entity_type typ_ent_local, med_geometry_type typ_geo_local,
med_entity_type typ_ent_distant, med_geometry_type typ_geo_distant,
char *type)
{
med_int nc;
med_int *cortab;
int k,ncor,ret=0;
ISCRUTE_int(typ_ent_local);ISCRUTE_int(typ_geo_local);
ISCRUTE_int(typ_ent_distant);ISCRUTE_int(typ_geo_distant);
if ( MEDsubdomainCorrespondenceSize(fid,maa,jnt,MED_NO_DT,MED_NO_IT,
typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,
&nc) < 0) {
MESSAGE("Erreur a la lecture des infos sur le nombre d'entite en regard de type");
SSCRUTE(type);
return -1;
}
printf("nb de couples d'entites en regard |%s|: "IFORMAT" \n",type,nc);
if (nc > 0) {
cortab = (med_int*) malloc(sizeof(med_int)*nc*2);
if ((ret=MEDsubdomainCorrespondenceRd(fid,maa,jnt,MED_NO_DT,MED_NO_IT,
typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,
cortab)) < 0) {
MESSAGE("Erreur a la lecture des correspondances sur ");
SSCRUTE(type);
ret = -1;
}
if (ret == 0)
for (k=0;k<nc;k++)
printf("Correspondance %d : "IFORMAT" et "IFORMAT" \n",k+1,*(cortab+2*k),
*(cortab+2*k+1));
free(cortab);
}
return ret;
}

/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : test31.c
*
* - Description : ecriture d'une numerotation globale dans un maillage MED
*
*****************************************************************************/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#ifdef DEF_LECT_ECR
#define MODE_ACCES MED_ACC_RDWR
#elif DEF_LECT_AJOUT
#define MODE_ACCES MED_ACC_RDEXT
#else
#define MODE_ACCES MED_ACC_CREAT
#endif
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
med_int mdim,sdim;
/* nom du maillage de longueur maxi MED_NAME_SIZE */
char maa[MED_NAME_SIZE+1];
/* le nombre de noeuds */
med_int nnoe = 0;
/* table des numeros global */
med_int *numglobalnoe=NULL;
/* variable de stockage pour reperer le maillage */
med_int i;
char des[MED_COMMENT_SIZE+1]="";
char dtunit[MED_SNAME_SIZE+1]="";
char nomcoo[3*MED_SNAME_SIZE+1]="";
char unicoo[3*MED_SNAME_SIZE+1]="";
med_axis_type rep;
med_mesh_type type;
med_sorting_type sort;
med_int nstep=0;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
if (argc != 2) {
MESSAGE("Il faut passer un fichier MED en param�tre");
return -1;
}
/* Ouverture du fichier passe en argument */
if ((fid = MEDfileOpen(argv[1],MED_ACC_RDWR)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier : "); SSCRUTE(argv[1]);
return -1;
}
if ((sdim=MEDmeshnAxis(fid, 1)) <0) {
MESSAGE("Erreur � la lecture de la dimension de l'espace du maillage :");
SSCRUTE(maa);
return -1;
}
/* Lecture des infos concernant le premier maillage */
if ( MEDmeshInfo( fid, 1, maa, &sdim, &mdim, &type, des, dtunit, &sort,
&nstep, &rep, nomcoo,unicoo) < 0 ) {
MESSAGE("Erreur a la lecture des informations sur le maillage : ");SSCRUTE(maa);
return -1;
} else {
printf("Maillage de nom : |%s| , de dimension : "IFORMAT" , et de type %d\n",maa,mdim,type);
printf("\t -Dimension de l'espace : "IFORMAT"\n",sdim);
printf("\t -Description du maillage : %s\n",des);
printf("\t -Noms des axes : %s\n",nomcoo);
printf("\t -Unit�s des axes : %s\n",unicoo);
printf("\t -Type de rep�re : %d\n",rep);
printf("\t -Nombre d'�tapes de calcul : "IFORMAT"\n",nstep);
printf("\t -Unit� des dates : %s\n\n",dtunit);
}
/* Lecture du nombre de noeuds */
if ( (nnoe = MEDmeshnEntity(fid,maa,MED_NO_DT,MED_NO_IT,
MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,
&chgt,&trsf)) < 0) {
MESSAGE("Erreur a la lecture du nombre de noeuds ");
return -1;
}
printf("Nombre de noeuds : "IFORMAT" \n",nnoe);
/* Allocations memoires */
/* table de la numerotation globale
profil : (nombre de noeuds ) */
if (nnoe > 0) {
numglobalnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
for (i=0;i<nnoe;i++) {
numglobalnoe[i]=i+100;
}
}
/* ecriture de la numerotation globale */
if (MEDmeshGlobalNumberWr(fid,maa,MED_NO_DT,MED_NO_IT,MED_NODE,MED_NONE,nnoe,numglobalnoe)<0) {
MESSAGE("Erreur a l''ecriture de la numerotation globale");
return -1;
}
free(numglobalnoe);
/* Fermeture du fichier */
if (MEDfileClose(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
return 0;
}
/* This file is part of MED.
*
* COPYRIGHT (C) 1999 - 2021 EDF R&D, CEA/DEN
* MED is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MED is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with MED. If not, see <http://www.gnu.org/licenses/>.
*/
/******************************************************************************
* - Nom du fichier : test32.c
*
* - Description : lecture nominale d'une numerotation globale dans un maillage MED
*
*****************************************************************************/
#include <med.h>
#define MESGERR 1
#include <med_utils.h>
#ifdef DEF_LECT_ECR
#define MODE_ACCES MED_ACC_RDWR
#elif DEF_LECT_AJOUT
#define MODE_ACCES MED_ACC_RDEXT
#else
#define MODE_ACCES MED_ACC_CREAT
#endif
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
med_int mdim,sdim;
char maa[MED_NAME_SIZE+1];
/* le nombre de noeuds */
med_int nnoe = 0;
/* table des numeros global */
med_int *numglobalnoe=NULL;
/* variable de stockage pour reperer le maillage */
med_int i;
char des[MED_COMMENT_SIZE+1]="";
char dtunit[MED_SNAME_SIZE+1]="";
char nomcoo[3*MED_SNAME_SIZE+1]="";
char unicoo[3*MED_SNAME_SIZE+1]="";
med_axis_type rep;
med_mesh_type type;
med_sorting_type sort;
med_int nstep=0;
med_bool chgt=MED_FALSE,trsf=MED_FALSE;
if (argc != 2) {
MESSAGE("Il faut passer un fichier MED en param�tre");
return -1;
}
/* Ouverture du fichier passe en argument */
if ((fid = MEDfileOpen(argv[1],MED_ACC_RDWR)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier : "); SSCRUTE(argv[1]);
return -1;
}
if ((sdim=MEDmeshnAxis(fid, 1)) <0) {
MESSAGE("Erreur � la lecture de la dimension de l'espace du maillage :");
SSCRUTE(maa);
return -1;
}
/* Lecture des infos concernant le premier maillage */
if ( MEDmeshInfo( fid, 1, maa, &sdim, &mdim, &type, des, dtunit, &sort,
&nstep, &rep, nomcoo,unicoo) < 0 ) {
MESSAGE("Erreur a la lecture des informations sur le maillage : ");SSCRUTE(maa);
return -1;
} else {
printf("Maillage de nom : |%s| , de dimension : "IFORMAT" , et de type %d\n",maa,mdim,type);
printf("\t -Dimension de l'espace : "IFORMAT"\n",sdim);
printf("\t -Description du maillage : %s\n",des);
printf("\t -Noms des axes : %s\n",nomcoo);
printf("\t -Unit�s des axes : %s\n",unicoo);
printf("\t -Type de rep�re : %d\n",rep);
printf("\t -Nombre d'�tapes de calcul : "IFORMAT"\n",nstep);
printf("\t -Unit� des dates : %s\n\n",dtunit);
}
/* Lecture du nombre de noeuds */
if ( (nnoe = MEDmeshnEntity(fid,maa,MED_NO_DT,MED_NO_IT,
MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,
&chgt,&trsf)) < 0) {
MESSAGE("Erreur a la lecture du nombre de noeuds ");
return -1;
}
printf("Nombre de noeuds : "IFORMAT" \n",nnoe);
/* Allocations memoires */
/* table de la numerotation globale
profil : (nombre de noeuds ) */
if (nnoe > 0) {
numglobalnoe = (med_int*) malloc(sizeof(med_int)*nnoe);
}
/* lecture de la numerotation globale attachee aux noeuds*/
if (MEDmeshGlobalNumberRd(fid,maa,MED_NO_DT,MED_NO_IT,MED_NODE,MED_NONE,numglobalnoe)<0) {
MESSAGE("Erreur a la lecture de de la numerotation globale");
return -1;
}
/* ecriture a l'ecran des resultats */
for (i=0;i<nnoe;i++)
printf("Numero global du noeud "IFORMAT" : "IFORMAT" \n",i+1,numglobalnoe[i]);
free(numglobalnoe);
/* Fermeture du fichier */
if (MEDfileClose(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier ");
return -1;
}
return 0;
}

MED_CARTESIAN
Definition: med.h:258
MED_NO_GROUP
#define MED_NO_GROUP
Definition: med.h:289
MED_TRIA3
#define MED_TRIA3
Definition: med.h:203
MED_FULL_INTERLACE
Definition: med.h:96
MED_BALL_DIAMETER
#define MED_BALL_DIAMETER
Definition: med.h:460
MEDstructElementConstAttWr
MEDC_EXPORT med_err MEDstructElementConstAttWr(const med_idt fid, const char *const modelname, const char *const constattname, const med_attribute_type constatttype, const med_int ncomponent, const med_entity_type sentitytype, const void *const value)
Cette routine définit un attribut caractéristique constant d'un modèle d'éléments de structure.
Definition: MEDstructElementConstAttWr.c:43
MEDmeshPolyhedronRd
MEDC_EXPORT med_err MEDmeshPolyhedronRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_connectivity_mode cmode, med_int *const faceindex, med_int *const nodeindex, med_int *const connectivity)
Cette routine permet la lecture dans un maillage des connectivités de polyèdres.
Definition: MEDmeshPolyhedronRd.c:45
MED_SORT_DTIT
Definition: med.h:309
MED_PARTICLE_LABEL
#define MED_PARTICLE_LABEL
Definition: med.h:459
MEDsubdomainJointInfo
MEDC_EXPORT med_err MEDsubdomainJointInfo(const med_idt fid, const char *const meshname, const int jointit, char *const jointname, char *const description, med_int *const domainnumber, char *const remotemeshname, med_int *const nstep, med_int *const nocstpncorrespondence)
Cette routine permet de lire les informations sur un joint dans un maillage.
Definition: MEDsubdomainJointInfo.c:45
MED_COMMENT_SIZE
#define MED_COMMENT_SIZE
Definition: med.h:79
MEDmeshNodeCoordinateWithProfileWr
MEDC_EXPORT med_err MEDmeshNodeCoordinateWithProfileWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_storage_mode storagemode, const char *const profilename, const med_switch_mode switchmode, const med_int dimselect, const med_int nentity, const med_float *const coordinates)
Cette routine permet d'écrire dans un maillage le tableau des coordonnées des noeuds,...
Definition: MEDmeshNodeCoordinateWithProfileWr.c:46
MEDmeshPolyhedronWr
MEDC_EXPORT med_err MEDmeshPolyhedronWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_entity_type entitype, const med_connectivity_mode cmode, const med_int faceindexsize, const med_int *const faceindex, const med_int nodeindexsize, const med_int *const nodeindex, const med_int *const connectivity)
Cette routine permet l'écriture dans un maillage des connectivités de polyèdres.
Definition: MEDmeshPolyhedronWr.c:47
MEDsubdomainJointCr
MEDC_EXPORT med_err MEDsubdomainJointCr(const med_idt fid, const char *const localmeshname, const char *const jointname, const char *const description, const med_int domainnumber, const char *const remotemeshname)
Cette routine permet de créer un joint dans un maillage.
Definition: MEDsubdomainJointCr.c:43
MEDmeshCr
MEDC_EXPORT med_err MEDmeshCr(const med_idt fid, const char *const meshname, const med_int spacedim, const med_int meshdim, const med_mesh_type meshtype, const char *const description, const char *const dtunit, const med_sorting_type sortingtype, const med_axis_type axistype, const char *const axisname, const char *const axisunit)
Cette routine permet de créer un maillage dans un fichier.
Definition: MEDmeshCr.c:45
MEDmeshnEntity
MEDC_EXPORT med_int MEDmeshnEntity(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_data_type datatype, const med_connectivity_mode cmode, med_bool *const changement, med_bool *const transformation)
Cette routine permet de lire le nombre d'entités dans un maillage pour une étape de calcul donnée.
Definition: MEDmeshnEntity.c:44
MEDmeshComputationStepInfo
MEDC_EXPORT med_err MEDmeshComputationStepInfo(const med_idt fid, const char *const meshname, const int csit, med_int *const numdt, med_int *const numit, med_float *const dt)
Cette routine permet de lire les informations relatives à une étape de calcul d'un maillage.
Definition: MEDmeshComputationStepInfo.c:38
MEDfileOpen
MEDC_EXPORT med_idt MEDfileOpen(const char *const filename, const med_access_mode accessmode)
Ouverture d'un fichier MED.
Definition: MEDfileOpen.c:42
med_geometry_type
int med_geometry_type
Definition: med.h:194
MED_SNAME_SIZE
#define MED_SNAME_SIZE
Definition: med.h:82
MEDstructElementConstAttWithProfileWr
MEDC_EXPORT med_err MEDstructElementConstAttWithProfileWr(const med_idt fid, const char *const modelname, const char *const constattname, const med_attribute_type constatttype, const med_int ncomponent, const med_entity_type sentitytype, const char *const profilename, const void *const value)
Cette routine définit un attribut caractéristique constant d'un modèle d'éléments de structure.
Definition: MEDstructElementConstAttWithProfileWr.c:44
MED_NODAL
Definition: med.h:255
MEDmeshGlobalNumberRd
MEDC_EXPORT med_err MEDmeshGlobalNumberRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitytype, const med_geometry_type geotype, med_int *const number)
Cette routine permet la lecture d'une numérotation globale sur un maillage pour un type d'entité,...
Definition: MEDmeshGlobalNumberRd.c:40
MED_PARTICLE_NAME
#define MED_PARTICLE_NAME
Definition: med.h:454
ISCRUTE_int
#define ISCRUTE_int(entier)
Definition: med_utils.h:314
MED_NO_GEOTYPE
#define MED_NO_GEOTYPE
Definition: med.h:232
med_idt
hid_t med_idt
Definition: med.h:331
MED_SEG2
#define MED_SEG2
Definition: med.h:200
MED_ACC_RDONLY
Definition: med.h:120
afficheCorres
int afficheCorres(med_idt fid, char *maa, char *jnt, med_entity_type typ_ent_local, med_geometry_type typ_geo_local, med_entity_type typ_ent_distant, med_geometry_type typ_geo_distant, char *type)
Definition: test30.c:167
MEDsubdomainCorrespondenceSizeInfo
MEDC_EXPORT med_err MEDsubdomainCorrespondenceSizeInfo(const med_idt fid, const char *const meshname, const char *const jointname, const med_int numdt, const med_int numit, const int corit, med_entity_type *const localentitytype, med_geometry_type *const localgeotype, med_entity_type *const remoteentitytype, med_geometry_type *const remotegeotype, med_int *const nentity)
Cette routine permet de lire les informations sur les couples d'entités en correspondance dans un joi...
Definition: MEDsubdomainCorrespondenceSizeInfo.c:48
MEDmeshNodeCoordinateTrsfRd
MEDC_EXPORT med_err MEDmeshNodeCoordinateTrsfRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float *const coordinatetrsf)
Cette routine lit les paramètres de translation rotation à appliquer aux noeuds de l'étape de calcul ...
Definition: MEDmeshNodeCoordinateTrsfRd.c:40
MED_STRUCT_ELEMENT
Definition: med.h:144
med_err
herr_t med_err
Definition: med.h:332
MEDsubdomainCorrespondenceSize
MEDC_EXPORT med_err MEDsubdomainCorrespondenceSize(const med_idt fid, const char *const meshname, const char *const jointname, const med_int numdt, const med_int numit, const med_entity_type localentitytype, const med_geometry_type localgeotype, const med_entity_type remoteentitytype, const med_geometry_type remotegeotype, med_int *const nentity)
Cette routine permet la lecture du nombre d'entités en correspondance dans un joint pour un couple d'...
Definition: MEDsubdomainCorrespondenceSize.c:47
med_sorting_type
med_sorting_type
Definition: med.h:309
med_entity_type
med_entity_type
Definition: med.h:143
MED_NO_CMODE
Definition: med.h:255
MEDmeshStructElementVarAttWr
MEDC_EXPORT med_err MEDmeshStructElementVarAttWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_geometry_type mgeotype, const char *const varattname, const med_int nentity, const void *const value)
Cette routine écrit les valeurs d'un attribut caractéristique variable sur les éléments de structure ...
Definition: MEDmeshStructElementVarAttWr.c:42
MED_FALSE
Definition: med.h:260
MEDequivalenceCorrespondenceSize
MEDC_EXPORT med_err MEDequivalenceCorrespondenceSize(const med_idt fid, const char *const meshname, const char *const equivname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, med_int *const nentity)
Cette routine permet de lire le nombre de correspondances dans une équivalence pour une étape de calc...
Definition: MEDequivalenceCorrespondenceSize.c:41
MED_CELL
Definition: med.h:143
MEDfileCommentWr
MEDC_EXPORT med_err MEDfileCommentWr(const med_idt fid, const char *const comment)
Ecriture d'un descripteur dans un fichier MED.
Definition: MEDfileCommentWr.c:34
MED_BALL_NAME
#define MED_BALL_NAME
Definition: med.h:455
MEDsubdomainCorrespondenceRd
MEDC_EXPORT med_err MEDsubdomainCorrespondenceRd(const med_idt fid, const char *const meshname, const char *const jointname, const med_int numdt, const med_int numit, const med_entity_type localentitytype, const med_geometry_type localgeotype, const med_entity_type remoteentitytype, const med_geometry_type remotegeotype, med_int *const correspondence)
Cette routine permet la lecture d'une correspondance dans un joint pour un type de couple d'entité en...
Definition: MEDsubdomainCorrespondenceRd.c:46
MEDnEquivalence
MEDC_EXPORT med_int MEDnEquivalence(const med_idt fid, const char *const meshname)
Cette routine permet de lire le nombre d'équivalence dans un fichier.
Definition: MEDnEquivalence.c:36
MESSAGE
#define MESSAGE(chaine)
Definition: med_utils.h:324
MED_ATT_FLOAT64
Definition: med.h:173
MEDmeshPolygonWr
MEDC_EXPORT med_err MEDmeshPolygonWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_entity_type entitype, const med_connectivity_mode cmode, const med_int indexsize, const med_int *const polyindex, const med_int *const connectivity)
Cette routine permet l'écriture des connectivités de polygones.
Definition: MEDmeshPolygonWr.c:45
MEDmeshEntityInfo
MEDC_EXPORT med_err MEDmeshEntityInfo(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const int geotypeit, char *const geotypename, med_geometry_type *const geotype)
Cette routine indique de façon itérative les types géométriques disponibles dans un maillage.
Definition: MEDmeshEntityInfo.c:41
med_int
int med_int
Definition: med.h:342
MED_UNDEF_DATATYPE
Definition: med.h:152
MEDsubdomainCorrespondenceWr
MEDC_EXPORT med_err MEDsubdomainCorrespondenceWr(const med_idt fid, const char *const meshname, const char *const jointname, const med_int numdt, const med_int numit, const med_entity_type localentitytype, const med_geometry_type localgeotype, const med_entity_type remoteentitytype, const med_geometry_type remotegeotype, const med_int nentity, const med_int *const correspondence)
Cette routine permet l'écriture d'une correspondance dans un joint pour un type de couple d'entité en...
Definition: MEDsubdomainCorrespondenceWr.c:47
MED_ACC_RDWR
Definition: med.h:121
med_attribute_type
med_attribute_type
Definition: med.h:173
MEDfamilyCr
MEDC_EXPORT med_err MEDfamilyCr(const med_idt fid, const char *const meshname, const char *const familyname, const med_int familynumber, const med_int ngroup, const char *const groupname)
Cette routine permet la création d'une famille portant sur les entités d'un maillage.
Definition: MEDfamilyCr.c:40
MED_GET_CELL_GEOMETRY_TYPE
med_geometry_type MED_GET_CELL_GEOMETRY_TYPE[MED_N_CELL_FIXED_GEO+2]
Definition: MEDiterators.c:55
MED_NO_MESHNAME
#define MED_NO_MESHNAME
Definition: med.h:270
med.h
ISCRUTE
#define ISCRUTE(entier)
Definition: med_utils.h:313
med_bool
med_bool
Definition: med.h:260
med_float
double med_float
Definition: med.h:336
MED_GEO_ALL
#define MED_GEO_ALL
Definition: med.h:236
IFORMAT
#define IFORMAT
Definition: med_utils.h:145
MED_POINT1
#define MED_POINT1
Definition: med.h:198
MED_NO_DT
#define MED_NO_DT
Definition: med.h:320
MED_NONE
#define MED_NONE
Definition: med.h:231
MED_CONNECTIVITY
Definition: med.h:149
MEDmeshElementConnectivityRd
MEDC_EXPORT med_err MEDmeshElementConnectivityRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_connectivity_mode cmode, const med_switch_mode switchmode, med_int *const connectivity)
Cette routine permet de lire dans un maillage le tableau des connectivités pour un type géométrique d...
Definition: MEDmeshElementConnectivityRd.c:40
MED_BEAM_NAME
#define MED_BEAM_NAME
Definition: med.h:456
MED_INDEX_FACE
Definition: med.h:151
MED_NODE
Definition: med.h:143
MEDequivalenceCorrespondenceRd
MEDC_EXPORT med_err MEDequivalenceCorrespondenceRd(const med_idt fid, const char *const meshname, const char *const equivname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, med_int *const correspondence)
Cette routine permet de lire un tableau de correspondances entre les entités d'un maillage dans une é...
Definition: MEDequivalenceCorrespondenceRd.c:41
MEDmeshNodeCoordinateTrsfWr
MEDC_EXPORT med_err MEDmeshNodeCoordinateTrsfWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_float *const coordinatetrsf)
Cette routine définit les paramètres de translation rotation à appliquer aux noeuds de l'étape de cal...
Definition: MEDmeshNodeCoordinateTrsfWr.c:41
MEDstructElementConstAttRd
MEDC_EXPORT med_err MEDstructElementConstAttRd(const med_idt fid, const char *const modelname, const char *const constattname, void *const value)
Cette routine lit la valeur d'un attribut caractéristique constant d'un modèle d'éléments de structur...
Definition: MEDstructElementConstAttRd.c:42
MEDmeshnAxis
MEDC_EXPORT med_int MEDmeshnAxis(const med_idt fid, const int meshit)
Cette routine permet de lire dans un maillage le nombre d'axes du repère des coordonnées des noeuds.
Definition: MEDmeshnAxis.c:35
MED_N_CELL_FIXED_GEO
#define MED_N_CELL_FIXED_GEO
Definition: med.h:239
MED_ATT_NAME
Definition: med.h:175
med_mesh_type
med_mesh_type
Definition: med.h:131
MODE_ACCES
#define MODE_ACCES
Definition: 3.0.8/test10.c:34
SSCRUTE
#define SSCRUTE(chaine)
Definition: med_utils.h:323
MEDmeshNodeCoordinateWr
MEDC_EXPORT med_err MEDmeshNodeCoordinateWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_switch_mode switchmode, const med_int nentity, const med_float *const coordinates)
Cette routine permet d'écrire dans un maillage le tableau des coordonnées des noeuds,...
Definition: MEDmeshNodeCoordinateWr.c:45
MEDmeshElementConnectivityWithProfileWr
MEDC_EXPORT med_err MEDmeshElementConnectivityWithProfileWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_entity_type entitype, const med_geometry_type geotype, const med_connectivity_mode cmode, const med_storage_mode storagemode, const char *const profilename, const med_switch_mode switchmode, const med_int dimselect, const med_int nentity, const med_int *const connectivity)
Cette routine permet d'écrire dans un maillage le tableau des connectivités pour un type géométrique ...
Definition: MEDmeshElementConnectivityWithProfileWr.c:45
MED_ACC_CREAT
Definition: med.h:123
MED_ATT_INT
Definition: med.h:174
MED_GLOBAL_STMODE
Definition: med.h:109
MEDstructElementGeotype
MEDC_EXPORT med_geometry_type MEDstructElementGeotype(const med_idt fid, const char *const modelname)
Cette routine renvoie le type géométrique mgeotype associé au modèle d'éléments de structure de nom m...
Definition: MEDstructElementGeotype.c:38
MEDmeshGlobalNumberWr
MEDC_EXPORT med_err MEDmeshGlobalNumberWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitytype, const med_geometry_type geotype, const med_int nentity, const med_int *const number)
Cette routine permet l'écriture d'une numérotation globale sur un maillage pour un type d'entité,...
Definition: MEDmeshGlobalNumberWr.c:41
MED_BEAM_THICKNESS
#define MED_BEAM_THICKNESS
Definition: med.h:461
MEDmeshNodeCoordinateRd
MEDC_EXPORT med_err MEDmeshNodeCoordinateRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_switch_mode switchmode, med_float *const coordinates)
Cette routine permet de lire dans un maillage le tableau des coordonnées des noeuds,...
Definition: MEDmeshNodeCoordinateRd.c:37
MED_INDEX_NODE
Definition: med.h:151
MEDprofileWr
MEDC_EXPORT med_err MEDprofileWr(const med_idt fid, const char *const profilename, const med_int profilesize, const med_int *const profilearray)
Cette routine permet d'écrire un profil dans un fichier MED.
Definition: MEDprofileWr.c:40
MED_NAME_SIZE
#define MED_NAME_SIZE
Definition: med.h:81
MEDnMesh
MEDC_EXPORT med_int MEDnMesh(const med_idt fid)
Cette routine permet de lire le nombre de maillages dans un fichier.
Definition: MEDnMesh.c:34
MED_UNSTRUCTURED_MESH
Definition: med.h:131
MEDfileClose
MEDC_EXPORT med_err MEDfileClose(med_idt fid)
Fermeture d'un fichier MED.
Definition: MEDfileClose.c:30
MEDequivalenceInfo
MEDC_EXPORT med_err MEDequivalenceInfo(const med_idt fid, const char *const meshname, const int equivit, char *const equivname, char *const equivdescription, med_int *const nstep, med_int *const nocstpncorrespondence)
Cette routine permet lire les informations d'une équivalence portant sur les entités d'un maillage.
Definition: MEDequivalenceInfo.c:40
MED_COORDINATE_TRSF
Definition: med.h:152
MED_ALL_CONSTITUENT
#define MED_ALL_CONSTITUENT
Definition: med.h:299
MEDstructElementConstAttInfo
MEDC_EXPORT med_err MEDstructElementConstAttInfo(const med_idt fid, const char *const modelname, const int attit, char *const constattname, med_attribute_type *const constatttype, med_int *const ncomponent, med_entity_type *const sentitytype, char *const profilename, med_int *const profilesize)
Cette routine décrit les caractéristiques d'un attribut constant de modèle d'élément de structure par...
Definition: MEDstructElementConstAttInfo.c:45
MEDmeshnEntityWithProfile
MEDC_EXPORT med_int MEDmeshnEntityWithProfile(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_data_type datatype, const med_connectivity_mode cmode, const med_storage_mode storagemode, char *const profilename, med_int *const profilesize, med_bool *const changement, med_bool *const transformation)
Cette routine permet de lire le nombre d'entités dans un maillage pour une étape de calcul et un prof...
Definition: MEDmeshnEntityWithProfile.c:47
MED_COMPACT_STMODE
Definition: med.h:110
MEDmeshInfoByName
MEDC_EXPORT med_err MEDmeshInfoByName(const med_idt fid, const 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 en précisant son nom.
Definition: MEDmeshInfoByName.c:42
MED_NO_PROFILE
#define MED_NO_PROFILE
Definition: med.h:281
MEDmeshPolygonRd
MEDC_EXPORT med_err MEDmeshPolygonRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_connectivity_mode cmode, med_int *const polyindex, med_int *const connectivity)
Cette routine permet la lecture des connectivités de polygones.
Definition: MEDmeshPolygonRd.c:44
MEDstructElementInfoByName
MEDC_EXPORT med_err MEDstructElementInfoByName(const med_idt fid, const char *const modelname, med_geometry_type *const mgeotype, med_int *const modeldim, char *const supportmeshname, med_entity_type *const sentitytype, med_int *const snnode, med_int *const sncell, med_geometry_type *const sgeotype, med_int *const nconstantatribute, med_bool *const anyprofile, med_int *const nvariableattribute)
Cette routine décrit les caractéristiques d'un modèle d'élément de structure à partir de son nom.
Definition: MEDstructElementInfoByName.c:49
MED_UNDEF_DT
#define MED_UNDEF_DT
Definition: med.h:322
MEDmeshElementConnectivityWr
MEDC_EXPORT med_err MEDmeshElementConnectivityWr(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_float dt, const med_entity_type entitype, const med_geometry_type geotype, const med_connectivity_mode cmode, const med_switch_mode switchmode, const med_int nentity, const med_int *const connectivity)
Cette routine permet d'écrire dans un maillage le tableau des connectivités pour un type géométrique ...
Definition: MEDmeshElementConnectivityWr.c:42
med_axis_type
med_axis_type
Definition: med.h:258
MEDequivalenceCorrespondenceWr
MEDC_EXPORT med_err MEDequivalenceCorrespondenceWr(const med_idt fid, const char *const meshname, const char *const equivname, const med_int numdt, const med_int numit, const med_entity_type entitype, const med_geometry_type geotype, const med_int nentity, const med_int *const correspondence)
Cette routine permet d'écrire un tableau de correspondances entre les entités d'un maillage dans une ...
Definition: MEDequivalenceCorrespondenceWr.c:43
MEDmeshInfo
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
MED_NO_IT
#define MED_NO_IT
Definition: med.h:321
MED_COORDINATE
Definition: med.h:149
MEDstructElementVarAttCr
MEDC_EXPORT med_err MEDstructElementVarAttCr(const med_idt fid, const char *const modelname, const char *const varattname, const med_attribute_type varatttype, const med_int ncomponent)
Cette routine déclare la présence d'un attribut caractéristique variable attaché aux éléments de type...
Definition: MEDstructElementVarAttCr.c:42
MEDequivalenceComputingStepInfo
MEDC_EXPORT med_err MEDequivalenceComputingStepInfo(const med_idt fid, const char *const meshname, const char *const equivname, const int csit, med_int *const numdt, med_int *const numit, med_int *const ncorrespondence)
Cette routine permet de lire les informations relatives à une équivalence pour une étape de calcul do...
Definition: MEDequivalenceComputingStepInfo.c:40
MEDnSubdomainJoint
MEDC_EXPORT med_int MEDnSubdomainJoint(const med_idt fid, const char *const meshname)
Cette routine permet la lecture du nombre de joint dans un maillage.
Definition: MEDnSubdomainJoint.c:38
MEDstructElementAttSizeof
MEDC_EXPORT int MEDstructElementAttSizeof(const med_attribute_type atttype)
Cette routine renvoie la taille en octets du type élémentaire atttype.
Definition: MEDstructElementAttSizeof.c:36
MED_POLYHEDRON
#define MED_POLYHEDRON
Definition: med.h:225
MEDstructElementVarAttInfo
MEDC_EXPORT med_err MEDstructElementVarAttInfo(const med_idt fid, const char *const modelname, const int attit, char *const varattname, med_attribute_type *const varatttype, med_int *const ncomponent)
Cette routine décrit les caractéristiques d'un attribut variable de modèle d'élément de structure par...
Definition: MEDstructElementVarAttInfo.c:41
MEDsupportMeshInfoByName
MEDC_EXPORT med_err MEDsupportMeshInfoByName(const med_idt fid, const char *const supportmeshname, med_int *const spacedim, med_int *const meshdim, char *const description, med_axis_type *const axistype, char *const axisname, char *const axisunit)
Cette routine permet de lire les informations relatives à un maillage support en précisant son nom.
Definition: MEDsupportMeshInfoByName.c:39
MEDsupportMeshCr
MEDC_EXPORT med_err MEDsupportMeshCr(const med_idt fid, const char *const supportmeshname, const med_int spacedim, const med_int meshdim, const char *const description, const med_axis_type axistype, const char *const axisname, const char *const axisunit)
Cette routine permet de créer un maillage support.
Definition: MEDsupportMeshCr.c:46
MEDequivalenceCr
MEDC_EXPORT med_err MEDequivalenceCr(const med_idt fid, const char *const meshname, const char *const equivname, const char *const description)
Cette routine permet la création d'une équivalence portant sur les entités d'un maillage.
Definition: MEDequivalenceCr.c:37
MEDmeshNodeCoordinateWithProfileRd
MEDC_EXPORT med_err MEDmeshNodeCoordinateWithProfileRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_storage_mode storagemode, const char *const profilename, const med_switch_mode switchmode, const med_int dimselect, med_float *const coordinates)
Cette routine permet de lire dans un maillage le tableau des coordonnées des noeuds,...
Definition: MEDmeshNodeCoordinateWithProfileRd.c:40
main
int main(int argc, char **argv)
Definition: 3.0.8/test10.c:50
med_utils.h
MEDstructElementCr
MEDC_EXPORT med_geometry_type MEDstructElementCr(const med_idt fid, const char *const modelname, const med_int modeldim, const char *const supportmeshname, const med_entity_type sentitytype, const med_geometry_type sgeotype)
Cette routine permet de créer un nouveau modèle d'éléments de structure dans un fichier MED.
Definition: MEDstructElementCr.c:50
MEDmeshStructElementVarAttRd
MEDC_EXPORT med_err MEDmeshStructElementVarAttRd(const med_idt fid, const char *const meshname, const med_int numdt, const med_int numit, const med_geometry_type mgeotype, const char *const varattname, void *const value)
Cette routine lit les valeurs d'un attribut caractéristique variable sur les éléments de structure d'...
Definition: MEDmeshStructElementVarAttRd.c:43
MED_QUAD4
#define MED_QUAD4
Definition: med.h:204
MED_POLYGON
#define MED_POLYGON
Definition: med.h:223
MED_NO_NAME
#define MED_NO_NAME
Definition: med.h:268