/*
* - Nom de la fonction : _MEDfichierCreer
* - Description : creation d'un fichier HDF
* - Parametres :
* - nom (IN) : le nom du fichier
* - Resultat : ID du fichier en cas de succes, -1 sinon
*/
med_idt _MEDfichierCreer(char *nom, med_mode_acces mode)
{
med_idt fid,gid;
med_err ret;
med_int majeur = 2;
med_int mineur = 3;
med_int release = 6;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ((fid = H5Fcreate(nom,H5F_ACC_TRUNC,
H5P_DEFAULT,H5P_DEFAULT)) < 0)
return -1;
_MEDsetModeAcces(fid,MED_LECTURE_ECRITURE);
if ((gid = _MEDdatagroupCreer(fid,MED_INFOS)) < 0)
return -1;
/* Numero de versions de MED */
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MAJEUR,&majeur)) < 0)
return -1;
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MINEUR,&mineur)) < 0)
return -1;
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_RELEASE,&release)) < 0)
return -1;
/* On ferme tout */
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
_MEDsetModeAcces(fid,mode);
return fid;
}
med_err
MEDnbnosoEcr(med_idt fid, char *nom_maillage,med_int n)
{
med_idt maaid;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_err ret;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,nom_maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Creation de l'attribut "Nombre de Noeuds Sommets"
*/
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNS,&n)) < 0)
return -1;
/*
* Fermetures
*/
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
med_err
MEDscalaireCr(med_idt fid,char *scalaire, med_type_champ type, char *desc)
{
med_err ret=-1;
med_idt root=0,gid=0;
char chemin[MED_TAILLE_NUM_DATA+1];
med_int _type = (med_int) type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer une variable scalaire en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Groupe HDF "/NUM_DATA" n'existe pas, on le cree
*/
strncpy(chemin,MED_NUM_DATA,MED_TAILLE_NUM_DATA-1);
chemin[MED_TAILLE_NUM_DATA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0){
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si le groupe HDF "scalaire" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(scalaire,ERROR);
if ((gid = _MEDdatagroupCreer(root,scalaire)) < 0) {
MESSAGE("Erreur à la création de la variable scalaire : ");
SSCRUTE(scalaire);
goto ERROR;
}
/*
* On stocke l'unite, et le type de la valeur scalaire
*/
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type)) < 0) {
MESSAGE("Erreur à l'écriture du type de la varaible scalaire : ");
ISCRUTE(_type);
goto ERROR;
}
if ((ret = _MEDattrStringEcrire(gid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description de la variable scalaire : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* On ferme tout
*/
ret = 0;
ERROR:
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret=-1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret=-1;
}
return ret;
}
med_err
MEDdimEspaceCr(med_idt fid, char *maillage, med_int dim)
{
med_idt maaid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_int maadim;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un maillage en mode MED_LECTURE.");
goto ERROR;
};
/*
* On regarde si le groupe existe => erreur si non
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Erreur à l'ouverture du maillage : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* On va lire l'attribut dimension du maillage et on controle
* la coherence
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&maadim)) < 0) {
MESSAGE("Erreur à la lecture de la dimension du maillage : ");
ISCRUTE(maadim);
goto ERROR;
}
if (maadim > dim) {
MESSAGE("La dimension de l'espace : ");
ISCRUTE(dim);
MESSAGE("doit être supérieur à la dimension du maillage : ");
ISCRUTE(maadim);
goto ERROR;
}
/*
* On ecrit la dimension de l'espace
*/
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_ESP,&dim)) < 0) {
MESSAGE("Erreur à l'écriture de la dimension de l'espace : ");
ISCRUTE(dim);
goto ERROR;
}
/*
* Fermetures des objets HDF
*/
ret = 0;
ERROR:
if (maaid>0) if (_MEDdatagroupFermer(maaid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(maaid);ret = -1;
}
return ret;
}
void
MEDjointCr231(int dummy,...) {
med_idt fid ;
char * maa_lcl ;
char * jn ;
char * desc ;
med_int dom ;
char * maa_dist ;
med_err * fret ;
med_idt root=0,jntid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_JNT+1];
med_int nbc=0;
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params,med_idt);
maa_lcl = va_arg(params,char *);
jn = va_arg(params,char *);
desc = va_arg(params,char *);
dom = va_arg(params,med_int);
maa_dist = va_arg(params,char*);
fret = va_arg(params,med_err *);
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un joint en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group "JNT" n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
NOFINALBLANK(maa_lcl,ERROR);
strcat(chemin,maa_lcl);
strncpy(tmp,MED_JNT,MED_TAILLE_JNT-1);
tmp[MED_TAILLE_JNT-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si un joint du meme nom existe => erreur
* Sinon on le cree
*/
NOFINALBLANK(jn,ERROR);
if ((jntid = _MEDdatagroupCreer(root,jn)) < 0) {
MESSAGE("Erreur à la création du joint : ");
SSCRUTE(jn);
goto ERROR;
}
/*
* L'attribut "DES"
*/
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description du joint : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* L'attribut "MAI"
*/
/* BUG CORRIGE EN 232 MED_TAILLE_NOM au lieu de MED_TAILLE_MAA */
/* conservé ici pour éviter de reprendre en lib2.3.2 un fichier 2.3.1
en écrivant l'attribut avec une taille plus grande que celle des fichiers 2.3.1 */
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_MAI,MED_TAILLE_MAA,maa_dist)) < 0) {
MESSAGE("Erreur à l'écriture du nom du maillage distant : ");
SSCRUTE(maa_dist);
goto ERROR;
}
/*
* L'attribut "DOM"
*/
if ((ret = _MEDattrEntierEcrire(jntid,MED_NOM_DOM,&dom)) < 0) {
MESSAGE("Erreur à l'écriture du domaine : ");
ISCRUTE(dom);
goto ERROR;
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (jntid>0) if (_MEDdatagroupFermer(jntid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(jntid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
med_err
MEDscalaireEntierEcr(med_idt fid, char *scalaire,med_int val, med_int numdt, char *dt_unit, med_float dt, med_int numo)
{
med_err ret = 0;
med_idt gid,datagroup;
char nomdatagroup[2*MED_MAX_PARA+1];
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1];
med_int type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier ");
return -1;
}
/*
* Si le groupe HDF "scalaire" n'existe pas => erreur
*/
strcpy(chemin,MED_NUM_DATA);
strcat(chemin,scalaire);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/* Creation du groupe HDF correspondant au couple <numdt>.<numoo> */
sprintf(nomdatagroup,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
/* Cree ou ouvre le datagroup nomdatagroup */
datagroup = 0;
if (((datagroup = _MEDdatagroupOuvrir(gid,nomdatagroup)) > 0)
&& ( MED_MODE_ACCES == MED_LECTURE_AJOUT ))
return -1;
else
if (datagroup < 0)
if ((datagroup = _MEDdatagroupCreer(gid,nomdatagroup)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_NDT */
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NDT,&numdt)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_PDT */
if ((ret = _MEDattrFloatEcrire(datagroup,MED_NOM_PDT,&dt)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_NOR */
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NOR,&numo)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_UNI */
if ( numdt == MED_NOPDT ) {
if ((ret = _MEDattrStringEcrire(datagroup,MED_NOM_UNI,MED_TAILLE_PNOM,MED_PNOM_BLANC)) < 0)
return -1;
} else
if ((ret = _MEDattrStringEcrire(datagroup,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0)
return -1;
/*
* Ecriture de la valeur scalaire
*/
if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,&type)) < 0)
return -1;
switch(type)
{
case MED_INT :
case MED_INT32 :
case MED_INT64 :
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_VAL,&val)) < 0)
return -1;
break;
default :
return -1;
}
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}
med_err
MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch,
med_int nbre, med_entite_maillage type_ent,
med_geometrie_element type_geo,med_connectivite type_conn)
{
med_idt maaid, entid, geoid, dataset;
med_err ret;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
char nom_ent[MED_TAILLE_NOM_ENTITE+1];
char nom_geo[MED_TAILLE_NOM_ENTITE+1];
char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
int dim, nnoe, ndes;
int taille;
med_entite_maillage _type_ent=type_ent;
if ( type_ent == MED_NOEUD_MAILLE ) _type_ent=MED_NOEUD ;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* On met a jour le nom du Data Group representant
* le type des entites
*/
if ((ret = _MEDnomEntite(nom_ent,_type_ent)) < 0)
return -1;
/*
* Si le Data Group des entites n'existe pas on le cree
*/
if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
return -1;
/*
* On cree s'il n'existe pas le Data Group du type geometrique
*/
if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
return -1;
if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
return -1;
/*
* On regarde si le Data Set existe et on le cree sinon
*/
if ((ret=_MEDparametresGeometrie(_type_ent,type_geo,&dim,&nnoe,&ndes))<0)
return -1;
switch(type_conn)
{
case MED_NOD :
strcpy(nom_dataset,MED_NOM_NOD);
taille = nnoe;
break;
case MED_DESC :
strcpy(nom_dataset,MED_NOM_DES);
taille = ndes;
break;
default :
return -1;
}
dimd[0] = nbre*taille;
#if defined(HAVE_F77INT64)
ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT64,mode_switch,(med_size)taille,MED_ALL,
MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) connectivite);
#else
ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT32,mode_switch,(med_size)taille,MED_ALL,
MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) connectivite);
#endif
if (ret < 0 ) {
MESSAGE("Impossible d'ecrire le dataset coon de taille : ");
ISCRUTE_int(taille); return -1;
}
/*
* Attribut NBR (nombre de noeuds ou d'elements)
*/
if ((dataset = _MEDdatasetOuvrir(geoid,nom_dataset)) < 0)
return -1;
if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&nbre)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(geoid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(entid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
med_err
MEDmaaCr(med_idt fid, char *maillage, med_int dim, med_maillage type,char *desc)
{
med_idt maaid=0, root=0, entid=0, geoid=0 ;
char chemin[MED_TAILLE_MAA+1];
char nom_ent[MED_TAILLE_NOM_ENTITE+1];
char nom_geo[MED_TAILLE_NOM_ENTITE+1];
med_err ret=-1;
med_int tmp;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un maillage en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si la racine n'existe pas on la cree
*/
strncpy(chemin,MED_MAA,strlen(MED_MAA)-1);
chemin[MED_TAILLE_MAA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Création du maillage
*/
NOFINALBLANK(maillage,ERROR);
if ( (maaid = _MEDdatagroupCreer(root,maillage)) < 0) {
MESSAGE("Erreur à la création du maillage : ");
SSCRUTE(maillage);
goto ERROR;
}
/*
* Creation de l'attribut dimension
*/
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_DIM,&dim)) < 0) {
MESSAGE("Erreur à l'écriture de la dimension du maillage : ");
ISCRUTE(dim);
goto ERROR;
}
/*
* La description associee au maillage
*/
if ((ret = _MEDattrStringEcrire(maaid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description du maillage : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* Creation de l'attribut correspondant au type du maillage (MED_STRUCTURE, MED_NON_STRUCTURE)
*/
tmp = (med_int) type;
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_TYP,&tmp)) < 0) {
MESSAGE("Erreur à l'écriture du type de maillage : ");
ISCRUTE(tmp);
goto ERROR;
}
if ( type == MED_STRUCTURE ) {
strcpy(nom_ent,MED_NOM_MAI);
if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) {
MESSAGE("Impossible de Cr\351er le datagroup :");
SSCRUTE(nom_ent);
MESSAGE("pour le maillage structur\351 :");
SSCRUTE(maillage);
goto ERROR;
}
switch ( dim ) {
case 1 : strcpy(nom_geo,MED_NOM_SE2);
break;
case 2 : strcpy(nom_geo,MED_NOM_QU4);
break;
case 3 : strcpy(nom_geo,MED_NOM_HE8);
break;
case 0 : strcpy(nom_geo,MED_NOM_PO1);
break;
default :
MESSAGE("La dimension doit être comprise entre 0 et 3");
goto ERROR;
}
if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) {
MESSAGE("Impossible de Créer le datagroup :");
SSCRUTE(nom_geo);
MESSAGE("pour le maillage structuré :");
SSCRUTE(maillage);
goto ERROR;
}
}
/*
* Nettoyages divers
*/
ret = 0;
ERROR:
if (geoid>0) if (_MEDdatagroupFermer(geoid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(geoid);ret = -1;
}
if (entid>0) if (_MEDdatagroupFermer(entid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(entid);ret = -1;
}
if (maaid>0) if (_MEDdatagroupFermer(maaid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(maaid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
return ret;
}
med_err
MEDjointEcr (med_idt fid, char *maa, char *jn, med_int *corrtab, med_int n,
med_entite_maillage type_ent_local, med_geometrie_element typ_geo_local,
med_entite_maillage type_ent_distant, med_geometrie_element typ_geo_distant)
{
med_entite_maillage _type_ent_local = (med_entite_maillage) ( (int)(type_ent_local) % 10 );
med_entite_maillage _type_ent_distant = (med_entite_maillage) ( (int)(type_ent_distant) % 10 );
med_idt corrid, datagroup;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+2*MED_TAILLE_NOM+1];
char nomdatagroup[MED_TAILLE_NOM+1+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_NOM_ENTITE+1];
med_size dimd[1];
med_mode_acces MED_MODE_ACCES;
/* if (typ_geo_local == MED_TETRA4 || typ_geo_local == MED_TETRA10 || */
/* typ_geo_local == MED_HEXA8 || typ_geo_local == MED_HEXA20 || */
/* typ_geo_local == MED_PENTA6 || typ_geo_local == MED_PENTA15 || */
/* typ_geo_local == MED_PYRA5 || typ_geo_local == MED_PYRA13 || */
/* typ_geo_distant == MED_TETRA4 || typ_geo_distant == MED_TETRA10 || */
/* typ_geo_distant == MED_HEXA8 || typ_geo_distant == MED_HEXA20 || */
/* typ_geo_distant == MED_PENTA6 || typ_geo_distant == MED_PENTA15 || */
/* typ_geo_distant == MED_PYRA5 || typ_geo_distant == MED_PYRA13) */
/* return -1; */
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier ");
return -1;
}
/*
* Si le Data Group de "JNT" n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
strcat(chemin,MED_JNT);
strcat(chemin,jn);
if ((corrid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE(chemin);
return -1;
}
/*
* Ecriture de la correspondance
* construction du tag HDF "reperant" la correspondance
*
*/
if ((ret = _MEDnomEntite(nomdatagroup,_type_ent_local)) < 0)
return -1;
if ((_type_ent_local != MED_NOEUD))
{
if ((ret = _MEDnomGeometrie(tmp,typ_geo_local)) < 0)
return -1;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
}
if ((ret = _MEDnomEntite(tmp,_type_ent_distant)) < 0)
return -1;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
if ((_type_ent_distant != MED_NOEUD))
{
if ((ret = _MEDnomGeometrie(tmp,typ_geo_distant)) < 0)
return -1;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
}
datagroup = 0;
/*
* Si la correspondance existe, on passe en mode
* ajout ?????????
*/
if (((datagroup = _MEDdatagroupOuvrir(corrid,nomdatagroup)) > 0) &&
( MED_MODE_ACCES == MED_LECTURE_AJOUT))
return -1;
else
if (datagroup > 0)
_MEDdatagroupFermer(datagroup);
if ((datagroup = _MEDdatagroupCreer(corrid,nomdatagroup)) < 0)
return -1;
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n)) < 0)
return -1;
dimd[0] = 2*n;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) corrtab)) < 0)
return -1;
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) corrtab)) < 0)
return -1;
#endif
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(corrid)) < 0)
return -1;
return 0;
}
void
MEDfamCr231(int dummy,...)
{
med_idt fid;
char *maa;
char *famille;
med_int numero;
med_int *attr_ident;
med_int *attr_val;
char *attr_desc;
med_int n_attr;
char *groupe;
med_int n_groupe;
med_err *fret ;
med_idt root=0, datagroup=0, famid=0;
med_err ret=-1;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_FAS_ENTITE+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_FAS+1];
char stockage[MED_TAILLE_FAS_ENTITE+1] = "NONE";
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params, med_idt );
maa = va_arg(params, char* );
famille = va_arg(params, char* );
numero = va_arg(params, med_int );
attr_ident = va_arg(params, med_int*);
attr_val = va_arg(params, med_int*);
attr_desc = va_arg(params, char* );
n_attr = va_arg(params, med_int );
groupe = va_arg(params, char* );
n_groupe = va_arg(params, med_int );
fret = va_arg(params, med_err*);
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE) {
MESSAGE("Impossible de créer une famille en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group FAS n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
/* BUG NON CORRIGE en 2.3.1 à cause
des noms de familles crées en F77
NOFINALBLANK(maa,ERROR);*/
strcat(chemin,maa);
strncpy(tmp,MED_FAS,MED_TAILLE_FAS-1);
tmp[MED_TAILLE_FAS-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Le lieu de stockage varie selon le signe du "numero"
* de famille
* = 0 => FAMILLE NEUTRE
* > 0 => FAMILLE DE NOEUD
* < 0 => FAMILLE DE MAILLE/FACE/ARETE
*/
if (numero != 0) {
if ((ret = _MEDdatagroupFermer(root)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret = -1;
goto ERROR;
}
if (numero > 0)
strncpy(stockage,MED_FAS_NOEUD,MED_TAILLE_FAS_ENTITE-1);
if (numero < 0)
strncpy(stockage,MED_FAS_ELEME,MED_TAILLE_FAS_ENTITE-1);
stockage[MED_TAILLE_FAS_ENTITE-1] = '\0';
strcat(chemin,stockage);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
}
/*
* Si le Data Group de meme nom que famille existe => erreur
* Sinon on le cree
*/
/*
* POUR LA FAMILLE DE NUMERO 0, ON FORCE LE NOM
*/
if (numero == 0)
strcpy(famille,FAMILLE_ZERO);
/*
* Création de la famille
*/
if ((famid = _MEDdatagroupCreer(root,famille)) < 0) {
MESSAGE("Erreur à la création du famille : ");
SSCRUTE(famille);
goto ERROR;
}
/*
* L'attribut NUM
*/
if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero)) < 0) {
MESSAGE("Erreur à l'écriture du numéro de famille : ");
ISCRUTE(numero);
goto ERROR;
}
/*
* Le Data Group "GRO"
*/
if (n_groupe > 0) {
/*
* On cree le Data Group
*/
if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(MED_NOM_GRO);
goto ERROR;
}
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe)) < 0) {
MESSAGE("Erreur à l'écriture du nombre de groupe : ");
ISCRUTE(n_groupe);
goto ERROR;
}
/*
* Data Set des noms des groupes "NOM"
*/
dimd[0] = n_groupe*MED_TAILLE_LNOM+1;
if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe))<0) {
MESSAGE("Erreur à l'écriture des noms des groupes : ");
SSCRUTE(groupe);
goto ERROR;
}
/*
* On ferme le Data Group
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup);
goto ERROR;
}
}
/*
* Le Data Group "ATT"
*/
if (n_attr > 0) {
if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(MED_NOM_ATT);
goto ERROR;
}
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr)) < 0) {
MESSAGE("Erreur à l'écriture du nombre d'attributs : ");
ISCRUTE(n_attr);
goto ERROR;
}
/*
* Le Data Set "IDE"
*/
dimd[0] = n_attr;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char *)attr_ident)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_IDE);
goto ERROR;
}
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char *)attr_ident)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_IDE);
goto ERROR;
}
#endif
/*
* Le Data Set "VAL"
*/
dimd[0] = n_attr;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*)attr_val)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_VAL);
goto ERROR;
}
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*)attr_val)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_VAL);
goto ERROR;
}
#endif
/*
* Le Data Set "DES"
*/
dimd[0] = n_attr*MED_TAILLE_DESC+1;
if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_DES);
goto ERROR;
}
/*
* On ferme le Data Group
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup);
goto ERROR;
}
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (famid>0) if (_MEDdatagroupFermer(famid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(famid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
void MAJ_21_22_maillages(med_idt fid)
{
med_idt gid;
med_err ret;
int n,i;
char nom[MED_TAILLE_NOM+1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
char description[MED_TAILLE_DESC+1] = "Maillage converti au format MED V2.2";
med_int type = (med_int) MED_NON_STRUCTURE;
med_int dimension;
/* Lecture du nombre de maillages */
n = 0;
_MEDnObjets(fid,(char *) MED_MAA,&n);
EXIT_IF(n < 0,"Erreur a la lecture du nombre de maillage",NULL);
/*
* Mise a jour des maillages :
* - type : MED_NON_STRUCTURE
* - description : "Maillage converti au format V2.2"
*/
for (i=0;i<n;i++) {
/* on recupere le nom du maillage */
ret = _MEDobjetIdentifier(fid,(char *) MED_MAA,i,nom);
EXIT_IF(ret < 0,"Identification d'un maillage",NULL);
fprintf(stdout," >>> Normalisation du maillage [%s] \n",nom);
/* on accede au maillage */
strcpy(chemin,MED_MAA);
strcat(chemin,nom);
gid = _MEDdatagroupOuvrir(fid,chemin);
EXIT_IF(gid < 0,"Accès au maillage",nom);
/* lecture de la dimension du maillage */
ret = _MEDattrEntierLire(gid,(char *)(MED_NOM_DIM),&dimension);
EXIT_IF(ret < 0,"Lecture de la dimension du maillage",nom);
/* Ecriture du type et de la description */
ret = _MEDattrStringEcrire(gid,(char *)(MED_NOM_DES),MED_TAILLE_DESC,description);
EXIT_IF(ret < 0,"Ecriture de la description du maillage ",nom);
ret = _MEDattrEntierEcrire(gid,(char *)(MED_NOM_TYP),&type);
EXIT_IF(ret < 0,"Ecriture de la dimension du maillage ",nom);
/* Mise a jour des noeuds du maillage */
MAJ_21_22_noeuds_maillage(gid,dimension);
fprintf(stdout," ... Normalisation des noeuds effectuée ... \n");
/* Mise a jour des éléments du maillage */
MAJ_21_22_elements_maillage(gid,dimension);
fprintf(stdout," ... Normalisation des éléments effectuée ... \n");
/* Mise a jour des familles du maillage */
MAJ_21_22_familles_maillage(gid);
fprintf(stdout," ... Normalisation des familles effectuée ... \n");
/* On ferme tout */
ret = _MEDdatagroupFermer(gid);
EXIT_IF(ret < 0,"Fermeture de l'accès au maillage",NULL);
fprintf(stdout," >>> Normalisation du maillage [%s] ... OK ... \n",nom);
}
}
med_err
MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *profilname)
{
med_idt gid, chid;
med_size dimd[1];
med_err ret=-1;
char chemin[MED_TAILLE_PROFILS+1];
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier ");
goto ERROR;
}
/*
* Si le groupe "PROFILS" n'existe pas, on le cree
*/
strncpy(chemin,MED_PROFILS,MED_TAILLE_PROFILS-1);
chemin[MED_TAILLE_PROFILS-1] = '\0';
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Impossible de creer le groupe MED_PROFILS : ");
SSCRUTE(chemin); goto ERROR;
}
/*
* Si le groupe "profilname" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(profilname,ERROR);
if ((chid = _MEDdatagroupOuvrir(gid,profilname)) >= 0) {
if ( MED_MODE_ACCES != MED_LECTURE_ECRITURE ) {
MESSAGE("Le profil existe déjà : ");
SSCRUTE(profilname); goto ERROR;
}
} else
if ((chid = _MEDdatagroupCreer(gid,profilname)) < 0)
goto ERROR;
/*
* On stocke "n" sous forme d'attribut
*/
if ((ret = _MEDattrEntierEcrire(chid,MED_NOM_NBR,&n)) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
ISCRUTE(n); goto ERROR;
};
/*
* On stocke le profil dans un dataset
*/
dimd[0] = n;
#if defined(HAVE_F77INT64)
ret = _MEDdatasetNumEcrire(chid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) pflval);
#else
ret = _MEDdatasetNumEcrire(chid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) pflval);
#endif
if (ret < 0 ) {
MESSAGE("Impossible d'ecrire le dataset pflval de taille : ");
ISCRUTE(n); goto ERROR;
}
ret = 0;
ERROR:
/*
* On ferme tout
*/
if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(chid); ret = -1;
}
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid); ret = -1;
}
return ret;
}
med_err
MEDgaussEcr(med_idt fid, med_geometrie_element type_geo, med_float *refcoo, med_mode_switch mode_coo,
med_int ngauss, med_float *gscoo, med_float * wg, char * locname )
{
med_idt gid=0, chid=0;
med_size dimd[1];
med_err ret = -1;
med_int typegeo = -1;
char chemin[MED_TAILLE_GAUSS+1]="";
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier ");
goto ERROR;
}
/*
* MED_GAUSS_ELNO est un mot cle reserve
*/
if (! strcmp(locname,MED_GAUSS_ELNO)) {
MESSAGE("MED_GAUSS_ELNO est un mot cle reserve : points Gauss sur les noeuds de l'element");
goto ERROR;
}
/*
* Si le groupe "GAUSS" n'existe pas, on le cree
*/
strncpy(chemin,MED_GAUSS,MED_TAILLE_GAUSS-1);
chemin[MED_TAILLE_GAUSS-1] = '\0';
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Impossible de creer le groupe MED_GAUSS : ");
SSCRUTE(chemin); goto ERROR;
}
/*
* Si le groupe <locname> n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(locname,ERROR);
if ((chid = _MEDdatagroupOuvrir(gid,locname)) >= 0) {
if ( MED_MODE_ACCES != MED_LECTURE_ECRITURE ) {
MESSAGE("Le nom de localisation existe déjà : ");
SSCRUTE(locname); goto ERROR;
}
} else
if ((chid = _MEDdatagroupCreer(gid,locname)) < 0)
goto ERROR;
/*
* On stocke <ngauss> sous forme d'attribut
*/
if (_MEDattrEntierEcrire(chid,MED_NOM_NBR,&ngauss) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
ISCRUTE(ngauss);goto ERROR;
};
/*
* On stocke <type_geo> sous forme d'attribut
*/
typegeo = (med_int) type_geo;
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long,
du coup sur machines 64 bits _MEDattrEntierEcrire utilise
le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
un enum.
*/
if (_MEDattrEntierEcrire(chid,MED_NOM_GEO,&typegeo) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_GEO : ");
ISCRUTE(type_geo);goto ERROR;
};
/*
* On stocke les coordonnées de référence dans un dataset
*/
dimd[0] = (type_geo%100)*(type_geo/100);
if ( _MEDdatasetNumEcrire(chid,MED_NOM_COO,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) refcoo) < 0 ) {
MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_COO);
ISCRUTE_size(dimd[0]); goto ERROR;
}
/*
* On stocke les points d'intégration dans un dataset
*/
dimd[0] = ngauss*(type_geo/100);
if ( _MEDdatasetNumEcrire(chid,MED_NOM_GAU,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) gscoo) < 0 ) {
MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_GAU);
ISCRUTE_size(dimd[0]); goto ERROR;
}
/*
* On stocke les poids dans un dataset
*/
dimd[0] = ngauss;
if ( _MEDdatasetNumEcrire(chid,MED_NOM_VAL,MED_FLOAT64,mode_coo,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) wg) < 0 ) {
MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_VAL);
ISCRUTE_size(dimd[0]); goto ERROR;
}
ret = 0;
ERROR:
/*
* On ferme tout
*/
if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(chid); ret = -1;
}
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid); ret = -1;
}
return ret;
}
med_err MEDchampCr( med_idt fid, char * champ, med_type_champ type, char * comp,
char * unit, med_int ncomp)
{
med_err ret=-1;
med_idt root=0,gid=0;
char chemin[MED_TAILLE_CHA+1];
med_size dimd[1];
med_int _type = (med_int) type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un champ en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group "/CHA/" n'existe pas, on le cree
*/
strncpy(chemin,MED_CHA,MED_TAILLE_CHA-1);
chemin[MED_TAILLE_CHA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si le Data Group cha n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(champ,ERROR);
if ((gid = _MEDdatagroupCreer(root,champ)) < 0) {
MESSAGE("Erreur à la création du champ : ");
SSCRUTE(champ);
goto ERROR;
}
/*
* Les infos sur les composants du champ
*/
if ( _MEDattrEntierEcrire(gid,MED_NOM_NCO,&ncomp) < 0 ) {
MESSAGE("Erreur à l'écriture du nombre de composantes : ");
ISCRUTE(ncomp);
goto ERROR;
}
if ( _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type) < 0) {
MESSAGE("Erreur à l'écriture du type du champ : ");
ISCRUTE(_type);
goto ERROR;
}
if ( _MEDattrStringEcrire(gid,MED_NOM_NOM,MED_TAILLE_PNOM*ncomp,comp) < 0) {
MESSAGE("Erreur à l'écriture des noms des composantes : ");
SSCRUTE(comp);
goto ERROR;
}
if ( _MEDattrStringEcrire(gid,MED_NOM_UNI,MED_TAILLE_PNOM*ncomp,unit) < 0) {
MESSAGE("Erreur à l'écriture des unités : ");
SSCRUTE(unit);
goto ERROR;
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
return ret;
}
med_err
MEDlienEcr(med_idt fid, char *lienval, char *maa)
{
med_idt gid=0, chid=0, did=0;
med_size dimd[1];
med_err ret=-1;
char chemin[MED_TAILLE_LIENS+1];
med_int n ;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le groupe "LIENS" n'existe pas, on le cree
*/
strncpy(chemin,MED_LIENS,MED_TAILLE_LIENS-1);
chemin[MED_TAILLE_LIENS-1] = '\0';
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Impossible de creer le groupe MED_LIENS : ");
SSCRUTE(chemin); goto ERROR;
}
/*
* Si le groupe "maa" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(maa,ERROR);
if ((chid = _MEDdatagroupOuvrir(gid,maa)) < 0)
if ((chid = _MEDdatagroupCreer(gid,maa)) < 0) {
MESSAGE("Erreur à la création du lien au maillage : ");
SSCRUTE(maa);
goto ERROR;
}
/*
* On stocke "n" sous forme d'attribut
*/
n = strlen(lienval);
if ((ret = _MEDattrEntierEcrire(chid,MED_NOM_NBR,&n)) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut n : ");
ISCRUTE(n); goto ERROR;
}
/*
* On stocke le lienval dans un dataset
*/
dimd[0] = n;
if ((ret = _MEDdatasetStringEcrire(chid,MED_NOM_LIE,dimd,lienval))<0) {
MESSAGE("Impossible d'ecrire le dataset lienval de taille : ");
ISCRUTE(n); goto ERROR;
}
/*
* On ferme tout
*/
ret =0;
ERROR:
if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(chid);ret=-1;
}
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret=-1;
}
return ret;
}
med_err
MEDindicesCoordEcr(med_idt fid,char *maillage,med_int mdim,med_float *indices,
med_int n,med_int axe,char *comp,char *unit)
{
med_idt maaid, noeid, dataset;
med_err ret;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
med_int att;
med_maillage maillage_type;
med_type_grille type;
/*
* Si axe > mdim => erreur
*/
if (axe > mdim)
return -1;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Si le maillage est de type MED_NON_STRUCTURE => erreur
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_TYP,&att)) < 0)
return -1;
maillage_type = (med_maillage) att;
if (maillage_type == MED_NON_STRUCTURE)
return -1;
/*
* Si la grille n'est pas de type MED_GRILLE_CARTESIENNE ou
* MED_GRILLE_POLAIRE => erreur
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_GTY,&att)) < 0)
return -1;
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long (normalement 64bits),
du coup sur machines 64 bits _MEDattrEntierLire utilise
le type hdf NATIVE_LONG, ce genere parfois un warning
*/
type = (med_type_grille) att;
if ((type != MED_GRILLE_CARTESIENNE) && (type != MED_GRILLE_POLAIRE))
return -1;
/*
* Si le groupe HDF "NOE" n'existe pas => erreur
*/
if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
if ((noeid = _MEDdatagroupCreer(maaid,MED_NOM_NOE)) < 0)
return -1;
/*
* On ecrit le tableau d'indice dans un dataset HDF
*/
switch(axe) {
case 1 :
strcpy(nom_dataset,MED_NOM_IN1);
break;
case 2 :
strcpy(nom_dataset,MED_NOM_IN2);
break;
case 3 :
strcpy(nom_dataset,MED_NOM_IN3);
break;
default :
return -1;
}
dimd[0] = n;
if ((ret = _MEDdatasetNumEcrire(noeid,nom_dataset,MED_FLOAT64,MED_FULL_INTERLACE,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,
MED_NOPG,dimd,(unsigned char*) indices)) < 0)
return -1;
/*
* On re-ouvre le dataset HDF pour y placer des attributs
*/
if ((dataset = _MEDdatasetOuvrir(noeid,nom_dataset)) < 0)
return -1;
/*
* Attribut NBR (taille du tableau d'indices)
*/
if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n)) < 0)
return -1;
/*
* Attribut "NOM" (nom de la composante)
*/
if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_NOM,MED_TAILLE_PNOM,comp)) < 0)
return -1;
/*
* Attribut "UNI" (unite de la composante)
*/
if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_UNI,MED_TAILLE_PNOM,unit)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(noeid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
void MAJ_21_22_elements_maillage(med_idt mid, med_int dimension)
{
med_idt eid,gid,did,tid;
med_err ret;
int i,j;
med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2,
MED_SEG3,MED_TRIA3,
MED_TRIA6,MED_QUAD4,
MED_QUAD8,MED_TETRA4,
MED_TETRA10,MED_HEXA8,
MED_HEXA20,MED_PENTA6,
MED_PENTA15,MED_PYRA5,
MED_PYRA13};
int taille, edim;
char *nom, *nouvelle_chaine;
char nomgroup[MED_TAILLE_NOM_ENTITE+1];
med_int n;
med_size dimd[1];
med_int *old_conn,*conn;
/* On ne regarde que les mailles et la connectivité nodale */
eid = _MEDdatagroupOuvrir(mid,(char *)(MED_NOM_MAI));
EXIT_IF(eid < 0,"Ouverture du groupe HDF MED_NOM_MAI",NULL);
/* On normalise selon tous les types geometriques */
for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) {
/* On recupere le nom du groupe HDF */
_MEDnomGeometrie(nomgroup,typmai[i]);
/* On accède au type s'il existe dans le fichier */
gid = _MEDdatagroupOuvrir(eid,nomgroup);
if (gid < 0)
continue;
/* Nombre d'element ? */
did = _MEDdatasetOuvrir(gid,(char *)(MED_NOM_NOD));
EXIT_IF(did < 0,"Ouverture du dataset HDF MED_NOM_NOD",NULL);
ret = _MEDattrEntierLire(did,(char *)(MED_NOM_NBR),&n);
EXIT_IF(ret < 0,"Lecture du nombre d'elements",NULL);
ret = _MEDdatasetFermer(did);
EXIT_IF(ret < 0,"Fermeture du dataset HDF MED_NOM_NOD",NULL);
/* on normalise la connectivité si edim < dimension */
edim = typmai[i] / 100;
if (edim < dimension) {
taille = typmai[i]%100 + 1;
old_conn = (med_int *) malloc(sizeof(med_int)*taille*n);
EXIT_IF(old_conn == NULL,NULL,NULL);
#if defined(HAVE_F77INT64)
ret = _MED21datasetNumLire(gid,(char *)(MED_NOM_NOD),MED_INT64,
MED_NO_INTERLACE,(med_size)taille,MED_ALL,
0,NULL,MED_NOPG,
(unsigned char*) old_conn,H5T_NATIVE_INT);
#else
ret = _MED21datasetNumLire(gid,(char *)(MED_NOM_NOD),MED_INT32,
MED_NO_INTERLACE,(med_size) taille,MED_ALL,
0,NULL,MED_NOPG,
(unsigned char*) old_conn,H5T_NATIVE_INT);
#endif
/* On recopie dans le bon tableau */
taille --;
conn = (med_int *) malloc(sizeof(med_int)*taille*n);
EXIT_IF(conn == NULL,NULL,NULL);
for (j=0;j<n*taille;j++)
*(conn+j) = *(old_conn+j);
dimd[0] = n*taille;
#if defined(HAVE_F77INT64)
ret = _MED231datasetNumEcrire(gid,(char *) "TMP",MED_INT64,MED_NO_INTERLACE,
taille,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
(unsigned char*) conn);
#else
ret = _MED231datasetNumEcrire(gid,(char *) "TMP",MED_INT32,MED_NO_INTERLACE,
taille,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
(unsigned char*) conn);
#endif
EXIT_IF(ret < 0,"Ecriture de la nouvelle connectivité des mailles",NULL);
/* Ecriture du nombre de mailles dans le dataset HDF TMP */
tid = _MEDdatasetOuvrir(gid,"TMP");
EXIT_IF(tid < 0,"Ouverture du dataset HDF TMP",NULL);
ret = _MEDattrEntierEcrire(tid,(char *)(MED_NOM_NBR),&n);
EXIT_IF(ret < 0,"Ecriture du nombre de noeuds dans le dataset HDF TMP",NULL);
ret = _MEDdatasetFermer(tid);
EXIT_IF(ret < 0,"Fermeture du dataset HDF TMP",NULL);
/* Fermeture de l'accès aux connectivites */
ret = H5Gunlink(gid,(char *)(MED_NOM_NOD));
EXIT_IF(ret < 0,"Suppression des anciennes connectivités",NULL);
ret = H5Gmove(gid,"TMP",(char *)(MED_NOM_NOD));
EXIT_IF(ret < 0,"Mise en place des nouvelles connectivités",NULL);
/* on libere la memoire */
free(old_conn);
free(conn);
}
/* Mise a niveau des noms */
nom = (char *) malloc(n*ANCIEN_MED_TAILLE_PNOM+1);
EXIT_IF(nom == NULL,NULL,NULL);
nouvelle_chaine = (char *) malloc(n*MED_TAILLE_PNOM+1);
EXIT_IF(nouvelle_chaine == NULL,NULL,NULL);
ret = _MEDdatasetStringLire(gid,(char *)(MED_NOM_NOM),nom);
if (ret == 0) {
_MED23v30stringConvert(nouvelle_chaine, MED_TAILLE_PNOM,
nom, ANCIEN_MED_TAILLE_PNOM, n );
/* MAJ_21_22_chaine(nom,nouvelle_chaine,n); */
H5Gunlink(gid,(char *)(MED_NOM_NOM));
dimd[0] = n*MED_TAILLE_PNOM+1;
ret = _MEDdatasetStringEcrire(gid,(char *)(MED_NOM_NOM),dimd,nouvelle_chaine);
EXIT_IF(ret < 0,"Ecriture des nouveaux noms des éléments",NULL);
did = _MEDdatasetOuvrir(gid,(char *)(MED_NOM_NOM));
ret = _MEDattrEntierEcrire(did,(char *)(MED_NOM_NBR),&n);
ret = _MEDdatasetFermer(did);
}
free(nom);
free(nouvelle_chaine);
/* on ferme avant de passer au type geometrique suivant */
ret = _MEDdatagroupFermer(gid);
EXIT_IF(ret < 0,"Fermeture de l'accès aux mailles",NULL);
}
/* On ferme tout */
ret = _MEDdatagroupFermer(eid);
EXIT_IF(ret < 0,"Fermeture de l'accès aux mailles",NULL);
}
med_err
MEDnumEcr(med_idt fid,char *maa, med_int *num, med_int n,
med_entite_maillage type_ent,med_geometrie_element type_geo)
{
med_idt root, maaid, entid, geoid, dataset;
med_err ret;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
char nom_ent[MED_TAILLE_NOM_ENTITE+1];
char nom_geo[MED_TAILLE_NOM_ENTITE+1];
med_entite_maillage _type_ent=type_ent;
if ( type_ent == MED_NOEUD_MAILLE ) _type_ent=MED_NOEUD ;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* On met a jour le nom du Data Group representant
* le type des entites
*/
if ((ret = _MEDnomEntite(nom_ent,_type_ent)) < 0)
return -1;
/*
* Si le Data Group des entites n'existe pas on le cree
*/
if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
if ((root = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
return -1;
/*
* Pour les mailles, les faces et le aretes, on cree
* s'il n'existe pas le Data Group du type geometrique
*/
if ((_type_ent==MED_MAILLE)||(_type_ent==MED_FACE)||(_type_ent==MED_ARETE))
{
if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
return -1;
if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
return -1;
}
else
geoid = -1;
/*
* Creation du Data Set "NUM"
*/
if (geoid == -1)
root = entid;
else
root = geoid;
dimd[0] = n;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) num)) < 0)
return -1;
#else
if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) num)) < 0)
return -1;
#endif
/*
* Attribut NBR (nombre de noeuds)
*/
if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NUM)) < 0)
return -1;
if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if (geoid != -1)
if ((ret = _MEDdatagroupFermer(geoid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(entid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
