med_err
MEDfileCommentWr(const med_idt fid,
const char* const comment)
{
med_idt _rootId=0;
med_err _ret=-1;
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
/* the root data group is open */
if ((_rootId = _MEDdatagroupOuvrir(fid,"/")) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP," : '/'");
goto ERROR;
}
/* The comment is stored in a HDF attribute */
if (_MEDattributeStringWr(_rootId,MED_COMMENT_NAME,MED_COMMENT_SIZE,(char*)comment) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_COMMENT_NAME);
SSCRUTE(comment);
goto ERROR;
}
_ret = 0;
ERROR:
/* the "/" group has to be closed */
if (_rootId > 0)
if (_MEDdatagroupFermer(_rootId) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP," : '/'");
}
return _ret;
}
med_int
MEDnInterp(const med_idt fid) {
med_int _ret=-1,_err=-1;
char _path[MED_INTERPOLATION_GRP_SIZE+1]=MED_INTERPOLATION_GRP;
med_size _tmpn=0;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* nombre de link
*/
if ((_err=_MEDnObjects(fid,_path,&_tmpn)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_INTERP,_path);
goto ERROR;
}
_ret = (med_int) _tmpn;
ERROR:
return _ret;
}
med_int
MEDnSupportMesh(const med_idt fid)
{
med_size _n=0;
med_int _ret=-1,_err=-1;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/*
* nombre de champs
*/
if ((_err=_MEDnObjects(fid,MED_SUP_MAA,&_n)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_MESH,MED_MAA);
goto ERROR;
}
_ret = (med_int) _n;
ERROR:
return _ret;
}
med_int
MEDfieldnComponent(const med_idt fid,
const int ind)
{
med_err _ret = -1;
char _fieldname[MED_NAME_SIZE+1]="";
int _num = ind-1;
char _path [MED_TAILLE_CHA+MED_NAME_SIZE+1]=MED_CHA;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom du champ
*/
if ( _MEDobjectGetName(fid, _path ,_num, _fieldname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
if ( (_ret=MEDfieldnComponentByName( fid, _fieldname )) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_FIELD_MSG);
SSCRUTE(_fieldname);SSCRUTE(_path);SSCRUTE("MEDfieldnComponentbyName");
goto ERROR;
}
ERROR:
return _ret;
}
med_err
MEDstructElementInfo(const med_idt fid,
const int mit,
char * const modelname,
med_geometry_type * const mgeotype,
med_int* const modeldim,
char* const supportmeshname,
med_entity_type* const sentitytype,
med_int* const snnode,
med_int* const sncell,
med_geometry_type* const sgeotype,
med_int* const nconstantattribute,
med_bool* const anyprofile,
med_int* const nvariableattribute
)
{
med_err _ret=-1;
char _path[MED_TAILLE_STRCT+MED_NAME_SIZE+1]=MED_STRCT;
int _num = mit -1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom de l'élément de structure
*/
if ( _MEDobjectGetName(fid, _path ,_num, modelname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(mit);
goto ERROR;
}
strcat(_path,modelname);
if (
MEDstructElementInfoByName(fid,
modelname,
mgeotype,
modeldim,
supportmeshname,
sentitytype,
snnode,
sncell,
sgeotype,
nconstantattribute,
anyprofile,
nvariableattribute
) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_STRUCT_MSG);
SSCRUTE(modelname);SSCRUTE(_path);SSCRUTE("MEDstructElementInfoByName");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err
MEDparameterComputationStepInfo(const med_idt fid,
const char * const paramname,
const int csit,
med_int * const numdt,
med_int * const numit,
med_float * const dt )
{
med_err _ret = -1, _err = -1;
med_idt _cpstidt = 0;
char _path[(MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1)+2*MED_MAX_PARA+1]=MED_NUM_DATA;
int _num=csit-1;
char _cstpname[2*MED_MAX_PARA+1]="";
_MEDmodeErreurVerrouiller();
/* On recupere le nom du pas de temps */
strcat(_path, paramname);
if ( _MEDobjectGetName(fid, _path ,_num, _cstpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
/* on ouvre le groupe HDF correspondant */
strcat(_path,"/");
strcat(_path,_cstpname);
if ((_cpstidt = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/* Lecture des attributs */
if (_MEDattrEntierLire(_cpstidt, MED_NOM_NDT, (med_int*) numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
SSCRUTE(_path);ISCRUTE(*numdt);goto ERROR;
}
if (_MEDattrFloatLire(_cpstidt, MED_NOM_PDT, (med_float*) dt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_PDT);
SSCRUTE(_path);RSCRUTE(*dt);goto ERROR;
}
if (_MEDattrEntierLire(_cpstidt, MED_NOM_NOR, (med_int*) numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
SSCRUTE(_path);ISCRUTE(*numit);goto ERROR;
}
_ret = 0;
ERROR:
/* on ferme tout */
if (_cpstidt > 0)
if (_MEDdatagroupFermer(_cpstidt) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_cpstidt);
}
return _ret;
}
med_err
MEDfichEntete(med_idt fid, med_fich_info quoi, char str[])
{
med_idt atid, root;
med_err ret;
char locale[MED_TAILLE_DESC+1];
char chemin[MED_TAILLE_MAA+1];
switch (quoi)
{
case MED_HDF_VERSION :
strcpy(str,HDF_VERSION_ACTUELLE);
break;
case MED_VERSION :
strcpy(str,PACKAGE_VERSION);
break;
case MED_FICH_DES :
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/* Ajout de la ligne suivante par un script malencontreux ?*/
/* if (MEDcheckVersion(fid) < 0) return -1; */
/*
* On ouvre le Data Group racine
*/
strncpy(chemin,MED_MAA,strlen(MED_MAA)-1);
chemin[MED_TAILLE_MAA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* On regarde si l'attribut existe
* Si non => erreur
* Si oui => on le copie dans str
*/
if ((ret = _MEDattrStringLire(root,MED_NOM_DESCRIPTEUR,
MED_TAILLE_DESC,locale)) < 0) {
_MEDdatagroupFermer(root);
return -1;
}
strcpy(str,locale);
if ( _MEDdatagroupFermer(root) < 0)
return -1;
break;
default :
return -1;
}
return 0;
}
med_err
MEDscalaireFlottantLire(med_idt fid,char *scalaire, med_float *val,med_int numdt, med_int numo)
{
med_err ret = 0;
med_idt gid, datagroup;
med_int type, i;
char nomdatagroup[2*MED_MAX_PARA+1];
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1];
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) 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;
/*
* Si le groupe HDF <numdtt>.<numoo> n'existe pas => erreur
*/
sprintf(nomdatagroup,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
datagroup = 0;
if ( (datagroup = _MEDdatagroupOuvrir(gid,nomdatagroup)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,&type)) < 0)
return -1;
switch(type)
{
case MED_FLOAT64 :
if ((ret = _MEDattrFloatLire(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
MEDdemonter(med_idt fid,med_idt mid, med_type_donnee type)
{
med_err ret;
med_idt root,did;
char chemin[2*MED_TAILLE_NOM+1];
char acces_montage[2*MED_TAILLE_NOM+1];
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On accede au type de la donnee
*/
switch(type) {
case MED_MAILLAGE :
strcpy(chemin,MED_MAA);
break;
case MED_CHAMP :
strcpy(chemin,MED_CHA);
break;
default :
return -1;
}
/*
* On supprime le lien avec les champs|maillages du fichier a demonter
*/
chemin[strlen(chemin)-1] = '\0';
if ((ret = _MEDdatagroupLienSupprimer(fid,chemin)) < 0)
return -1;
/*
* On demonte le fichier dans MED_MNT
*/
strncpy(acces_montage,MED_MNT,strlen(MED_MNT)-1);
acces_montage[strlen(MED_MNT)-1] = '\0';
if ((ret = _MEDfichierDemonter(fid,acces_montage)) < 0)
return -1;
/*
* On ferme le fichier que l'on vient de demonter
*/
if ((ret = _MEDfichierFermer(mid)) < 0)
return -1;
return ret;
}
med_err
MEDgaussInfo(med_idt fid, int indice, char * locname, med_geometrie_element * type_geo,
med_int * ngauss )
{
int numero=0;
med_idt locid=0;
med_err ret=-1;
char chemin[MED_TAILLE_GAUSS+MED_TAILLE_NOM+1]="";
med_int typegeo;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On recupere le nom du groupe de rang "indice"
*/
numero = indice-1;
if ( _MEDobjetIdentifier(fid,MED_GAUSS,numero,locname) < 0)
goto ERROR;
/*
* On va chercher l'attribut ngauss
*/
strcpy(chemin,MED_GAUSS);
strcat(chemin,locname);
if ((locid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Impossible d'ouvrir le datagroup : ");
SSCRUTE(chemin); goto ERROR;
}
/* Lecture de <ngauss> */
if (_MEDattrEntierLire(locid,MED_NOM_NBR,ngauss) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NBR : ");
ISCRUTE(*ngauss);goto ERROR;
};
/* Lecture <type_geo> sous forme d'attribut */
if (_MEDattrEntierLire(locid,MED_NOM_GEO,&typegeo) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_GEO : ");
ISCRUTE(*type_geo);goto ERROR;
};
*type_geo = ( med_geometrie_element ) typegeo;
ret = 0;
ERROR:
if ( locid > 0 ) if (_MEDdatagroupFermer(locid) < 0)
goto ERROR;
return 0;
}
/**\ingroup MEDfile
\brief \MEDfileObjectExistBrief
\param fid \fid
\param medclass \medclass
\param objectname \objectname
\param objectexist \objectexist
\retval med_err \error
\details \MEDfileObjectExistDetails
\par Remarques
*/
med_err
MEDfileObjectExist(const med_idt fid,
const med_class medclass,
const char * const objectname,
med_bool * const objectexist )
{
med_idt _fid = 0;
med_err _ret = -1;
char _link[2*MED_NAME_SIZE+1]="";
med_bool _datagroupexist=MED_FALSE,_isasoftlink=MED_FALSE;
int _objsize = 0;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
*objectexist = MED_FALSE;
/*
* Give access to the class object in the local file
*/
switch(medclass) {
MY_CASE(MESH);
MY_CASE(MESH_SUPPORT);
MY_CASE(ELSTRUCT);
MY_CASE(FAMILY);
MY_CASE(EQUIVALENCE);
MY_CASE(JOINT);
MY_CASE(FIELD);
MY_CASE(LOCALIZATION);
MY_CASE(PROFILE);
MY_CASE(INTERPOLATION);
MY_CASE(NUMERICAL_DATA);
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_CLASS,_link);
goto ERROR;
}
strncpy(_link+_objsize,objectname,MED_NAME_SIZE+1);
_link[2*MED_NAME_SIZE]='\0';
if( _MEDdatagroupExist(fid,_link,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(_link);goto ERROR;
}
if ( _datagroupexist ) *objectexist = MED_TRUE;
_ret=0;
ERROR:
return _ret;
}
void
_MEDmeshUniversalNameRd30(int dummy, ...)
{
med_err _ret=-1;
med_idt _meshid;
char _path [MED_TAILLE_MAA+MED_NAME_SIZE+1]=MED_MAA;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(, char *, const , univname );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(, char *, const , univname );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
/*
* Si le maillage n'existe pas => erreur
*/
strcat(_path,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_meshid);goto ERROR;
}
if ( _MEDattrStringLire(_meshid,MED_NOM_UNV,MED_LNAME_SIZE,univname) < 0) {
_ret = MED_ERR_READ + MED_ERR_ATTRIBUTE;
goto ERROR;
}
_ret = 0;
ERROR:
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_meshid);
}
va_end(params);
*fret = _ret;
return;
}
med_err
MEDscalairePasdetempsInfo(med_idt fid,char *scalaire,int indice,
med_int * numdt, char * dt_unit, med_float * dt,med_int * numo)
{
med_err ret=0;
med_idt gid;
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1+2*MED_MAX_PARA+1];
int num;
char nomdatagroup[2*MED_MAX_PARA+1];
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On construit le chemine d'acces
*/
strcpy(chemin,MED_NUM_DATA);
strcat(chemin,scalaire);
strcat(chemin,"/");
num = indice - 1;
if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0)
return -1;
strcat(chemin,nomdatagroup);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* La liste des attributs
*/
if ((ret = _MEDattrEntierLire(gid,MED_NOM_NDT,(med_int*) numdt)) < 0)
return -1;
if ((ret = _MEDattrFloatLire(gid,MED_NOM_PDT,(med_float*) dt)) < 0)
return -1;
if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_NOR,(med_int*) numo)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}
med_err
MEDscalaireInfo(med_idt fid,int indice,char *scalaire,
med_type_champ *type,char *desc)
{
med_err ret=0;
med_idt gid;
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1];
int num;
med_int typechamp;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On recupere le nom du scalaire
*/
num = indice - 1;
strcpy(chemin,MED_NUM_DATA);
if ((ret = _MEDobjetIdentifier(fid,chemin,num,scalaire)) < 0)
return -1;
/*
* Si le Groupe HDF "scalaire" n'existe pas => erreur
*/
strcat(chemin,scalaire);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* La liste des attributs
*/
if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP, & typechamp)) < 0)
return -1;
*type = (med_type_champ) typechamp;
if ((ret = _MEDattrStringLire(gid,MED_NOM_DES,MED_TAILLE_DESC,
desc)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}
/**\ingroup MEDinterp
\brief \MEDinterpInfoBrief
\param fid \fid
\param interpit \interpit
\param interpname \interpname
\param geotype \geotype
\param cellnode \cellnode
\param nbasisfunc \nbasisfunc
\param nvariable \nvariable
\param maxdegree \maxdegree
\param nmaxcoef \nmaxcoef
\return \error
\details \MEDinterpInfoDetails
\see MEDinterpInfoByName
*/
med_err
MEDinterpInfo(const med_idt fid,
const int interpit,
char* const interpname,
med_geometry_type* const geotype,
med_bool* const cellnode,
med_int* const nbasisfunc,
med_int* const nvariable,
med_int* const maxdegree,
med_int* const nmaxcoef
)
{
med_err _ret=-1;
char _interppath[MED_TAILLE_INTERP+MED_NAME_SIZE+1]=MED_INTERP;
int _num = interpit -1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom de l'interpolation
*/
if ( _MEDobjectGetName(fid, _interppath ,_num, interpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_interppath);ISCRUTE_int(interpit);
goto ERROR;
}
strcat(_interppath,interpname);
if ( MEDinterpInfoByName(fid,
interpname,
geotype,
cellnode,
nbasisfunc,
nvariable,
maxdegree,
nmaxcoef
) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_INTERP_MSG);
SSCRUTE(interpname);SSCRUTE(_interppath);SSCRUTE("MEDinterpInfoByName");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err
MEDnatureGrilleLire(med_idt fid,char *maillage,med_type_grille *type)
{
med_idt maaid;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_maillage maillage_type;
med_int att;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On regarde si le groupe existe => erreur si non
*/
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;
/*
* On lit le type de la grille
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_GTY,&att)) < 0)
return -1;
*type = (med_type_grille) att;
/*
* Fermeture des objets HDF
*/
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return ret;
}
int
MEDequivInfo(int fid, char *maa, int ind, char *eq, char *des)
{
med_idt eqid;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1];
int num;
int idx;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On recupere le nom de l'equivalence
*/
num = ind - 1;
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
strcat(chemin,MED_EQS);
if ((idx = _MEDobjetIdentifier(fid,chemin,num,eq)) < 0)
return -1;
/*
* Si le Data Group eq n'existe pas => erreur
*/
strcat(chemin,eq);
if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* L'attribut "DES"
*/
if ((ret = _MEDattrStringLire(eqid,MED_NOM_DES,MED_TAILLE_DESC,des)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(eqid)) < 0)
return -1;
return 0;
}
med_err
MEDlibraryClose(void)
{
med_err _ret = -1;
_MEDmodeErreurVerrouiller();
if ( H5close() < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_LIBRARY,"");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err
MEDversionConforme(const char *nom) {
med_int majeur, mineur;
med_idt fid, gid;
med_err ret;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/*
* On ouvre le fichier MED en mode MED_LECT
*/
if ((fid = _MEDfichierOuvrir((char *)nom,MED_LECTURE)) < 0)
return -1;
/*
* Lecture du numero de version
*/
if ((gid = _MEDdatagroupOuvrir(fid,MED_INFOS)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,&majeur)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,&mineur)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
if ((ret = _MEDfichierFermer(fid)) < 0)
return -1;
/* On autorise les versions 2.2.x et 2.3.x , ce qui est le cas depuis med2.3.1 */
if ((majeur == 2) && (mineur >1) && (mineur<4) )
return 0;
else
return -1;
}
med_err
MEDunvLire(med_idt fid, char *maa,char *nomu)
{
med_idt maaid=0;
char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_err ret=-1;
/*
* On inhibe le gestionnaire d'erreur
*/
_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)
goto ERROR;
/*
* Creation/Ecriture de l'attribut nom universel
*/
if ((ret = _MEDattrStringLire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,
nomu )) < 0)
goto ERROR;
/*
* Nettoyages divers
*/
ret=0;
ERROR:
if ( maaid> 0 ) if ( _MEDdatagroupFermer(maaid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(maaid);ret = -1;
}
return ret;
}
med_err
MEDlocalizationInfo(const med_idt fid,
const int localizationit,
char * const localizationname,
med_geometry_type * const geotype,
med_int * const spacedimension,
med_int * const nipoint,
char * const geointerpname,
char * const sectionmeshname,
med_int * const nsectionmeshcell,
med_geometry_type * const sectiongeotype)
{
med_err _ret=-1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
int _num=localizationit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* ouverture du groupe /GAUSS/"nom"
*/
if ( _MEDobjectGetName(fid, _path ,_num, localizationname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
ISCRUTE_int(localizationit);
goto ERROR;
}
if ( MEDlocalizationInfoByName(fid, localizationname, geotype, spacedimension,
nipoint,geointerpname,
sectionmeshname, nsectionmeshcell,sectiongeotype ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDlocalizationInfoByName");
SSCRUTE(localizationname);
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
void _MEDnEquivalence30(int dummy, ...) {
char _path[MED_EQUIVALENCE_GRP_SIZE+MED_NAME_SIZE+1]=MED_EQUIVALENCE_GRP;
med_int _ret=-1,_err=-1;
med_size _tmpn=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(, med_int * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
strcat(_path,meshname);
/*
* nombre d'équivalence
*/
if ( (_err=_MEDnObjects(fid,_path,&_tmpn)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
_ret = (med_int) _tmpn;
ERROR:
va_end(params);
*fret = _ret;
return;
}
med_int
MEDnJoint(med_idt fid, char *maa)
{
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+MED_TAILLE_JNT+1];
int n;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
strcat(chemin,MED_JNT);
n = 0;
_MEDnObjets(fid,chemin,&n);
return (med_int) n;
}
med_err
MEDfileCommentRd(const med_idt fid, char* const comment)
{
char * name = "_MEDfileCommentRd";
int dummy=0;
med_err fret=-1;
med_int majeur, mineur, release;
MedFuncType func;
_MEDmodeErreurVerrouiller();
MEDfileNumVersionRd(fid, &majeur, &mineur, &release);
func = _MEDversionedApi3(name,majeur,mineur,release);
if ( func != (MedFuncType) NULL )
func (dummy,
fid,
comment,
&fret);
return fret;
}
/*
* - 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
MEDprofilInfo(med_idt fid, int indice, char *profilname, med_int *n)
{
int numero=0;
med_idt proid=0;
med_err ret=-1;
char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]="";
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On recupere le nom du groupe de rang "indice"
*/
numero = indice-1;
if ( _MEDobjetIdentifier(fid,MED_PROFILS,numero,profilname) < 0)
goto ERROR;
/*
* On va chercher l'attribut taille du profil
*/
strcpy(chemin,MED_PROFILS);
strcat(chemin,profilname);
if ((proid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
goto ERROR;
if (_MEDattrEntierLire(proid,MED_NOM_NBR,n) < 0)
goto ERROR;
ret = 0;
ERROR:
if ( proid > 0 ) if (_MEDdatagroupFermer(proid) < 0)
goto ERROR;
return 0;
}
med_int
MEDnProfil(med_idt fid)
{
int n=0;
med_idt datagroup=0;
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (datagroup = _MEDdatagroupOuvrir(fid,MED_PROFILS)) < 0)
return 0;
else
if (datagroup) if ( _MEDdatagroupFermer(datagroup) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup); return -1;
}
if ( _MEDnObjets(fid,MED_PROFILS,&n) < 0 ) return -1;
return (med_int) n;
}
med_idt
MEDfileObjectsMountById(const med_idt fid,
const med_idt chfid,
const char * const chpath,
const med_class medclass )
{
int dummy=0;
med_idt ret=-1,fret=-1;
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
_MEDfileObjectsMount30(dummy,
fid,
chfid,
chpath,
medclass,
&fret);
ret=fret;
ERROR:
return ret;
}
med_int
MEDnValProfil(med_idt fid, char *nom)
{
med_int n = 0;
med_idt gid;
char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1];
med_err ret;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* ouverture du groupe /PROFILS/<nom>
*/
strcpy(chemin,MED_PROFILS);
strcat(chemin,nom);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0){
MESSAGE("Impossible d'ouvrir le groupe MED_PROFILS : ");
SSCRUTE(chemin); return -1;
}
if ((ret = _MEDattrEntierLire(gid,MED_NOM_NBR,&n)) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NBR : ");
ISCRUTE(n); return -1;
}
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return n;
}
med_err
MEDfermer(med_idt fid)
{
#ifdef _DEBUG_
_MEDobjetsOuverts(fid);
#endif
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On ferme le fichier MED
*/
if (_MEDfichierFermer(fid) < 0)
return -1;
else
return 0;
}
