int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1]= "maa1";
char jnt[MED_TAILLE_NOM+1] = "joint";
char des_jnt[MED_TAILLE_DESC+1] = "joint avec le sous-domaine 2";
char maa_distant[MED_TAILLE_NOM+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};
/* Creation du fichier "test29.med" */
if ((fid = MEDouvrir("test29.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test29.med");
return -1;
}
/* Creation du maillage */
if (MEDmaaCr(fid,maa,3,MED_NON_STRUCTURE,
"Un maillage pour test29") < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
/* Creation du joint */
if (MEDjointCr(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 (MEDjointEcr(fid,maa,jnt,cor,ncor,
MED_NOEUD,0,MED_NOEUD,0) < 0) {
MESSAGE("Erreur a l'ecriture du tableau des correspondances (noeud,noeud)");
return -1;
}
/* Ecriture de la correspondance Noeud Maille */
if (MEDjointEcr(fid,maa,jnt,cor2,ncor,
MED_NOEUD,0,MED_MAILLE,MED_TRIA3) < 0) {
MESSAGE("Erreur a l'ecriture du tableau des correspondances (noeud,maille TRIA3)");
return -1;
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
char des[MED_TAILLE_DESC+1]="Ceci est un courte description du mon fichier test1.med";
/* creation du fichier "test1.med" */
fid = MEDouvrir("test1.med",MODE_ACCES);
if (fid < 0) {
MESSAGE("Erreur à la creation du fichier");
return -1;
}
/* ecriture d'un en-tete dans le fichier */
if (MEDfichDesEcr(fid,des) < 0) {
MESSAGE("Erreur à l'ecriture de l'en-tete du fichier");
ret = -1;
}
/* fermeture du fichier */
if ((ret = MEDfermer(fid)) < 0) {
MESSAGE("Erreur à la fermeture du fichier");
return -1;
}
/* re-ouverture du fichier en lecture seule */
fid = MEDouvrir("test1.med",MED_LECTURE);
if (fid < 0) {
MESSAGE("Erreur à l'ouverture du fichier en mode MED_LECTURE");
return -1;
}
/* fermeture du fichier */
if (MEDfermer(fid) < 0)
ret = -1;
return ret;
}
int main (int argc, char **argv)
{
med_err ret,lret;
med_idt fid;
char * fichier = NULL;
char maa[MED_TAILLE_NOM+1]="";
char desc[MED_TAILLE_DESC+1]="";
char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]="";
char locname[MED_TAILLE_NOM+1]="";
char * lien = NULL;
char *comp= NULL, *unit= NULL;
char nomcha [MED_TAILLE_NOM+1]="";
med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval;
med_int ngauss,nloc;
int t1,t2,t3;
med_type_champ typcha;
med_maillage type;
med_geometrie_element type_geo;
med_float *refcoo, *gscoo, *wg;
int i,j;
if (argc != 2) {
MESSAGE("Aucun nom de fichier precise, fichier test10.med utilise ");
fichier = "test10.med";
} else {
fichier = argv[1];
};
/* Ouverture du fichier med */
if ((fid = MEDouvrir(fichier,MED_LECTURE)) < 0){
MESSAGE("Erreur a l'ouverture du fichier : ");SSCRUTE(fichier);
return -1;
}
ret = 0;
/* infos sur le premier maillage */
if ( MEDmaaInfo(fid,1,maa,&mdim,&type,desc) < 0 ) {
MESSAGE("Erreur a la lecture des informations sur le maillage : ");
SSCRUTE(maa);ISCRUTE(mdim);ISCRUTE(type);SSCRUTE(desc);
return -1;
}
printf("Maillage de nom |%s| et de dimension %d \n",maa,mdim);
/* combien de champs dans le fichier */
if ((ncha = MEDnChamp(fid,0)) < 0) {
MESSAGE("Impossible de lire le nombre de champs : ");ISCRUTE(ncha);
return ncha;
}
printf("Nombre de champs : %d \n",ncha);
/* lecture de tous les champs */
for (i =0;i<ncha;i++) {
lret = 0;
printf("\nChamp numero : %d \n",i+1);
/* Lecture du nombre de composantes */
if ((ncomp = MEDnChamp(fid,i+1)) < 0) {
MESSAGE("Erreur a la lecture du nombre de composantes : "); ISCRUTE(ncomp);
ret = -1; continue;
}
/* Lecture du type du champ, des noms des composantes et du nom de l'unite*/
comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
EXIT_IF(comp == NULL,NULL,NULL);
unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
EXIT_IF(unit == NULL,NULL,NULL);
if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) {
MESSAGE("Erreur a la demande d'information sur les champs : ");
ISCRUTE(i+1);SSCRUTE(nomcha);ISCRUTE(typcha);SSCRUTE(comp);SSCRUTE(unit);
ISCRUTE(ncomp);
ret = -1; continue;
}
printf("Nom du champ : |%s| de type %d\n",nomcha,typcha);
printf("Nom des composantes : |%s|\n",comp);
printf("Unites des composantes : |%s| \n",unit);
free(comp);
free(unit);
lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NOEUD, USER_INTERLACE );
if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_MAILLE, USER_INTERLACE );
else { MESSAGE("Erreur a la lecture des champs aux noeuds "); ret = -1; continue;}
if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_FACE,USER_INTERLACE);
else { MESSAGE("Erreur a la lecture des champs aux mailles "); ret = -1; continue;}
if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_ARETE,USER_INTERLACE);
else {MESSAGE("Erreur a la lecture des champs aux faces "); ret = -1; continue;}
if (lret != 0) {MESSAGE("Erreur a la lecture des champs aux aretes "); ret = -1;};
}
/* Interrogation des profils */
npro = MEDnProfil(fid);
printf("\nNombre de profils stockes : %i\n\n",npro);
for (i=1 ; i <= npro ; i++ ) {
if ( MEDprofilInfo(fid, i, pflname, &nval) < 0) {
MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i);
ret = -1;continue;
}
printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval);
pflval = (med_int*) malloc(sizeof(med_int)*nval);
if ( MEDprofilLire(fid, pflval, pflname) < 0) {
MESSAGE("Erreur a la lecture des valeurs du profil : ");
SSCRUTE(pflname);
ret = -1;
} else {
printf("\t");
for (j=0;j<nval;j++) printf(" %i ",*(pflval+j));
printf("\n\n");
}
free(pflval);
}
/* Interrogation des liens */
nln = MEDnLien(fid);
printf("\nNombre de liens stockes : %i\n\n",nln);
for (i=1 ; i <= nln ; i++ ) {
if ( MEDlienInfo(fid, i, nomlien, &nval) < 0) {
MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i);
ret = -1;continue;
}
printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval);
lien = malloc((nval+1)*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
if ( MEDlienLire(fid, lien, nomlien) < 0 ) {
MESSAGE("Erreur a la lecture du lien : ");
SSCRUTE(nomlien);SSCRUTE(lien);
ret = -1;
} else
printf("\t\t|%s|\n\n",lien);
free(lien);
}
/* Interrogation des localisations des points de GAUSS */
nloc = MEDnGauss(fid);
printf("\nNombre de localisations stockees : %i\n\n",nloc);
for (i=1 ; i <= nloc ; i++ ) {
if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0) {
MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i);
ret = -1;continue;
}
printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss);
t1 = (type_geo%100)*(type_geo/100);
t2 = ngauss*(type_geo/100);
t3 = ngauss;
refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
gscoo = (med_float *) malloc(sizeof(med_float)*t2 );
wg = (med_float *) malloc(sizeof(med_float)*t3 );
if ( MEDgaussLire(fid, refcoo, gscoo, wg, USER_INTERLACE, locname ) < 0) {
MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
SSCRUTE(locname);
ret = -1;
} else {
printf("\t Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
printf("\n");
printf("\t Localisation des points de GAUSS : \n\t\t");
for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
printf("\n");
printf("\t Poids associes aux points de GAUSS :\n\t\t");
for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
printf("\n\n");
}
free(refcoo);
free(gscoo);
free(wg);
}
/* fermeture du fichier */
if ( MEDfermer(fid) < 0) return -1;
return ret;
}
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1] = "maillage_test19";
char desc[MED_TAILLE_DESC+1]="un maillage pour test19.med";
med_int mdim=2;
/* Donnees de tests pour MEDgro2FamCr()
Les noeuds/mailles sont numerotes de 1 a 5 et les
groupes de 1 a 3.
Au depart, on a :
- G1 : 1,2
- G2 : 3,4,6
- G3 : 1,4
Au retour, on foit avoir 4 familles de noeuds + 4 familles de mailles
+ la famille 0 dans le fichier :
- F0 : 5 - groupes : aucun groupe par defaut (convention habituelle).
- F1 : 1 - groupes : G1,G3
- F2 : 2 - groupes : G1
- F3 : 3,6 - groupes : G2
- F4 : 4 - groupes : G2,G3
*/
med_int ngroup = 3;
med_int nent = 6;
char nom_groupes[MED_TAILLE_LNOM*3+1];
/* 0 1 2 3 4 5 6 */
med_int entites[7] = { 1,2, 3,4,6, 1,4};
med_int index[4] = { 1, 3, 6, 8};
int i;
char nom_famille0[MED_TAILLE_NOM+1] = "FAMILLE0";
/* on fait la meme distribution pour des mailles */
med_int ngeo = 3;
med_geometrie_element geo[3] = {MED_SEG2,MED_TRIA3,MED_TETRA4};
/* MED_SEG2 : M1,M2,M3 - MED_TRI3 : M4,M5 - MED_TETRA4 : M6 */
med_int index_geo[4] = {1,4,6,7};
/* Creation du fichier test19.med */
if ((fid = MEDouvrir("test19.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test19.med");
return -1;
}
printf("Creation du fichier test19.med \n");
/* Creation du maillage */
if (MEDmaaCr(fid,maa,mdim,MED_NON_STRUCTURE,desc) < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
printf("Creation du maillage \n");
/* on teste la fonction MEDgro2fam() */
/* on definit les noms des groupes */
strcpy(nom_groupes,"GROUPE 1");
for (i=8;i<MED_TAILLE_LNOM;i++)
nom_groupes[i] = ' ';
nom_groupes[MED_TAILLE_LNOM] = '\0';
strcat(nom_groupes,"GROUPE 2");
for (i=8;i<MED_TAILLE_LNOM;i++)
nom_groupes[MED_TAILLE_LNOM+i] = ' ';
nom_groupes[2*MED_TAILLE_LNOM] = '\0';
strcat(nom_groupes,"GROUPE 3");
for (i=8;i<MED_TAILLE_LNOM;i++)
nom_groupes[2*MED_TAILLE_LNOM+i] = ' ';
nom_groupes[3*MED_TAILLE_LNOM] = '\0';
/* On cree la famille 0 */
if (MEDfamCr(fid,maa,nom_famille0,0,NULL,NULL,NULL,0,NULL,0) < 0) {
MESSAGE("Erreur a la creation de la famille 0");
return -1;
}
printf("Creation de la famille 0 \n");
/*
* On definit et on archive les familles de noeuds dans test.19.med
*/
if (MEDgro2famCr(fid,maa,nom_groupes,index,ngroup,entites,nent,
MED_NOEUD,NULL,NULL,0) < 0) {
MESSAGE("Erreur a la creation des familles de noeuds ");
return -1;
}
printf("On constuit les familles de noeuds et on les stocke dans test19.med \n");
/*
* On fait la meme chose pour des mailles de differents types
*/
if (MEDgro2famCr(fid,maa,nom_groupes,index,ngroup,entites,nent,
MED_MAILLE,geo,index_geo,ngeo) < 0) {
MESSAGE("Erreur a la creation des familles d'elements ");
return -1;
}
printf("On constuit les familles d'elements et on les stocke dans test19.med \n");
/* Fermeture du fichier */
if (MEDfermer(fid) <0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
printf("Fermeture du fichier \n");
return 0;
}
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1] = "maa1";
med_int mdim = 3;
med_int index[4] = {1,6,12,17};
med_int con[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
med_int n=3,ni = 4;
/* 123456789012345612345678901234561234567890123456 */
char nom[MED_TAILLE_PNOM*3+1]="poly1 poly2 poly3 ";
med_int num[3] = {1,2,3};
med_int fam[3] = {0,-1,-2};
/* Creation du fichier test23.med */
fid = MEDouvrir("test23.med",MODE_ACCES);
if (fid == -1) {
MESSAGE("Erreur a la creation du fichier test23.med");
return -1;
}
printf("Creation du fichier test23.med \n");
/* Creation du maillage */
if (MEDmaaCr(fid,maa,mdim,MED_NON_STRUCTURE,
"un maillage pour test23") < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
printf("Creation du maillage \n");
/* Ecriture de la connectivite des mailles polygones en mode nodal */
if (MEDpolygoneConnEcr(fid,maa,index,ni,con,MED_MAILLE,MED_NOD) < 0) {
MESSAGE("Erreur a l'ecriture de la connectivite des mailles MED_POLYGONE");
return -1;
}
printf("Ecriture des connectivites de mailles de type MED_POLYGONE en mode nodal \n");
/* Ecriture des noms des polygones */
if (MEDnomEcr(fid,maa,nom,n,MED_MAILLE,MED_POLYGONE) < 0) {
MESSAGE("Erreur a l'ecriture des noms mailles MED_POLYGONE");
return -1;
}
printf("Ecriture des noms des polygones \n");
/* Ecriture des numeros des polygones */
if (MEDnumEcr(fid,maa,num,n,MED_MAILLE,MED_POLYGONE) < 0) {
MESSAGE("Erreur a l'ecriture des numeros des mailles MED_POLYGONE");
return -1;
}
printf("Ecriture des numeros des polygones \n");
/* Ecriture des numeros des familles des polygones */
if (MEDfamEcr(fid,maa,fam,n,MED_MAILLE,MED_POLYGONE) < 0) {
MESSAGE("Erreur a l'ecriture des numeros de famille des mailles MED_POLYGONE");
return -1;
}
printf("Ecriture des numeros des familles des polygones \n");
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
printf("Fermeture du fichier test23.med \n");
return 0;
}
int GModel::readMED(const std::string &name)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_LECTURE);
if(fid < 0) {
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
med_int v[3], vf[3];
MEDversionDonner(&v[0], &v[1], &v[2]);
MEDversionLire(fid, &vf[0], &vf[1], &vf[2]);
Msg::Info("Reading MED file V%d.%d.%d using MED library V%d.%d.%d",
vf[0], vf[1], vf[2], v[0], v[1], v[2]);
if(vf[0] < 2 || (vf[0] == 2 && vf[1] < 2)){
Msg::Error("Cannot read MED file older than V2.2");
return 0;
}
std::vector<std::string> meshNames;
for(int i = 0; i < MEDnMaa(fid); i++){
char meshName[MED_TAILLE_NOM + 1], meshDesc[MED_TAILLE_DESC + 1];
med_int spaceDim;
med_maillage meshType;
#if (MED_MAJOR_NUM == 3)
med_int meshDim, nStep;
char dtUnit[MED_SNAME_SIZE + 1];
char axisName[3 * MED_SNAME_SIZE + 1], axisUnit[3 * MED_SNAME_SIZE + 1];
med_sorting_type sortingType;
med_axis_type axisType;
if(MEDmeshInfo(fid, i + 1, meshName, &spaceDim, &meshDim, &meshType, meshDesc,
dtUnit, &sortingType, &nStep, &axisType, axisName, axisUnit) < 0){
#else
if(MEDmaaInfo(fid, i + 1, meshName, &spaceDim, &meshType, meshDesc) < 0){
#endif
Msg::Error("Unable to read mesh information");
return 0;
}
meshNames.push_back(meshName);
}
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
int ret = 1;
for(unsigned int i = 0; i < meshNames.size(); i++){
// we use the filename as a kind of "partition" indicator, allowing to
// complete a model part by part (used e.g. in DDM, since MED does not store
// a partition index)
GModel *m = findByName(meshNames[i], name);
if(!m) m = new GModel(meshNames[i]);
ret = m->readMED(name, i);
if(!ret) return 0;
}
return ret;
}
int GModel::readMED(const std::string &name, int meshIndex)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_LECTURE);
if(fid < 0){
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
int numMeshes = MEDnMaa(fid);
if(meshIndex >= numMeshes){
Msg::Info("Could not find mesh %d in MED file", meshIndex);
return 0;
}
checkPointMaxNumbers();
GModel::setCurrent(this); // make sure we increment max nums in this model
// read mesh info
char meshName[MED_TAILLE_NOM + 1], meshDesc[MED_TAILLE_DESC + 1];
med_int spaceDim, nStep = 1;
med_maillage meshType;
#if (MED_MAJOR_NUM == 3)
med_int meshDim;
char dtUnit[MED_SNAME_SIZE + 1];
char axisName[3 * MED_SNAME_SIZE + 1], axisUnit[3 * MED_SNAME_SIZE + 1];
med_sorting_type sortingType;
med_axis_type axisType;
if(MEDmeshInfo(fid, meshIndex + 1, meshName, &spaceDim, &meshDim, &meshType, meshDesc,
dtUnit, &sortingType, &nStep, &axisType, axisName, axisUnit) < 0){
#else
if(MEDmaaInfo(fid, meshIndex + 1, meshName, &spaceDim, &meshType, meshDesc) < 0){
#endif
Msg::Error("Unable to read mesh information");
return 0;
}
// FIXME: we should support multi-step MED3 meshes (probably by
// storing each mesh as a separate model, with a naming convention
// e.g. meshName_step%d). This way we could also handle multi-mesh
// time sequences in MED3.
if(nStep > 1)
Msg::Warning("Discarding %d last meshes in multi-step MED mesh", nStep - 1);
setName(meshName);
setFileName(name);
if(meshType == MED_NON_STRUCTURE){
Msg::Info("Reading %d-D unstructured mesh <<%s>>", spaceDim, meshName);
}
else{
Msg::Error("Reading structured MED meshes is not supported");
return 0;
}
med_int vf[3];
MEDversionLire(fid, &vf[0], &vf[1], &vf[2]);
// read nodes
#if (MED_MAJOR_NUM == 3)
med_bool changeOfCoord, geoTransform;
med_int numNodes = MEDmeshnEntity(fid, meshName, MED_NO_DT, MED_NO_IT, MED_NODE,
MED_NO_GEOTYPE, MED_COORDINATE, MED_NO_CMODE,
&changeOfCoord, &geoTransform);
#else
med_int numNodes = MEDnEntMaa(fid, meshName, MED_COOR, MED_NOEUD, MED_NONE,
MED_NOD);
#endif
if(numNodes < 0){
Msg::Error("Could not read number of MED nodes");
return 0;
}
if(numNodes == 0){
Msg::Error("No nodes in MED mesh");
return 0;
}
std::vector<MVertex*> verts(numNodes);
std::vector<med_float> coord(spaceDim * numNodes);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshNodeCoordinateRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_FULL_INTERLACE,
&coord[0]) < 0){
#else
std::vector<char> coordName(spaceDim * MED_TAILLE_PNOM + 1);
std::vector<char> coordUnit(spaceDim * MED_TAILLE_PNOM + 1);
med_repere rep;
if(MEDcoordLire(fid, meshName, spaceDim, &coord[0], MED_FULL_INTERLACE,
MED_ALL, 0, 0, &rep, &coordName[0], &coordUnit[0]) < 0){
#endif
Msg::Error("Could not read MED node coordinates");
return 0;
}
std::vector<med_int> nodeTags(numNodes);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_NODE,
MED_NO_GEOTYPE, &nodeTags[0]) < 0)
#else
if(MEDnumLire(fid, meshName, &nodeTags[0], numNodes, MED_NOEUD, MED_NONE) < 0)
#endif
nodeTags.clear();
for(int i = 0; i < numNodes; i++)
verts[i] = new MVertex(coord[spaceDim * i],
(spaceDim > 1) ? coord[spaceDim * i + 1] : 0.,
(spaceDim > 2) ? coord[spaceDim * i + 2] : 0.,
0, nodeTags.empty() ? 0 : nodeTags[i]);
// read elements (loop over all possible MSH element types)
for(int mshType = 0; mshType < MSH_NUM_TYPE; mshType++){
med_geometrie_element type = msh2medElementType(mshType);
if(type == MED_NONE) continue;
#if (MED_MAJOR_NUM == 3)
med_bool changeOfCoord;
med_bool geoTransform;
med_int numEle = MEDmeshnEntity(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, MED_CONNECTIVITY, MED_NODAL, &changeOfCoord,
&geoTransform);
#else
med_int numEle = MEDnEntMaa(fid, meshName, MED_CONN, MED_MAILLE, type, MED_NOD);
#endif
if(numEle <= 0) continue;
int numNodPerEle = type % 100;
std::vector<med_int> conn(numEle * numNodPerEle);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshElementConnectivityRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, MED_NODAL, MED_FULL_INTERLACE, &conn[0]) < 0){
#else
if(MEDconnLire(fid, meshName, spaceDim, &conn[0], MED_FULL_INTERLACE, 0, MED_ALL,
MED_MAILLE, type, MED_NOD) < 0){
#endif
Msg::Error("Could not read MED elements");
return 0;
}
std::vector<med_int> fam(numEle, 0);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityFamilyNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, &fam[0]) < 0){
#else
if(MEDfamLire(fid, meshName, &fam[0], numEle, MED_MAILLE, type) < 0){
#endif
Msg::Info("No family number for elements: using 0 as default family number");
}
std::vector<med_int> eleTags(numEle);
#if (MED_MAJOR_NUM == 3)
if(MEDmeshEntityNumberRd(fid, meshName, MED_NO_DT, MED_NO_IT, MED_CELL,
type, &eleTags[0]) < 0)
#else
if(MEDnumLire(fid, meshName, &eleTags[0], numEle, MED_MAILLE, type) < 0)
#endif
eleTags.clear();
std::map<int, std::vector<MElement*> > elements;
MElementFactory factory;
for(int j = 0; j < numEle; j++){
std::vector<MVertex*> v(numNodPerEle);
for(int k = 0; k < numNodPerEle; k++)
v[k] = verts[conn[numNodPerEle * j + med2mshNodeIndex(type, k)] - 1];
MElement *e = factory.create(mshType, v, eleTags.empty() ? 0 : eleTags[j]);
if(e) elements[-fam[j]].push_back(e);
}
_storeElementsInEntities(elements);
}
_associateEntityWithMeshVertices();
_storeVerticesInEntities(verts);
// read family info
med_int numFamilies = MEDnFam(fid, meshName);
if(numFamilies < 0){
Msg::Error("Could not read MED families");
return 0;
}
for(int i = 0; i < numFamilies; i++){
#if (MED_MAJOR_NUM == 3)
med_int numAttrib = (vf[0] == 2) ? MEDnFamily23Attribute(fid, meshName, i + 1) : 0;
med_int numGroups = MEDnFamilyGroup(fid, meshName, i + 1);
#else
med_int numAttrib = MEDnAttribut(fid, meshName, i + 1);
med_int numGroups = MEDnGroupe(fid, meshName, i + 1);
#endif
if(numAttrib < 0 || numGroups < 0){
Msg::Error("Could not read MED groups or attributes");
return 0;
}
std::vector<med_int> attribId(numAttrib + 1);
std::vector<med_int> attribVal(numAttrib + 1);
std::vector<char> attribDes(MED_TAILLE_DESC * numAttrib + 1);
std::vector<char> groupNames(MED_TAILLE_LNOM * numGroups + 1);
char familyName[MED_TAILLE_NOM + 1];
med_int familyNum;
#if (MED_MAJOR_NUM == 3)
if(vf[0] == 2){ // MED2 file
if(MEDfamily23Info(fid, meshName, i + 1, familyName, &attribId[0],
&attribVal[0], &attribDes[0], &familyNum,
&groupNames[0]) < 0){
Msg::Error("Could not read info for MED2 family %d", i + 1);
continue;
}
}
else{
if(MEDfamilyInfo(fid, meshName, i + 1, familyName, &familyNum,
&groupNames[0]) < 0){
Msg::Error("Could not read info for MED3 family %d", i + 1);
continue;
}
}
#else
if(MEDfamInfo(fid, meshName, i + 1, familyName, &familyNum, &attribId[0],
&attribVal[0], &attribDes[0], &numAttrib, &groupNames[0],
&numGroups) < 0){
Msg::Error("Could not read info for MED family %d", i + 1);
continue;
}
#endif
// family tags are unique (for all dimensions)
GEntity *ge;
if((ge = getRegionByTag(-familyNum))){}
else if((ge = getFaceByTag(-familyNum))){}
else if((ge = getEdgeByTag(-familyNum))){}
else ge = getVertexByTag(-familyNum);
if(ge){
elementaryNames[std::pair<int, int>(ge->dim(), -familyNum)] = familyName;
if(numGroups > 0){
for(int j = 0; j < numGroups; j++){
char tmp[MED_TAILLE_LNOM + 1];
strncpy(tmp, &groupNames[j * MED_TAILLE_LNOM], MED_TAILLE_LNOM);
tmp[MED_TAILLE_LNOM] = '\0';
// don't use same physical number across dimensions, as e.g. getdp
// does not support this
int pnum = setPhysicalName(tmp, ge->dim(), getMaxPhysicalNumber(-1) + 1);
if(std::find(ge->physicals.begin(), ge->physicals.end(), pnum) ==
ge->physicals.end())
ge->physicals.push_back(pnum);
}
}
}
}
// check if we need to read some post-processing data later
#if (MED_MAJOR_NUM == 3)
bool postpro = (MEDnField(fid) > 0) ? true : false;
#else
bool postpro = (MEDnChamp(fid, 0) > 0) ? true : false;
#endif
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
return postpro ? 2 : 1;
}
template<class T>
static void fillElementsMED(med_int family, std::vector<T*> &elements,
std::vector<med_int> &conn, std::vector<med_int> &fam,
med_geometrie_element &type)
{
if(elements.empty()) return;
type = msh2medElementType(elements[0]->getTypeForMSH());
if(type == MED_NONE){
Msg::Warning("Unsupported element type in MED format");
return;
}
for(unsigned int i = 0; i < elements.size(); i++){
elements[i]->setVolumePositive();
for(int j = 0; j < elements[i]->getNumVertices(); j++)
conn.push_back(elements[i]->getVertex(med2mshNodeIndex(type, j))->getIndex());
fam.push_back(family);
}
}
static void writeElementsMED(med_idt &fid, char *meshName, std::vector<med_int> &conn,
std::vector<med_int> &fam, med_geometrie_element type)
{
if(fam.empty()) return;
#if (MED_MAJOR_NUM == 3)
if(MEDmeshElementWr(fid, meshName, MED_NO_DT, MED_NO_IT, 0., MED_CELL, type,
MED_NODAL, MED_FULL_INTERLACE, (med_int)fam.size(),
&conn[0], MED_FALSE, 0, MED_FALSE, 0, MED_TRUE, &fam[0]) < 0)
#else
if(MEDelementsEcr(fid, meshName, (med_int)3, &conn[0], MED_FULL_INTERLACE,
0, MED_FAUX, 0, MED_FAUX, &fam[0], (med_int)fam.size(),
MED_MAILLE, type, MED_NOD) < 0)
#endif
Msg::Error("Could not write MED elements");
}
int GModel::writeMED(const std::string &name, bool saveAll, double scalingFactor)
{
med_idt fid = MEDouvrir((char*)name.c_str(), MED_CREATION);
if(fid < 0){
Msg::Error("Unable to open file '%s'", name.c_str());
return 0;
}
// write header
if(MEDfichDesEcr(fid, (char*)"MED file generated by Gmsh") < 0){
Msg::Error("Unable to write MED descriptor");
return 0;
}
char *meshName = (char*)getName().c_str();
// Gmsh always writes 3D unstructured meshes
#if (MED_MAJOR_NUM == 3)
char dtUnit[MED_SNAME_SIZE + 1] = "";
char axisName[3 * MED_SNAME_SIZE + 1] = "";
char axisUnit[3 * MED_SNAME_SIZE + 1] = "";
if(MEDmeshCr(fid, meshName, 3, 3, MED_UNSTRUCTURED_MESH, "Mesh created with Gmsh",
dtUnit, MED_SORT_DTIT, MED_CARTESIAN, axisName, axisUnit) < 0){
#else
if(MEDmaaCr(fid, meshName, 3, MED_NON_STRUCTURE,
(char*)"Mesh created with Gmsh") < 0){
#endif
Msg::Error("Could not create MED mesh");
return 0;
}
// if there are no physicals we save all the elements
if(noPhysicalGroups()) saveAll = true;
// index the vertices we save in a continuous sequence (MED
// connectivity is given in terms of vertex indices)
indexMeshVertices(saveAll);
// get a vector containing all the geometrical entities in the
// model (the ordering of the entities must be the same as the one
// used during the indexing of the vertices)
std::vector<GEntity*> entities;
getEntities(entities);
std::map<GEntity*, int> families;
// write the families
{
// always create a "0" family, with no groups or attributes
#if (MED_MAJOR_NUM == 3)
if(MEDfamilyCr(fid, meshName, "F_0", 0, 0, "") < 0)
#else
if(MEDfamCr(fid, meshName, (char*)"F_0", 0, 0, 0, 0, 0, 0, 0) < 0)
#endif
Msg::Error("Could not create MED family 0");
// create one family per elementary entity, with one group per
// physical entity and no attributes
for(unsigned int i = 0; i < entities.size(); i++){
if(saveAll || entities[i]->physicals.size()){
int num = - ((int)families.size() + 1);
families[entities[i]] = num;
std::ostringstream fs;
fs << entities[i]->dim() << "D_" << entities[i]->tag();
std::string familyName = "F_" + fs.str();
std::string groupName;
for(unsigned j = 0; j < entities[i]->physicals.size(); j++){
std::string tmp = getPhysicalName
(entities[i]->dim(), entities[i]->physicals[j]);
if(tmp.empty()){ // create unique name
std::ostringstream gs;
gs << entities[i]->dim() << "D_" << entities[i]->physicals[j];
groupName += "G_" + gs.str();
}
else
groupName += tmp;
groupName.resize((j + 1) * MED_TAILLE_LNOM, ' ');
}
#if (MED_MAJOR_NUM == 3)
if(MEDfamilyCr(fid, meshName, familyName.c_str(),
(med_int)num, (med_int)entities[i]->physicals.size(),
groupName.c_str()) < 0)
#else
if(MEDfamCr(fid, meshName, (char*)familyName.c_str(),
(med_int)num, 0, 0, 0, 0, (char*)groupName.c_str(),
(med_int)entities[i]->physicals.size()) < 0)
#endif
Msg::Error("Could not create MED family %d", num);
}
}
}
// write the nodes
{
std::vector<med_float> coord;
std::vector<med_int> fam;
for(unsigned int i = 0; i < entities.size(); i++){
for(unsigned int j = 0; j < entities[i]->mesh_vertices.size(); j++){
MVertex *v = entities[i]->mesh_vertices[j];
if(v->getIndex() >= 0){
coord.push_back(v->x() * scalingFactor);
coord.push_back(v->y() * scalingFactor);
coord.push_back(v->z() * scalingFactor);
fam.push_back(0); // we never create node families
}
}
}
if(fam.empty()){
Msg::Error("No nodes to write in MED mesh");
return 0;
}
#if (MED_MAJOR_NUM == 3)
if(MEDmeshNodeWr(fid, meshName, MED_NO_DT, MED_NO_IT, 0., MED_FULL_INTERLACE,
(med_int)fam.size(), &coord[0], MED_FALSE, "", MED_FALSE, 0,
MED_TRUE, &fam[0]) < 0)
#else
char coordName[3 * MED_TAILLE_PNOM + 1] =
"x y z ";
char coordUnit[3 * MED_TAILLE_PNOM + 1] =
"unknown unknown unknown ";
if(MEDnoeudsEcr(fid, meshName, (med_int)3, &coord[0], MED_FULL_INTERLACE,
MED_CART, coordName, coordUnit, 0, MED_FAUX, 0, MED_FAUX,
&fam[0], (med_int)fam.size()) < 0)
#endif
Msg::Error("Could not write nodes");
}
// write the elements
{
{ // points
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(viter it = firstVertex(); it != lastVertex(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->points, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // lines
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(eiter it = firstEdge(); it != lastEdge(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->lines, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // triangles
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(fiter it = firstFace(); it != lastFace(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->triangles, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // quads
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(fiter it = firstFace(); it != lastFace(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->quadrangles, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // tets
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->tetrahedra, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // hexas
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->hexahedra, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // prisms
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->prisms, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
{ // pyramids
med_geometrie_element typ = MED_NONE;
std::vector<med_int> conn, fam;
for(riter it = firstRegion(); it != lastRegion(); it++)
if(saveAll || (*it)->physicals.size())
fillElementsMED(families[*it], (*it)->pyramids, conn, fam, typ);
writeElementsMED(fid, meshName, conn, fam, typ);
}
}
if(MEDfermer(fid) < 0){
Msg::Error("Unable to close file '%s'", (char*)name.c_str());
return 0;
}
return 1;
}
#else
int GModel::readMED(const std::string &name)
{
Msg::Error("Gmsh must be compiled with MED support to read '%s'",
name.c_str());
return 0;
}
int main (int argc, char **argv)
{
med_idt fid;
char nom_scalaire[MED_TAILLE_NOM+1];
char description[MED_TAILLE_DESC+1];
med_int vali;
med_float valr;
med_int i,n,npdt,j;
med_type_champ type;
med_int numdt,numo;
med_float dt;
char dt_unit[MED_TAILLE_PNOM+1];
/* Ouverture du fichier test21.med en lecture seule */
if ((fid = MEDouvrir("test21.med",MED_LECTURE)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier test21.med");
return -1;
}
/* Lecture du nombre de variable scalaire */
n = MEDnScalaire(fid);
if (n < 0) {
MESSAGE("Erreur a la lecture du nombre de variable scalaire");
return -1;
}
printf("Nombre de variables scalaires dans tes21.med = %d\n",n);
/* Lecture des infos sur les variables (type,description) */
for (i=1;i<=n;i++) {
if (MEDscalaireInfo(fid,i,nom_scalaire,&type,description) < 0) {
MESSAGE("Erreur a la lecture des infos sur la variable d'indice : ");
ISCRUTE(i);
return -1;
}
printf("- Scalaire n°"IFORMAT" de nom %s \n",i,nom_scalaire);
if (type == MED_FLOAT64)
printf(" Type flottant. \n");
else
printf(" Type entier. \n");
printf(" Description associee : [%s] \n",description);
/* Pour chaque scalaire on regarde les valeurs associees
eventuellement a des pas de temps et des numeros d'ordre */
npdt = MEDnScalairePasdetemps(fid,nom_scalaire);
if (npdt < 0) {
MESSAGE("Erreur a la lecture du nombre de pas de temps");
return -1;
}
printf(" Nombre de valeurs stockees : "IFORMAT" \n",npdt);
for (j=1;j<=npdt;j++) {
if (MEDscalairePasdetempsInfo(fid,nom_scalaire,j,&numdt,dt_unit,&dt,&numo) < 0) {
MESSAGE("Erreur a la lecture des informations sur le pas de temps d'indice :");
ISCRUTE(j);
return -1;
}
printf(" Valeur n°"IFORMAT" : \n",j);
if (numdt == MED_NOPDT)
printf(" - Aucun de pas de temps \n");
else
printf(" - Pas de de temps de numero "IFORMAT" de valeur %f [%s] \n",numdt,dt,dt_unit);
if (numo == MED_NONOR)
printf(" - Aucun numero d'ordre \n");
else
printf(" - Numero d'ordre : "IFORMAT" \n",numo);
/* Lecture de la valeur flottante associee au pas de temps */
if (type == MED_FLOAT64) {
if (MEDscalaireFlottantLire(fid,nom_scalaire,&valr,numdt,numo) < 0) {
MESSAGE("Erreur a la lecture de la valeur flottante : ");
SSCRUTE(nom_scalaire); ISCRUTE(numdt);ISCRUTE(numo);
return -1;
}
printf(" - Valeur : %f \n",valr);
} else {
/* Lecture de la valeur scalaire associee au pas de temps */
if (MEDscalaireEntierLire(fid,nom_scalaire,&vali,numdt,numo) < 0) {
MESSAGE("Erreur a la lecture de la valeur entiere : ");
SSCRUTE(nom_scalaire); ISCRUTE(numdt);ISCRUTE(numo);
return -1;
}
printf(" - Valeur : "IFORMAT" \n",vali);
}
}
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier ");
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
char maa[MED_TAILLE_NOM+1];
med_int mdim;
med_int nfam;
med_int i,j;
med_int natt,ngro;
char *attdes,*gro;
med_int *attval,*attide;
char nomfam[MED_TAILLE_NOM+1];
med_int numfam;
char str1[MED_TAILLE_DESC+1];
char str2[MED_TAILLE_LNOM+1];
char desc[MED_TAILLE_DESC+1];
med_maillage type;
/* Ouverture du fichier "test8.med" en lecture seule */
if ((fid = MEDouvrir("test8.med",MED_LECTURE)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier test8.med");
return -1;
}
/* Lecture des information sur le 1er maillage */
if (MEDmaaInfo(fid,1,maa,&mdim,&type,desc) < 0) {
MESSAGE("Erreur a la lecture des informations du premier maillage");
return -1;
}
/* Lecture du nombre de familles */
if ((nfam = MEDnFam(fid,maa)) < 0) {
MESSAGE("Erreur a la lecture du nombre de famille");
return -1;
}
printf("Nombre de familles : "IFORMAT" \n",nfam);
/* Lecture de chaque famille */
for (i=0;i<nfam;i++) {
/* Lecture du nombre de groupe */
if ((ngro = MEDnGroupe(fid,maa,i+1)) < 0) {
MESSAGE("Erreur a la lecture du nombre de groupe de la famille d'indice : ");
ISCRUTE(i+1);
ret = -1;
}
/* Lecture du nombre d'attribut */
if ((natt = MEDnAttribut(fid,maa,i+1)) < 0) {
MESSAGE("Erreur a la lecture du nombre d'attribut de la famille d'indice : ");
ISCRUTE(i+1);
ret = -1;
}
if (ret == 0)
printf("Famille "IFORMAT" a "IFORMAT" attributs et "IFORMAT" groupes \n",i+1,natt,ngro);
/* Lecture des informations sur la famille */
if (ret == 0) {
/* Allocations memoire */
attide = (med_int*) malloc(sizeof(med_int)*natt);
attval = (med_int*) malloc(sizeof(med_int)*natt);
attdes = (char *) malloc(MED_TAILLE_DESC*natt+1);
gro = (char*) malloc(MED_TAILLE_LNOM*ngro+1);
if (MEDfamInfo(fid,maa,i+1,nomfam,&numfam,attide,attval,attdes,
&natt,gro,&ngro) < 0) {
MESSAGE("Erreur a la lecture des informations de la famille d'indice : ");
ISCRUTE(i+1);
ret = -1;
}
if (ret == 0) {
printf("Famille de nom %s et de numero "IFORMAT" : \n",nomfam,numfam);
printf("Attributs : \n");
for (j=0;j<natt;j++) {
strncpy(str1,attdes+j*MED_TAILLE_DESC,MED_TAILLE_DESC);
str1[MED_TAILLE_DESC] = '\0';
printf("ide = "IFORMAT" - val = "IFORMAT" - des = %s\n",*(attide+j),
*(attval+j),str1);
}
free(attide);
free(attval);
free(attdes);
for (j=0;j<ngro;j++) {
strncpy(str2,gro+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
str2[MED_TAILLE_LNOM] = '\0';
printf("gro = %s\n",str2);
}
free(gro);
}
}
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
return ret;
}
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
char maa[MED_TAILLE_NOM+1],maa_dist[MED_TAILLE_NOM+1];
med_int mdim;
med_int njnt,ncor,ndom,nc;
char jnt[MED_TAILLE_NOM+1],corr[MED_TAILLE_NOM+1];
char des[MED_TAILLE_DESC+1];
med_entite_maillage typ_ent_local,typ_ent_distant;
med_geometrie_element typ_geo_local,typ_geo_distant;
int i,j,k;
med_maillage type;
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 = MEDouvrir(argv[1],MED_LECTURE)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier : "); SSCRUTE(argv[1]);
return -1;
}
/* Lecture des infos sur le premier maillage */
if (MEDmaaInfo(fid,1,maa,&mdim,&type,des) < 0) {
MESSAGE("Erreur a lecture des infos sur le 1er maillage");
return -1;
}
printf("Maillage de nom %s et de dimension "IFORMAT" \n",maa,mdim);
/* Lecture du nombre de joints */
if ((njnt = MEDnJoint(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 */
if (njnt > 0)
for (i = 0;i<njnt;i++) {
printf("Joint numero : %d \n",i+1);
/* Lecture des infos sur le joints */
if (MEDjointInfo(fid,maa,i+1,jnt,des,&ndom,maa_dist) < 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);
/* lecture des correspondances une par une
en connaissant leur type a priori */
/* Lecture de la correspondance Noeud Noeud */
afficheCorres(fid,maa,jnt,MED_NOEUD,0,MED_NOEUD,0,"noeud/noeud");
/* Lecture de la correspondance Noeud Maille */
afficheCorres(fid,maa,jnt,MED_NOEUD,0,MED_MAILLE,MED_TRIA3,"noeud/TRIA3");
/* lecture des correspondances une par une
sans connaitre leur type a priori
-> utilisation de la fonction MEDjointTypeCorres */
ncor=1;
while (MEDjointTypeCorres(fid,maa,jnt,ncor,
&typ_ent_local,&typ_geo_local,&typ_ent_distant,&typ_geo_distant)>=0) {
/* Lecture de la correspondance Noeud Noeud */
afficheCorres(fid,maa,jnt,typ_ent_local,typ_geo_local,typ_ent_distant,typ_geo_distant,"noeud/noeud");
ncor++;
}
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier ");
return -1;
}
return ret;
}
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1] ="maa1";
med_int mdim = 2;
char nomfam[MED_TAILLE_NOM+1]="";
med_int numfam;
char attdes[MED_TAILLE_DESC+1]="";
med_int natt;
med_int attide;
med_int attval;
med_int ngro;
char gro[MED_TAILLE_LNOM+1]="";
int i;
int nfame = 3;
int nfamn = 2;
/* Creation du fichier "test8.med" */
if ((fid = MEDouvrir("test8.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test8.med");
return -1;
}
/* Creation d'un maillage */
if (MEDmaaCr(fid,maa,2,MED_NON_STRUCTURE,
"un maillage pour test8") < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
/* Ecriture des familles */
/* Conventions appliquees dans MED :
- Toujours creer une famille de numero 0 ne comportant aucun attribut
ni groupe (famille de reference pour les noeuds ou les elements
qui ne sont rattaches a aucun groupe ni attribut)
- Les numeros de familles de noeuds sont > 0
- Les numeros de familles des elements sont < 0
- Rien d'imposer sur les noms de familles.
*/
/* Creation de la famille 0 */
strcpy(nomfam,"FAMILLE_0");
numfam = 0;
if (MEDfamCr(fid,maa,nomfam,numfam,&attide,&attval,attdes,0,
gro,0) < 0) {
MESSAGE("Erreur a la creation de la famille 0");
return -1;
}
/* Creation pour correspondre aux cas test precedent de :
- 3 familles d'elements (-1,-2,-3)
- 2 familles de noeuds (1,2) */
nfame = 3;
for (i=0;i<nfame;i++) {
numfam = -(i+1);
sprintf(nomfam,"%s"IFORMAT,"FAMILLE_ELEMENT_",-numfam);
attide = 1;
attval = numfam*100;
natt = 1;
strcpy(attdes,"description attribut");
strcpy(gro,"groupe1");
ngro = 1;
printf("%s - "IFORMAT" - "IFORMAT" - "IFORMAT" - "IFORMAT" \n",nomfam,numfam,attide,attval,
ngro);
if (MEDfamCr(fid,maa,nomfam,numfam,&attide,&attval,attdes,
natt,gro,ngro) < 0) {
MESSAGE("Erreur a la creation de la famille :");
SSCRUTE(nomfam); ISCRUTE(numfam);
return -1;
}
}
nfamn = 2;
for (i=0;i<nfamn;i++) {
numfam = i+1;
sprintf(nomfam,"%s"IFORMAT,"FAMILLE_NOEUD_",numfam);
attide = 1;
attval = numfam*100;
natt = 1;
strcpy(attdes,"description attribut");
strcpy(gro,"groupe1");
ngro = 1;
if (MEDfamCr(fid,maa,nomfam,numfam,&attide,&attval,attdes,
natt,gro,ngro) < 0) {
MESSAGE("Erreur a la creation de la famille :");
SSCRUTE(nomfam); ISCRUTE(numfam);
return -1;
}
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier :");
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
int i;
med_idt fid,mid,mid2;
med_int ncha, ncomp, nmaa;
med_type_champ type;
char comp[3*MED_TAILLE_PNOM+1],unit[3*MED_TAILLE_PNOM+1];
char nom[MED_TAILLE_NOM+1];
/* Ouverture du fichier test20-0.med en mode lecture et ajout */
if ((fid = MEDouvrir("test20-0.med",MED_LECTURE_AJOUT)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier test20-0.med");
return -1;
}
printf("On ouvre le fichier test20-0.med \n");
/* Lecture du nombre de champs */
if ((ncha = MEDnChamp(fid,0)) < 0) {
MESSAGE("Erreur a la lecture du nombre de champs");
return -1;
}
printf("Nombre de champs dans test20-0.med :"IFORMAT" \n",ncha);
/* On fait le montage dans test20-0.med de tous les champs de test10.med */
mid = MEDmonter(fid,"test10.med",MED_CHAMP);
if (mid < 0) {
MESSAGE("Echec du montage des champs de test10.med");
return -1;
}
printf("On monte les champs du fichier test10.med dans le fichier test20-0.med \n");
/* Combien de champs dans le fichier "test20-0.med" apres le montage */
if ((ncha = MEDnChamp(fid,0)) < 0) {
MESSAGE("Erreur a la lecture du nombre de champ");
return -1;
}
printf("Nombre de champs dans test20-0.med apres montage : "IFORMAT" \n",ncha);
/* On s'assure que les champs sont bien accessibles */
for (i=1;i<=ncha;i++) {
/* Combien de composantes dans le champ */
if ((ncomp = MEDnChamp(fid,i)) < 0) {
MESSAGE("Erreur a lecture du nombre de composante du champ");
return -1;
}
/* Lecture des infos sur le champ */
if (MEDchampInfo(fid,i,nom,&type,comp,unit,ncomp) < 0) {
MESSAGE("Erreur a la lecture des informations sur le champ");
return -1;
}
printf("Champ de nom [%s] de type %d et avec "IFORMAT" composantes \n",nom,type,ncomp);
}
/* On demonte le fichier */
if (MEDdemonter(fid,mid,MED_CHAMP) < 0) {
MESSAGE("Echec du demontage de test10.med");
return -1;
}
printf("On demonte le fichier test10.med dans test20-0.med\n");
/* Combien de champs dans le fichier "test20-0.med" apres le demontage */
if ((ncha = MEDnChamp(fid,0)) < 0) {
MESSAGE("Erreur a la lecture du nombre de champ");
return -1;
}
printf("Nombre de champs dans test20-0.med apres demontage: "IFORMAT" \n",ncha);
/* On ferme le fichier test20-0.med */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur lors de la fermeture du fichier");
return -1;
}
printf("On ferme le fichier test20-0.med \n");
/* Creation du fichier test20.med */
if ((fid = MEDouvrir("test20.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test20.med");
return -1;
}
printf("On cree le fichier test20.med \n");
/* Montage dans test20.med de tous les maillages de test20-0.med */
mid2 = MEDmonter(fid,"test20-0.med",MED_MAILLAGE);
if (mid2 < 0) {
MESSAGE("Echec du montage de test20-0.med");
return -1;
}
printf("On monte les maillages du fichier test20-0.med dans le fichier test20.med \n");
/* Lecture du nombre de maillages */
nmaa = MEDnMaa(fid);
if (nmaa < 0) {
MESSAGE("Erreur lors de la lecture du nombre de maillage");
return -1;
}
printf("Nombre de maillages apres montage de test20-0.med : "IFORMAT"\n",nmaa);
/* Montage dans test20.med de tous les champs de test10.med */
mid = MEDmonter(fid,"test10.med",MED_CHAMP);
if (mid < 0) {
MESSAGE("Echec du montage de test10.med");
return -1;
}
printf("On monte les champs du fichier test10.med dans le fichier test20.med \n");
/* Combien de champs dans le fichier "test20.med" apres le montage */
if ((ncha = MEDnChamp(fid,0)) < 0) {
MESSAGE("Erreur lors de la lecture du nombre de champ");
return -1;
}
printf("Nombre de champs dans test20.med apres montage : "IFORMAT" \n",ncha);
/* Demontage du fichier test10.med */
if (MEDdemonter(fid,mid,MED_CHAMP) < 0) {
MESSAGE("Echec du demontage de test10.med");
return -1;
}
printf("On demonte le fichier test10.med dans test20.med \n");
/* Demontage du fichier test20-0.med */
if (MEDdemonter(fid,mid2,MED_MAILLAGE) < 0) {
MESSAGE("Echec du demontage de test20-0.med");
return -1;
}
printf("On demonte le fichier test20-0.med dans test20.med\n");
/* Fermeture du fichier test20.med */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur de la fermeture du fichier");
return -1;
}
printf("On ferme le fichier test20.med \n");
return 0;
}
int main (int argc, char **argv)
{
med_err ret;
med_idt fid;
char nom_scalaire1[MED_TAILLE_NOM+1] = "VariableEntiere";
char description1[MED_TAILLE_DESC+1] = "Une premiere description";
char nom_scalaire2[MED_TAILLE_NOM+1] = "VariableFlottante";
char description2[MED_TAILLE_DESC+1] = "Une seconde description";
med_int vali1 = 56;
med_int vali2 = -789;
med_float valr1 = 67.98;
/* Creation du fichier test21.med */
if ((fid = MEDouvrir("test21.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test21.med");
return -1;
}
/* Creation d'un variable scalaire entiere */
if (MEDscalaireCr(fid,nom_scalaire1,MED_INT,description1) < 0) {
MESSAGE("Erreur a la creation d'une variable scalaire entière");
return -1;
}
printf("Creation d'une variable scalaire entiere \n");
/* Ecriture d'un valeur sans pas de temps et sans numero d'ordre*/
if (MEDscalaireEntierEcr(fid,nom_scalaire1,vali1,MED_NOPDT,"",0.0,MED_NONOR) < 0) {
MESSAGE("Erreur a l'ecriture d'une valeur entiere");
return -1;
}
printf("Ecriture d'une valeur entiere sans pas de temps \n");
/* Ecriture d'une valeur entiere avec 1 pas de temps et sans numero d'ordre */
if (MEDscalaireEntierEcr(fid,nom_scalaire1,vali2,1,"ms",5.5,MED_NONOR) < 0) {
MESSAGE("Erreur a l'ecriture d'une valeur entiere");
return -1;
}
printf("Ecriture d'une valeur entiere avec pas de temps \n");
/* Creation d'un variable scalaire flottante */
if (MEDscalaireCr(fid,nom_scalaire2,MED_FLOAT64,description2) < 0) {
MESSAGE("Erreur a la creation d'une variable scalaire flottante");
return -1;
}
printf("Creation d'une variable scalaire flottante \n");
/* Ecriture d'une valeur reelle avec 1 pas de temps et 1 numero d'ordre */
if (MEDscalaireFlottantEcr(fid,nom_scalaire2,valr1,1,"ms",5.5,2) < 0) {
MESSAGE("Erreur a l'ecriture d'une valeur flottante");
return -1;
}
printf("Ecriture d'une valeur reelle avec pas de temps et numero d'ordre \n");
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
med_idt fid;
char maa[MED_TAILLE_NOM+1] = "maa1";
med_int mdim = 3;
med_int n=2;
/* connectivite nodale */
med_int indexp[3] = {1,5,9};
med_int np = 3;
med_int indexf[9] = {1,4,7,10,13,16,19,22,25};
med_int nf = 9;
med_int conn[24] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,
20,21,22,23,24};
/* connectivite descendante */
med_int indexp2[3] = {1,5,9};
med_int np2 = 3;
med_int conn2[8] = {1,2,3,4,5,6,7,8};
med_int indexf2[8] = {MED_TRIA3,MED_TRIA3,MED_TRIA3,MED_TRIA3,
MED_TRIA3,MED_TRIA3,MED_TRIA3,MED_TRIA3};
med_int nf2=8;
/* 12345678901234561234567890123456*/
char nom[MED_TAILLE_PNOM*2+1]="polyedre1 polyedre2 ";
med_int num[2] = {1,2};
med_int fam[2] = {0,-1};
/* Creation du fichier test25.med */
if ((fid = MEDouvrir("test25.med",MODE_ACCES)) < 0) {
MESSAGE("Erreur a la creation du fichier test25.med");
return -1;
}
printf("Creation du fichier test25.med \n");
/* Creation du maillage */
if (MEDmaaCr(fid,maa,mdim,MED_NON_STRUCTURE,
"un maillage pour test25") < 0) {
MESSAGE("Erreur a la creation du maillage");
return -1;
}
printf("Creation du maillage \n");
/* Ecriture des connectivites des mailles polyedres en mode nodal */
if (MEDpolyedreConnEcr(fid,maa,indexp,np,indexf,nf,conn,MED_NOD) < 0) {
MESSAGE("Erreur a l'ecriture de la connectivite des mailles MED_POLYEDRE");
return -1;
}
printf("Ecriture des connectivites de mailles de type MED_POLYEDRE en mode nodal \n");
/* Ecriture des connectivites des mailles polyedres en mode descendant */
if (MEDpolyedreConnEcr(fid,maa,indexp2,np2,indexf2,nf2,conn2,MED_DESC) < 0) {
MESSAGE("Erreur a l'ecriture des connectivites des mailles MED_POLYEDRE en mode descendant");
return -1;
}
printf("Ecriture des connectivites de mailles de type MED_POLYEDRE en mode descendant \n");
/* Ecriture des noms des polyedres */
if (MEDnomEcr(fid,maa,nom,n,MED_MAILLE,MED_POLYEDRE) < 0) {
MESSAGE("Erreur a l'ecriture des noms des mailles MED_POLYEDRE");
return -1;
}
printf("Ecriture des noms des polyedres \n");
/* Ecriture des numeros des polyedres */
if (MEDnumEcr(fid,maa,num,n,MED_MAILLE,MED_POLYEDRE) < 0) {
MESSAGE("Erreur a l'ecriture des numeros des mailles MED_POLYEDRE");
return -1;
}
printf("Ecriture des numeros des polyedres \n");
/* Ecriture des numeros des familles des polyedres */
if (MEDfamEcr(fid,maa,fam,n,MED_MAILLE,MED_POLYEDRE) < 0) {
MESSAGE("Erreur a l'ecriture des familles des mailles MED_POLYEDRE");
return -1;
}
printf("Ecriture des numeros des familles des polyedres \n");
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
printf("Fermeture du fichier test25.med \n");
return 0;
}
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
/* la dimension du maillage */
med_int mdim = 2;
/* nom du maillage de longueur maxi MED_TAILLE_NOM */
char maa[MED_TAILLE_NOM+1] = "maa1";
/* le nombre de noeuds */
med_int nnoe = 4;
/* table des coordonnees
profil : (dimension * nombre de noeuds) */
med_float coo[8] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0};
/* tables des noms et des unites des coordonnees
profil : (dimension*MED_TAILLE_PNOM+1) */
/* 12345678901234561234567890123456*/
char nomcoo[2*MED_TAILLE_PNOM+1] = "x y ";
char unicoo[2*MED_TAILLE_PNOM+1] = "cm cm ";
/* tables des noms, numeros, numeros de familles des noeuds
autant d'elements que de noeuds - les noms ont pout longueur
MED_TAILLE_PNOM */
/* 1234567890123456123456789012345612345678901234561234567890123456*/
char nomnoe[4*MED_TAILLE_PNOM+1] = "nom1 nom2 nom3 nom4 ";
med_int numnoe[4] = {1,2,3,4};
med_int nufano[4] = {0,1,2,2};
/* Creation du fichier "test4.med" */
fid = MEDouvrir("test4.med",MODE_ACCES);
if (fid < 0) {
MESSAGE("Erreur a la creation du fichier test4.med");
return -1;
}
/* Creation du maillage "maa" de type MED_NON_STRUCURE
et de dimension 2 */
if (MEDmaaCr(fid,maa,mdim,MED_NON_STRUCTURE,
"un maillage pour test4") < 0) {
MESSAGE("Erreur a la creation du maillage : "); SSCRUTE(maa);
ret = -1;
}
/* Ecriture des coordonnees des noeuds en mode MED_FULL_INTERLACE :
(X1,Y1, X2,Y2, X3,Y3, ...) dans un repere cartesien */
if (MEDcoordEcr(fid,maa,mdim,coo,MED_FULL_INTERLACE,nnoe,
MED_CART,nomcoo,unicoo) < 0) {
MESSAGE("Erreur a l'ecriture des coordonnees des noeuds");
ret = -1;
}
/* Ecriture des noms des noeuds (optionnel dans un maillage MED) */
if (MEDnomEcr(fid,maa,nomnoe,nnoe,MED_NOEUD,0) < 0) {
MESSAGE("Erreur a l'ecriture des noms des noeuds");
ret = -1;
}
/* Ecriture des numeros des noeuds (optionnel dans un maillage MED) */
if (MEDnumEcr(fid,maa,numnoe,nnoe,MED_NOEUD,0) < 0) {
MESSAGE("Erreur a l'ecriture des numeros des noeuds");
ret = -1;
}
/* Ecriture des numeros de famille des noeuds */
if (MEDfamEcr(fid,maa,nufano,nnoe,MED_NOEUD,0) < 0) {
MESSAGE("Erreur a l'ecriture des numeros de familles des noeuds");
ret = -1;
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier test4.med");
return -1;
}
return ret;
}
int main (int argc, char **argv)
{
med_idt fid;
med_int nse2 = 5;
med_int se2[10] = {1,2,1,3,2,4,3,4,2,3};
/* 12345678901234561234567890123456123456789012345612345678901234561234567890123456 */
char nomse2[MED_TAILLE_PNOM*5+1]="se1 se2 se3 se4 se5 ";
med_int numse2[5] = {1,2,3,4,5};
med_int nufase2[5] = {-1,-1,0,-2,-3};
med_int ntr3 = 2;
med_int tr3[6] = {1,2,-5,-5,3,-4};
/* 1234567890123456123456789012345612345678901234561234567890123456 */
/* Erreur sur la taille de tr1, il manque deux blancs.*/
char nomtr3[MED_TAILLE_PNOM*2+1] = "tr1 tr2 ";
med_int numtr3[2] = {4,5};
med_int nufatr3[2] = {0,-1};
char maa[MED_TAILLE_NOM+1] = "maa1";
med_int mdim = 2;
/* Creation du fichier test16.med */
if ( (fid = MEDouvrir("test16.med",MODE_ACCES) ) < 0) {
MESSAGE("Impossible de creer le fichier test16.med : ");
return -1;
}
/* Creation du maillage */
if ( MEDmaaCr(fid,maa,mdim,MED_NON_STRUCTURE,
"un maillage pour test16") < 0 ) {
MESSAGE("Impossible de creer le maillage : ");
return -1;
}
/* Ecriture des aretes segments MED_SEG2 :
- connectivite
- noms (optionnel)
- numeros (optionnel)
- numeros des familles */
if ( MEDelementsEcr(fid,maa,mdim,se2,MED_NO_INTERLACE,nomse2,MED_VRAI,numse2,MED_VRAI,
nufase2,nse2,MED_ARETE,MED_SEG2,MED_DESC)< 0 ) {
MESSAGE("Impossible d'ecrire la connectivité des aretes : ");
return -1;
}
/* Ecriture des mailles MED_TRIA3 :
- Connectivite
- Noms (optionnel)
- Numeros (optionnel)
- Numeros des familles */
if ( MEDelementsEcr(fid,maa,mdim,tr3,MED_NO_INTERLACE,nomtr3,MED_VRAI,numtr3,MED_VRAI,
nufatr3,ntr3,MED_MAILLE,MED_TRIA3,MED_DESC) < 0 ) {
MESSAGE("Impossible d'ecrire les éléments triangles : ");
return -1;
}
/* Fermeture du fichier */
if ( MEDfermer(fid) < 0) {
MESSAGE("Impossible de fermerle fichier : ");
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
char maa[MED_TAILLE_NOM+1];
med_int nmaa,i,mdim,npoly,j;
char desc[MED_TAILLE_DESC+1];
med_int taille,nf,np;
med_int taille2,nf2,np2;
med_int *conn, *conn2, *indexf, *indexf2, *num, *fam;
med_int *indexp, *indexp2;
char *nom;
char tmp[MED_TAILLE_PNOM+1];
int ind1, ind2,k,nfaces,nnoeuds,l;
med_maillage type;
/* Ouverture du fichier test25.med en lecture seule */
fid = MEDouvrir("test25.med",MED_LECTURE);
if (fid < 0) {
MESSAGE("Erreur a l'ouverture du fichier test25.med");
return -1;
}
printf("Ouverture du fichier test25.med \n");
/* Lecture du nombre de maillages */
nmaa = MEDnMaa(fid);
if (nmaa < 0) {
MESSAGE("Erreur a lecture du nombre de maillage");
return -1;
}
printf("Nombre de maillages = "IFORMAT"\n",nmaa);
for (i=0;i<nmaa;i++)
if (ret == 0) {
/* Lecture des infos sur le maillage */
if (MEDmaaInfo(fid,i+1,maa,&mdim,&type,desc) < 0) {
MESSAGE("Erreur a lecture des infos sur le maillage");
return -1;
}
printf("maillage "IFORMAT" de nom [%s] et de dimension : "IFORMAT" \n",i+1,maa,mdim);
/* Combien de mailles polyedres en mode nodal */
if ((npoly = MEDnEntMaa(fid,maa,MED_CONN,MED_MAILLE,MED_POLYEDRE,MED_NOD)) < 0) {
MESSAGE("Erreur a lecture du nombre de maille MED_POLYEDRE en mode nodal");
return -1;
}
printf("Nombre de mailles polyedres : "IFORMAT" \n",npoly);
/* Quelle taille pour le tableau des connectivites et d'indexation
en mode MED_NOD */
if (MEDpolyedreInfo(fid,maa,MED_NOD,&nf,&taille) < 0) {
MESSAGE("Erreur a lecture des infos sur les polyedres");
return -1;
}
printf("Taille a allouer pour la connectivite nodale des polyedres : "IFORMAT" \n",taille);
printf("Taille a allouer pour le tableau d'indexation des faces : "IFORMAT" \n",nf);
/* Quelle taille pour le tableau des connectivites et d'indexation
en mode MED_DESC */
if (MEDpolyedreInfo(fid,maa,MED_DESC,&nf2,&taille2) < 0) {
MESSAGE("Erreur a la lecture des infos sur les polyedres");
return -1;
}
printf("Taille a allouer pour la connectivite descendante des polyedres : "IFORMAT" \n",taille2);
printf("Taille a allouer pour le tableau d'indexation des types de faces : "IFORMAT" \n",nf2);
/* Allocation memoire :
* - tableau indexp et indexp2 : npoly + 1
* - tableau indexf et indexf2 : nf et nf2
* - tableau des connectivites : consize
* - tableaux numeros et numeros de familles : npoly
* - tableau des noms : MED_TAILLE_PNOM*npoly + 1
*/
indexp = (med_int *) malloc(sizeof(med_int)*(npoly+1));
indexp2 = (med_int *) malloc(sizeof(med_int)*(npoly+1));
indexf = (med_int *) malloc(sizeof(med_int)*nf);
indexf2 = (med_int *) malloc(sizeof(med_int)*nf2);
conn = (med_int *) malloc(sizeof(med_int)*taille);
conn2 = (med_int *) malloc(sizeof(med_int)*taille2);
num = (med_int *) malloc(sizeof(med_int)*npoly);
fam = (med_int *) malloc(sizeof(med_int)*npoly);
nom = (char *) malloc(sizeof(char)*MED_TAILLE_PNOM*npoly+1);
/* Lecture de la connectivite des mailles polyedres en mode nodal */
if (MEDpolyedreConnLire(fid,maa,indexp,npoly+1,indexf,nf,conn,MED_NOD) < 0) {
MESSAGE("Erreur a lecture de la connectivite nodale des polyedres");
ret = -1;
}
printf("Lecture de la connectivite des mailles MED_POLYEDRE en mode nodal \n");
/* Lecture de la connectivite des mailles polyedres en mode descendant */
if (ret == 0) {
if (MEDpolyedreConnLire(fid,maa,indexp2,npoly+1,indexf2,nf2,conn2,MED_DESC) < 0) {
MESSAGE("Erreur a lecture de la connectivite descendante des polyedres");
ret = -1;
}
printf("Lecture de la connectivite des mailles MED_POLYEDRE en mode descendant \n");
}
/* Lecture noms */
if (ret == 0) {
if (MEDnomLire(fid,maa,nom,npoly,MED_MAILLE,MED_POLYEDRE) < 0) {
MESSAGE("Erreur a lecture des noms des polyedres");
ret = -1;
}
printf("Lecture des noms des mailles MED_POLYEDRE \n");
}
/* Lecture des numeros */
if (ret == 0) {
if (MEDnumLire(fid,maa,num,npoly,MED_MAILLE,MED_POLYEDRE) < 0) {
MESSAGE("Erreur a lecture des numeros des polyedres");
ret = -1;
}
printf("Lecture des numeros des mailles MED_POLYEDRE \n");
}
/* Lecture des numeros de familles */
if (ret == 0) {
if (MEDfamLire(fid,maa,fam,npoly,MED_MAILLE,MED_POLYEDRE) < 0) {
MESSAGE("Erreur a lecture des numeros de famille des polyedres");
ret = -1;
}
printf("Lecture des numeros de familles des mailles MED_POLYEDRE \n");
}
if (ret == 0) {
printf("Affichage des resultats \n");
for (j=0;j<npoly;j++) {
printf(">> Maille MED_POLYEDRE "IFORMAT" : \n",j+1);
printf("---- Connectivite nodale ----- : \n");
nfaces = *(indexp+j+1) - *(indexp+j);
/* ind1 = indice dans "indexf" pour acceder aux numeros des faces */
ind1 = *(indexp+j) - 1;
for (k=0;k<nfaces;k++) {
/* ind2 = indice dans "conn" pour acceder au premier noeud de la face */
ind2 = *(indexf+ind1+k) - 1;
nnoeuds = *(indexf+ind1+k+1) - *(indexf+ind1+k);
printf(" - Face %d : [ ", k+1);
for (l=0;l<nnoeuds;l++)
printf(" "IFORMAT" ",*(conn+ind2+l));
printf(" ] \n");
}
printf("---- Connectivite descendante ----- : \n");
nfaces = *(indexp2+j+1) - *(indexp2+j);
/* ind1 = indice dans "conn2" pour acceder aux numeros des faces */
ind1 = *(indexp2+j) - 1;
for (k=0;k<nfaces;k++)
printf(" - Face %d de numero : "IFORMAT" et de type "IFORMAT" \n", k+1,*(conn2+ind1+k),*(indexf2+ind1+k));
strncpy(tmp,nom+j*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
tmp[MED_TAILLE_PNOM] = '\0';
printf("---- Nom ----- : %s \n",tmp);
printf("---- Numero ----- : "IFORMAT" \n",*(num+j));
printf("---- Numero de famille ----- : "IFORMAT" \n",*(fam+j));
}
}
/* liberation de la memoire */
free(indexp);
free(indexp2);
free(indexf);
free(indexf2);
free(conn);
free(conn2);
free(num);
free(fam);
free(nom);
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a fermeture du fichier");
return -1;
}
printf("Fermeture du fichier \n");
return ret;
}
int main (int argc, char **argv)
{
med_err ret = 0;
med_idt fid;
med_int nse2;
med_int *se2_1;
med_int *se2_2;
char *nomse2;
med_int *numse2;
med_int *nufase2;
med_int ntr3;
med_int *tr3;
char *nomtr3;
med_int *numtr3;
med_int *nufatr3;
char maa[MED_TAILLE_NOM+1] ="maa1";
med_int mdim = 2;
med_booleen inoele,inuele;
med_int tse2,ttr3;
med_int i;
char str[MED_TAILLE_PNOM+1];
med_int profil[2] = { 2, 3 };
char desc[MED_TAILLE_DESC+1];
med_maillage type;
/* Ouverture du fichier en mode lecture seule */
if ((fid = MEDouvrir("test6.med",MED_LECTURE)) < 0) {
MESSAGE("Erreur a l'ouverture du fichier test6.med");
return -1;
}
/* Lecture des informations sur le premier maillage */
if (MEDmaaInfo(fid,1,maa,&mdim,&type,desc) < 0) {
MESSAGE("Erreur a la lecture des information sur le 1er maillage");
return -1;
} else
printf("Maillage de nom : %s et de dimension %d \n",maa,mdim);
/* Combien de triangles et de segments */
if ((nse2 = MEDnEntMaa(fid,maa,MED_CONN,MED_ARETE,MED_SEG2,MED_DESC)) < 0) {
MESSAGE("Erreur a la lecture du nombre de faces MED_SEG2");
return -1;
}
if ((ntr3 = MEDnEntMaa(fid,maa,MED_CONN,MED_MAILLE,MED_TRIA3,MED_DESC))<0) {
MESSAGE("Erreur a la lecture du nombre de mailles MED_TRIA3");
return -1;
}
printf("Nombre de MED_SEG2 : "IFORMAT" - nombre de MED_TRIA3 : "IFORMAT"\n",nse2,ntr3);
/* Allocations memoire */
tse2 = 2;
se2_1 = (med_int*) calloc(tse2*nse2,sizeof(med_int));
se2_2 = (med_int*) malloc(sizeof(med_int)*tse2*nse2);
nomse2 = (char*) malloc(MED_TAILLE_PNOM*nse2+1);
numse2 = (med_int*) malloc(sizeof(med_int)*nse2);
nufase2 = (med_int*) malloc(sizeof(med_int)*nse2);
ttr3 = 3;
tr3 = (med_int*) malloc(sizeof(med_int)*ntr3*ttr3);
nomtr3 = (char*) malloc(MED_TAILLE_PNOM*ntr3+1);
numtr3 = (med_int*) malloc(sizeof(med_int)*ntr3);
nufatr3 = (med_int*) malloc(sizeof(med_int)*ntr3);
/* Lecture des connectivites des segments avec profil */
if (MEDconnLire(fid,maa,mdim,se2_1,MED_FULL_INTERLACE,profil,2,
MED_ARETE,MED_SEG2,MED_DESC) < 0) {
MESSAGE("Erreur a la lecture de la connectivite des segments");
return -1;
}
/* Lecture de la connectivite des segments */
if (MEDconnLire(fid,maa,mdim,se2_2,MED_FULL_INTERLACE,NULL,0,
MED_ARETE ,MED_SEG2,MED_DESC) < 0) {
MESSAGE("Erreur a la lecture de la connectivite des segments");
return -1;
}
/* Lecture (optionnelle) des noms des segments */
if (MEDnomLire(fid,maa,nomse2,nse2,MED_ARETE,MED_SEG2) < 0)
inoele = MED_FAUX;
else
inoele = MED_VRAI;
/* Lecture (optionnelle) des numeros des segments */
if (MEDnumLire(fid,maa,numse2,nse2,MED_ARETE,MED_SEG2) < 0)
inuele = MED_FAUX;
else
inuele = MED_VRAI;
/* Lecture des numeros des familles des segments */
if (MEDfamLire(fid,maa,nufase2,nse2,MED_ARETE,MED_SEG2) < 0) {
MESSAGE("Erreur a la lecture des numéros de famille des segments");
return -1;
}
/* Lecture de la connectivite des triangles */
if (MEDconnLire(fid,maa,mdim,tr3,MED_NO_INTERLACE,NULL,0,MED_MAILLE,MED_TRIA3,
MED_DESC) < 0) {
MESSAGE("Erreur a la lecture de la connectivite des triangles");
return -1;
}
/* Lecture (optionnelle) des noms des triangles */
if (MEDnomLire(fid,maa,nomtr3,ntr3,MED_MAILLE,MED_TRIA3) < 0)
inoele = MED_FAUX;
else
inoele = MED_VRAI;
/* Lecture (optionnelle) des numeros des triangles */
if (MEDnumLire(fid,maa,numtr3,ntr3,MED_MAILLE,MED_TRIA3) < 0)
inuele = MED_FAUX;
else
inuele = MED_VRAI;
/* Lecture des numeros des familles des triangles */
if (ret = MEDfamLire(fid,maa,nufatr3,ntr3,MED_MAILLE,MED_TRIA3) < 0) {
MESSAGE("Erreur a la lecture des numeros de famille des segments");
return -1;
}
/* Fermeture du fichier */
if (MEDfermer(fid) < 0) {
MESSAGE("Erreur a la fermeture du fichier");
return -1;
}
/* Affichage */
if (ret == 0) {
printf("Connectivite des segments (1): \n");
for (i=0;i<nse2*tse2;i++)
printf(IFORMAT" ",*(se2_1+i));
printf("\n");
printf("Connectivite des segments (2): \n");
for (i=0;i<nse2*tse2;i++)
printf(IFORMAT" ",*(se2_2+i));
if (inoele) {
printf("\nNoms des segments :\n");
for (i=0;i<nse2;i++) {
strncpy(str,nomse2+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
str[MED_TAILLE_PNOM] = '\0';
printf("%s ",str);
}
}
if (inuele) {
printf("\nNumeros des segments :\n");
for (i=0;i<nse2;i++)
printf(IFORMAT" ",*(numse2+i));
}
printf("\nNumeros des familles des segments :\n");
for (i=0;i<nse2;i++)
printf(IFORMAT" ",*(nufase2+i));
printf("\nConnectivite des triangles : \n");
for (i=0;i<ntr3*ttr3;i++)
printf(IFORMAT" ",*(tr3+i));
if (inoele) {
printf("\nNoms des triangles :\n");
for (i=0;i<ntr3;i++) {
strncpy(str,nomtr3+i*MED_TAILLE_PNOM,MED_TAILLE_PNOM);
str[MED_TAILLE_PNOM] = '\0';
printf("%s ",str);
}
}
if (inuele) {
printf("\nNumeros des triangles :\n");
for (i=0;i<ntr3;i++)
printf(IFORMAT" ",*(numtr3+i));
}
printf("\nNumeros des familles des triangles :\n");
for (i=0;i<ntr3;i++)
printf(IFORMAT" ",*(nufatr3+i));
printf("\n");
}
/* Nettoyage memoire */
free(se2_1);
free(se2_2);
free(nomse2);
free(numse2);
free(nufase2);
free(tr3);
free(nomtr3);
free(numtr3);
free(nufatr3);
return ret;
}