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;
}
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;
}
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
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;
}
void
_MEDfieldInfoByName30(int dummy, ...) {
med_err _ret=-1,_err=-1;
med_idt _fieldgid=0,_meshgid=0,_linkgid=0;
char _fieldpath[MED_TAILLE_CHA+MED_NAME_SIZE+1]=MED_CHA;
char _meshpath [MED_TAILLE_MAA+MED_NAME_SIZE+1]=MED_MAA;
char _linkpath [MED_TAILLE_LIENS+MED_NAME_SIZE+1]=MED_LIENS;
med_size _ncstp=0;
med_int _n=0;
med_int _intfieldtype=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_field_type *, const , fieldtype );
MED_VARGS_DECL(, char *, const , componentname );
MED_VARGS_DECL(, char *, const , componentunit );
MED_VARGS_DECL(, char *, const , dtunit );
MED_VARGS_DECL(, med_int *, const , ncstp );
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 , fieldname );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_field_type *, const , fieldtype );
MED_VARGS_DEF(, char *, const , componentname );
MED_VARGS_DEF(, char *, const , componentunit );
MED_VARGS_DEF(, char *, const , dtunit );
MED_VARGS_DEF(, med_int *, const , ncstp );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
strcat(_fieldpath,fieldname);
/*
* On recupere le nombre de composants
*/
if ((_fieldgid = _MEDdatagroupOuvrir(fid,_fieldpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_fieldpath);
goto ERROR;
}
if ( _MEDattrEntierLire(_fieldgid,MED_NOM_NCO,&_n) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NCO);
SSCRUTE(_fieldpath);goto ERROR;
}
/*
* La liste des attributs
*/
/* Lecture de l'attribut MED_NOM_TYP */
if ( _MEDattrEntierLire(_fieldgid,MED_NOM_TYP,&_intfieldtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(MED_NOM_TYP);
goto ERROR;
}
*fieldtype = (med_field_type) (_intfieldtype);
/*
* Les infos sur les composantes du champ
*/
if (_MEDattrStringLire(_fieldgid,MED_NOM_NOM,_n*MED_SNAME_SIZE,
componentname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_NOM);
SSCRUTE(componentname);goto ERROR;
}
if (_MEDattrStringLire(_fieldgid,MED_NOM_UNI,_n*MED_SNAME_SIZE,
componentunit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_UNI);
SSCRUTE(componentunit);goto ERROR;
}
/*MODEL : MED_NOM_UNI vient du niveau en dessous
Cree ou ouvre l'attribut MED_NOM_UNI pour écriture
*/
if ( _MEDattrStringLire(_fieldgid,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_MAI */
if ( _MEDattrStringLire(_fieldgid,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(MED_NOM_MAI);SSCRUTE(meshname);
goto ERROR;
}
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
/* Nombre d'étapes de calcul*/
if ( (_err=_MEDnObjects(_fieldgid,".",&_ncstp)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_fieldpath);
goto ERROR;
}
*ncstp = (med_int) _ncstp;
_ret = 0;
ERROR:
if (_fieldgid>0) if (_MEDdatagroupFermer(_fieldgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_fieldpath);
ISCRUTE_id(_fieldgid);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDlocalizationInfoByName30(int dummy, ...) {
med_idt _lzid = 0;
med_err _ret = -1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
char _sectiongeotypename[MED_TAILLE_NOM_ENTITE+1]="";
med_int _intgeotype = -1,_nsectiongeotype=0, _nsectionmeshcell=0;
med_entity_type _sectionentitype = MED_CELL;
med_geometry_type _sectiongeotype = MED_UNDEF_GEOTYPE;
med_data_type _conorcoo = MED_CONNECTIVITY;
med_bool _chgt=MED_FALSE,_trsf=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , localizationname );
MED_VARGS_DECL(, med_geometry_type *, const , geotype );
MED_VARGS_DECL(, med_int *, const , spacedimension );
MED_VARGS_DECL(, med_int *, const , nipoint );
MED_VARGS_DECL(, char *, const , geointerpname );
MED_VARGS_DECL(, char *, const , sectionmeshname );
MED_VARGS_DECL(, med_int *, const , nsectionmeshcell );
MED_VARGS_DECL(, med_geometry_type *, const , sectiongeotype );
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 , localizationname );
MED_VARGS_DEF(, med_geometry_type *, const , geotype );
MED_VARGS_DEF(, med_int *, const , spacedimension );
MED_VARGS_DEF(, med_int *, const , nipoint );
MED_VARGS_DEF(, char *, const , geointerpname );
MED_VARGS_DEF(, char *, const , sectionmeshname );
MED_VARGS_DEF(, med_int *, const , nsectionmeshcell );
MED_VARGS_DEF(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* ouverture du groupe /GAUSS/"nom"
*/
strcat(_path,localizationname);
if ((_lzid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_NBR
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_NBR,nipoint) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nipoint);
goto ERROR;
}
/*
* On lit <typgeo> sous forme d'attribut
*/
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long,
du coup sur machines 64 bits _MEDattributeIntWr utilise
le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
un enum.
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_GEO,&_intgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE(_intgeotype);
goto ERROR;
};
*geotype = (med_geometry_type) _intgeotype;
/*
* On lit <spacedimension>
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_DIM,spacedimension) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_DIM);ISCRUTE(*spacedimension);
goto ERROR;
};
/*
* Lecture de l'attribut MED_NOM_NOM (nom du maillage de section)
*/
if ( _MEDattrStringLire(_lzid,MED_NOM_NOM,MED_NAME_SIZE,sectionmeshname) < 0) {
sectionmeshname[0]='\0';
}
if ( strlen(sectionmeshname) &&
( _intgeotype > MED_STRUCT_GEO_INTERNAL) &&
( _intgeotype < MED_STRUCT_GEO_SUP_INTERNAL) ) {
if ( _MEDgetSupportMeshNbOfEntities(fid,sectionmeshname,&_sectionentitype,
&_sectiongeotype,NULL,&_nsectionmeshcell) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetSupportMeshNbOfEntities");
SSCRUTE(sectionmeshname);ISCRUTE_int(_sectionentitype);
ISCRUTE(_sectiongeotype);ISCRUTE(_nsectionmeshcell);goto ERROR;
}
}
*sectiongeotype= _sectiongeotype;
*nsectionmeshcell= _nsectionmeshcell;
if ( _MEDattrStringLire(_lzid,MED_NOM_INM,MED_NAME_SIZE,geointerpname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_INM);SSCRUTE(geointerpname);
goto ERROR;
}
_ret = 0;
ERROR:
if ( _lzid > 0 ) if ( _MEDdatagroupFermer(_lzid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_GAUSS);
ISCRUTE_id(_lzid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDfield23ComputingStepMeshInfo236(int dummy,...)
{
med_err _ret=-1,_err=0;
med_size _num,_nmesh=0;
med_idt _datagroup1=0,_meshgid=0,_linkgid=0;
char _datagroupname1[2*MED_MAX_PARA+1] ="";
char _ent_geo [2*MED_TAILLE_NOM_ENTITE+2]="";
char _path [(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+
(2*MED_TAILLE_NOM_ENTITE+1)+1+(2*MED_MAX_PARA)+1]=MED_CHA;
char _meshpath [MED_TAILLE_MAA+MED_TAILLE_NOM+1]=MED_MAA;
char _linkpath [MED_TAILLE_LIENS+MED_TAILLE_NOM+1]=MED_LIENS;
med_size _ncpst=0;
med_bool _checkmultiplemesh=MED_TRUE, _multiplemesh =MED_FALSE;
med_bool _checkmeshname =MED_TRUE, _samedefaultmeshname=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, int , , csit );
MED_VARGS_DECL(, med_int *, const , numdt );
MED_VARGS_DECL(, med_int *, const , numit );
MED_VARGS_DECL(, med_float *, const , dt );
MED_VARGS_DECL(, med_int *, const , nmesh );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_int *, const , meshnumdt );
MED_VARGS_DECL(, med_int *, const , meshnumit );
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 , fieldname );
MED_VARGS_DEF(const, int , , csit );
MED_VARGS_DEF(, med_int *, const , numdt );
MED_VARGS_DEF(, med_int *, const , numit );
MED_VARGS_DEF(, med_float *, const , dt );
MED_VARGS_DEF(, med_int *, const , nmesh );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_int *, const , meshnumdt );
MED_VARGS_DEF(, med_int *, const , meshnumit );
MED_VARGS_DEF(, med_err * ,, fret );
_num=csit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On construit le nom du datagroup
*/
strcat(_path,fieldname);
/* if ( _MEDfieldComputingStepCheck236(fid, fieldname, */
/* &_ncpst, */
/* _checkmultiplemesh, &_multiplemesh, */
/* _checkmeshname, &_samedefaultmeshname) < 0) { */
/* MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FIELD,fieldname); */
/* goto ERROR; */
/* } */
/*
* On suppose que le modèle 2.3.6 est respecté :
* Il y a les mêmes séquences de calcul pour tous les couples
* (typent,typegeo). Autrement dit selon l'utilisation de l'API 2.3.6 :
* A chaque séquence de calcul, on utilise le même ensemble de (typent,typegeo).
* En conséquence si l'on fixe le (typeent,typegeo) les séquences
* de calcul que l'on va trouver seront représentatives de celles
* présentent dans tous les (typent,typegeo) utilisés.
*/
if ( _MEDobjectGetName(fid, _path ,0, _ent_geo) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); SSCRUTE(_ent_geo); goto ERROR;
}
strcat(_path,"/");
strcat(_path,_ent_geo);
if ( _MEDobjectGetName(fid, _path ,_num, _datagroupname1) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); SSCRUTE(_ent_geo); goto ERROR;
}
strcat(_path,"/");
strcat(_path,_datagroupname1);
if ((_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Lecture des attributs
*/
if (_MEDattrEntierLire(_datagroup1,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(_datagroup1,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(_datagroup1,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;
}
if (_MEDattrStringLire(_datagroup1,MED_NOM_MAI,MED_TAILLE_NOM,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_MAI);
SSCRUTE(_path);SSCRUTE(meshname);goto ERROR;
}
/* Nombre de maillages
* La gestion d'une incohérence sur le nombre de séquences de calcul par couple (entitytype,geotype)
* se fait à partir des appels :
* MEDfieldnProfile,MEDfieldnValue*
* La vérification complémentaire que l'ensemble des maillages utilisés sont les mêmes pour toutes les séquences
* de calcul identiques est effectué dans MEDfield23nValue
*/
if ( (_err=_MEDnObjects(_datagroup1,".",&_nmesh)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
*nmesh = (med_int) _nmesh;
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
*meshnumdt=MED_NO_DT;
*meshnumit=MED_NO_IT;
_ret = 0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_datagroup1);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
med_err
MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo,
med_mode_switch mode_coo,med_int numco,
med_int * pfltabtmp, med_size psize, med_repere *type_rep, char *nom, char *unit)
{
med_idt maaid, noeid, dataset;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
int i,j;
med_float *new_coo;
med_int type_rep_int;
med_size * pfltab;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
* Sinon on recupere sa dimension au passage
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Si le Data Group "NOE" n'existe pas => erreur
*/
if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
return -1;
/*
* Convertion de med_int en med_size
*/
if ( psize != MED_NOPF ) {
pfltab = (med_size *) malloc (sizeof(med_size)*psize);
for (i=0;i<psize;i++)
pfltab[i] = (med_size) pfltabtmp[i];
}
/*
* Lecture du Data Set "COO"
*/
if ((ret = _MEDdatasetNumLire(noeid,MED_NOM_COO,MED_FLOAT64,
mode_coo,mdim,numco,
psize,MED_COMPACT,MED_PFL_NON_COMPACT,pfltab,MED_NOPG,0,
(unsigned char*) coo)) < 0)
return -1;
/*
* On re-ouvre le Data Set "COO" pour y lire des attributs
*/
if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0)
return -1;
/*
* L'attribut "REP"
*/
if ((ret = _MEDattrEntierLire(dataset,MED_NOM_REP,&type_rep_int)) < 0)
return -1;
else
*type_rep = (med_repere) type_rep_int;
/*
* Attribut "NOM"
*/
if ((ret = _MEDattrStringLire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,
nom)) < 0)
return -1;
/*
* Attribut "UNI"
*/
if ((ret = _MEDattrStringLire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,
unit)) < 0)
return -1;
/*
* On ferme tout
*/
if ( psize != MED_NOPF ) free(pfltab);
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(noeid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
void
_MEDmeshnEntity30(int dummy, ...)
{
med_access_mode _MED_ACCESS_MODE;
med_int _ret=-1,_err=-1;
med_idt _meshid=0, _datagroup=0,_datagroupf=0,_datagroup1=0;
med_idt _datagroup2=0,_datagroup3=0,_datagroup4=0,_dataset=0;
char _meshpath [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
char _datagroupname1 [2*MED_MAX_PARA+1] ="";
char _datagroupname2 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname3 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname4 [MAX(MED_TAILLE_VARATR,MED_TAILLE_COOTRF)]="";
char _datasetconame [3 + 1 + 3 + 1 ] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _datasetname [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype = 0;
med_int _intsortingtype = 0;
med_int _profilearraysize = 0;
med_int _changement=0, _changement_s=0, _transformation=0;
med_bool _changement_co = MED_FALSE;
med_size _n=0;
med_int _intn=0;
med_bool _isasupportmesh = MED_FALSE;
med_bool _isasoftlink = MED_FALSE;
med_bool _datasetexist = MED_FALSE;
med_int _ntmpmeddatatype = 1;
med_data_type _tmpmeddatatype[4] = {MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE};
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _intmeshtype = 0;
med_int _meshdim = 0;
int _i = 0;
med_connectivity_mode _cmode ;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
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(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_cmode = cmode;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/*
* Ouverture du datagroup de niveau 1 <_meshpath>/<meshname>
*/
NOFINALBLANK(meshname,ERROR);
if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(_meshpath); goto ERROR;
}
/* Lecture de la dimension du maillage */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
/* Lecture du type de maillage (attribut MED_NOM_TYP) */
if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
}
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
/* Lecture de l'attribut MED_NOM_GTY */
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype= (med_grid_type) _intgridtype;
}
/*
* Ouverture du datagroup de niveau 2 <numdt>.<numit>
*/
if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
}
_sortingtype = (med_sorting_type) (_intsortingtype);
_MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
}
/*
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_CGT);goto ERROR;
}
*changement = (med_bool) _changement;
*transformation = MED_FALSE;
/*
* Gestion entitytype == MED_UNDEF_ENTITY_TYPE
*/
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) {
_n=0; goto SORTIE;
}
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
_err=_MEDnObjects(_datagroup1,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
goto SORTIE;
}
/*
* Ouverture du datagroup de niveau 3 <entitytype>
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
}
if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
*changement = (med_bool) MED_FALSE;
_n=0;_datagroup2=0;
goto SORTIE;
}
/* MAJ du changement pour le type d'entité <entitytype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup2,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
/*
* Ouverture du datagroup de niveau 4 <geotype>
*/
/* Pas Utilisation pour MED_NODE */
if ( geotype == MED_GEO_ALL ) {
_err=_MEDnObjects(_datagroup2,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname2);
goto ERROR;
}
/*Par construction du modèle, le tableau de coordonnées preexiste aux autres */
if ( ( entitytype == MED_NODE ) && (_n > 0) ) _n=1;
goto SORTIE;
}
if ( entitytype != MED_NODE ) {
/* Lecture du nom de type géométrique */
/*TODO : Remplacer les deux appels suivants par un seul gérant les geotype dynamiques et statiques*/
if ( entitytype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid, geotype,_datagroupname3) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else
if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);goto ERROR;
}
if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
_n=0;
*changement = MED_FALSE;
goto SORTIE;
}
}
if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
/* MAJ du changement pour le type géométrique d'entité <geotype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
* Prend en charge le cas d'un dataset vide écrit pour un typegeo donné (CHGT==1)
*/
if (_datagroup3) {
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
}
/*
* Lecture du flag de modification sur autre chose que MED_CONNECTIVITY,MED_COORDINATE,MED_COORDINATE_AXIS<i>
*
*/
if ( _MEDattrEntierLire(_datagroup,MED_NOM_CGS,&_changement_s) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGS);goto ERROR;
}
/* 1) Lorsque l'utilisateur interroge un <meddatatype> qui est relatif a des coordonnées (famille,....) il faut mettre
* le flag chgt à jour par rapport à des modifications potentiellement effectuées sur ces coordonnées
* <=>
* Si on interroge autre chose que MED_CONNECTIVITY,MED_COORDINATE
* et qu'un changement est présent sur MED_CONNECTIVITY,MED_COORDINATE
* le flag chgt doit être positionné à vrai
* Une demande entitype==MED_NODE && (meddatatype == MED_COORDINATE_AXIS1)||(meddatatype == MED_COORDINATE_AXIS2)
* ||(meddatatype === MED_COORDINATE_AXIS3) est assimilée à une demande concernant des coordonnées
* <=>
* Y-a-t'il une modification des datasets COO(si NOE)| NOD|DES(si !NOE)
*/
/* 2)
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et que le cmode n'a pas été
* spécifié par l'utilisateur.
* Cette Information est necessaire pour construire le nom du dataset.
*/
if ( (meddatatype != MED_CONNECTIVITY) && ( meddatatype != MED_COORDINATE )
&& (meddatatype != MED_COORDINATE_AXIS1)
&& (meddatatype != MED_COORDINATE_AXIS2)
&& (meddatatype != MED_COORDINATE_AXIS3)
&& (meddatatype != MED_INDEX_FACE)
&& (meddatatype != MED_INDEX_NODE)) {
if (entitytype == MED_NODE) {
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
if ( (_gridtype == MED_CARTESIAN_GRID) ||
(_gridtype == MED_CURVILINEAR_GRID) ) {
_ntmpmeddatatype=_meshdim;
_tmpmeddatatype[0] = MED_COORDINATE_AXIS1;
_tmpmeddatatype[1] = MED_COORDINATE_AXIS2;
_tmpmeddatatype[2] = MED_COORDINATE_AXIS3;
} else if (_gridtype == MED_CURVILINEAR_GRID ) {
/*Les grilles curvilinéaires utilisent MED_COORDINATE_AXISx pour stocker la structure et le tableau MED_COORDINATE pour stocker les coordonnées des noeuds */
++_ntmpmeddatatype;
_tmpmeddatatype[3] = MED_COORDINATE;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
} else
_tmpmeddatatype[0] = MED_COORDINATE;
} else {
switch (geotype) {
case MED_POLYHEDRON:
_ntmpmeddatatype=3;
_tmpmeddatatype[2] = MED_CONNECTIVITY;
_tmpmeddatatype[1] = MED_INDEX_FACE;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
case MED_POLYGON:
_ntmpmeddatatype=2;
_tmpmeddatatype[1] = MED_CONNECTIVITY;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
default:
if ( ( (med_mesh_type) _intmeshtype ) == MED_STRUCTURED_MESH ) {
_ntmpmeddatatype=0;
break;
}
_tmpmeddatatype[0] = MED_CONNECTIVITY;
if ( cmode == MED_NO_CMODE ) {
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_NODAL,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
if ( _datasetexist ) _cmode= MED_NODAL;
else
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_DESCENDING,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
} else
_cmode = MED_DESCENDING;
}
}
}
*changement = MED_FALSE;
for (_i=0; _i < _ntmpmeddatatype ;++_i) {
if ( _MEDgetDatasetChgt( _datagroup, _tmpmeddatatype[_i], _cmode,
&_isasoftlink, &_changement_co ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"getDatasetChgt");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
*changement |= _changement_co;
}
}
/*
* Niveau de datagroup 5 supplémentaire pour les éléments de structure ou les transformations.
*/
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) ) {
if (meddatatype == MED_VARIABLE_ATTRIBUTE)
strcpy(_datagroupname4,MED_VARATR_NOM);
else
strcpy(_datagroupname4,MED_COOTRF_NOM);
if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
_n=0;
goto SORTIE;
}
}
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) )
_datagroupf=_datagroup4;
else
_datagroupf=_datagroup;
/*
* Construction du nom du dataset à lire
*/
if ( _MEDgetDatasetName(_datasetname,meddatatype,cmode) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetName");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
/*
* MAJ du champ transformation pour le (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if (_datagroup4) {
if ( _MEDattrEntierLire(_datagroup4,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
if ( (_dataset = _MEDdatasetOuvrir(_datagroupf,_datasetname)) < 0) {
_n=0;_dataset=0;*transformation = (med_bool) MED_FALSE;
/* if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname); */
/* SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4); */
/* ISCRUTE_size(_n); */
/* goto ERROR; */
/* } */
goto SORTIE;
}
if (!_datagroup4) {
/*
* Lire l'attribut CGT pour savoir si le dataset a changé
* n'a pas de sens si le dataset est en fait un lien vers le dataset précedent.
* En testant si le dataset est un lien on détermine si un changement a eu lieu
* depuis la séquence de calcul précédente.
* Ce traitement ne doit pas être effectué pour le pas de temps initial et pour
* (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if ( _MEDisasoftlink(_datagroupf, _datasetname,MED_TRUE, &_isasoftlink ) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_LINK,_datasetname);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
ISCRUTE_size(_n);goto ERROR;
}
if (_isasoftlink)
_transformation = MED_FALSE;
else {
if ( _MEDattrEntierLire(_dataset,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
}
*transformation = (med_bool) _transformation;
if ( ( meddatatype == MED_CONNECTIVITY) && ( meddatatype == MED_COORDINATE ) ) {
*transformation &= (med_bool) !_changement_s;
}
/*
* Attribut PFL (nombre de noeuds ou d'elements)
* la lecture est faite sur le datagroup _datagroup et non sur _datagroupf
* pour (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
_profilearraysize = 0;
profilename[0]='\0';
if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(profilename,_profilename,MED_NAME_SIZE+1);
profilename[MED_NAME_SIZE]='\0';
if ( ( _profilearraysize = MEDprofileSizeByName( fid,_profilename) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_profilename);SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
*profilesize=(med_int) _profilearraysize;
/*
* Attribut NBR (nombre d'entité)
*/
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_intn) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
SSCRUTE(_datasetname);SSCRUTE(MED_NOM_NBR);ISCRUTE_size(_n);goto ERROR;
}
_n = _intn;
if (_profilearraysize)
switch(storagemode) {
case MED_GLOBAL_PFLMODE :
break;
case MED_COMPACT_PFLMODE :
if ( meddatatype!=MED_COORDINATE_TRSF )
_n=_profilearraysize;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_STORAGEMODE,MED_ERR_VALUE_MSG);
ISCRUTE_int(storagemode);goto ERROR;
break;
}
SORTIE:
_ret = _n;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
ISCRUTE_id(_dataset);
}
if (_datagroup4>0) if (_MEDdatagroupFermer(_datagroup4) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname4);
ISCRUTE_id(_datagroup4);
}
if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
ISCRUTE_id(_datagroup3);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
/* _MEDobjetsOuverts(fid); */
*fret = _ret;
va_end(params);
return;
}
void
_MEDequivalenceInfo30(int dummy, ...)
{
med_idt _eqid=0;
med_err _ret=-1,_err=-1;
char _path[MED_TAILLE_EQS+2*MED_NAME_SIZE+2]=MED_EQS;
char _cstpname[2*MED_MAX_PARA+1]="";
int _num;
int _pathreflen=0;
med_size _nstep=0,_nocstpncorrespondence=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, int , , equivit );
MED_VARGS_DECL(, char *, const , equivname );
MED_VARGS_DECL(, char *, const , equivdescription );
MED_VARGS_DECL(, med_int *, const , nstep );
MED_VARGS_DECL(, med_int *, const , nocstpncorrespondence );
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(const, int , , equivit );
MED_VARGS_DEF(, char *, const , equivname );
MED_VARGS_DEF(, char *, const , equivdescription );
MED_VARGS_DEF(, med_int *, const , nstep );
MED_VARGS_DEF(, med_int *, const , nocstpncorrespondence );
MED_VARGS_DEF(, med_err * ,, fret );
_num=equivit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom de l'equivalence
*/
strcat(_path,meshname);
_pathreflen=strlen(_path);
if ( _MEDobjectGetName(fid, _path ,_num, equivname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(equivit);
goto ERROR;
}
_path[_pathreflen]='/';
strncpy(&_path[_pathreflen+1],equivname,MED_NAME_SIZE+1);
if ((_eqid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(_path);
goto ERROR;
}
/*
* L'attribut DES
*/
if ( _MEDattrStringLire(_eqid,MED_NOM_DES,MED_COMMENT_SIZE,equivdescription) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(_path);SSCRUTE(MED_NOM_DES);
goto ERROR;
}
/*
* Nombre d'$(0!;(Btapes de calcul
*/
if (_MEDnObjects(_eqid,".",&_nstep) <0) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
*nstep = (med_int) _nstep;
/*
* Nombre de correspondence pour <MED_NO_DT,MED_NO_IT>
*/
_MEDgetComputationStepName(MED_SORT_DTIT,MED_NO_DT,MED_NO_IT,_cstpname);
if ( (_err=_MEDnObjects(_eqid, _cstpname, &_nocstpncorrespondence)) < 0 )
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_cstpname);
goto ERROR;
}
*nocstpncorrespondence = (med_int) _nocstpncorrespondence;
_ret = 0;
ERROR:
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,&_path[_pathreflen]);
ISCRUTE_id(_eqid);
}
va_end(params);
*fret = _ret;
return;
}
med_err
MED231champInfoEtRen(med_idt fid,int indice,char *champ,
med_type_champ *type,char *comp,char *unit,
med_int ncomp)
{
med_err ret=0;
med_idt gid;
char chemin [MED_TAILLE_CHA+MED_TAILLE_NOM+1];
char chemini[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
char champf [MED_TAILLE_NOM+1];
int num;
med_int typechamp;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom du champ
*/
num = indice - 1;
strcpy(chemin,MED_CHA);
if ((ret = _MEDobjetIdentifier(fid,chemin,num,champ)) < 0)
return -1;
/*
* Si le Data Group cha n'existe pas => erreur
*/
if ( MAJ_231_232_chaine(champ,champf) ) {
fprintf(stdout," >>> Normalisation du nom de champ [%s] \n",champ);
/* on accede au maillage */
strcpy(chemini,chemin);
strcat(chemini,champ);
strcat(chemin,champf);
ret = H5Gmove(fid, chemini, chemin );
EXIT_IF(ret < 0,"Renommage du champ en",champf);
strcpy(champ,champf);
fprintf(stdout," >>> Normalisation du nom du champ [%s] ... OK ... \n",champf);
} else {
strcat(chemin,champ);
}
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_NOM,ncomp*MED_TAILLE_PNOM,
comp)) < 0)
return -1;
if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,ncomp*MED_TAILLE_PNOM,
unit)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return 0;
}
med_err
MED231champRefInfoEtRenMaa(med_idt fid,char *champ,
med_entite_maillage type_ent, med_geometrie_element type_geo,
int indice, med_int numdt, med_int numo,
char * maa, med_booleen * local, med_int *ngauss)
{
med_err ret=-1;
int num;
med_idt datagroup2=0,datagroup3=0,gid_maa=0,gid_lien=0;
char chemin[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA+1)+(MED_TAILLE_NOM)+1]="";
char chemini[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA+1)+(MED_TAILLE_NOM)+1]="";
char chemin_maa[MED_TAILLE_MAA+MED_TAILLE_NOM+1]="";
char chemin_lien[MED_TAILLE_LIENS+MED_TAILLE_NOM+1]="";
char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2]="";
char nomdatagroup2[2*MED_MAX_PARA+1]="";
char tmp1 [MED_TAILLE_NOM_ENTITE+1]="";
char maai [MED_TAILLE_NOM+1];
char maaf [MED_TAILLE_NOM+1]="";
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On construit le nom du datagroup
*/
strcpy(chemin,MED_CHA);
strcat(chemin,champ);
strcat(chemin,"/");
/*
* Si le Data Group de niveau 1 <type_ent>[.<type_geo>] n'existe pas => erreur
*/
/* modif pour la version 2.3.3 */
if (_MEDnomEntite(nomdatagroup1,type_ent) < 0)
goto ERROR;
if ((type_ent != MED_NOEUD)) {
if (_MEDnomGeometrie(tmp1,type_geo) < 0)
goto ERROR;
strcat(nomdatagroup1,".");
strcat(nomdatagroup1,tmp1);
}
strcat(chemin,nomdatagroup1);
strcat(chemin,"/");
/*
* Si le Data Group de niveau 2 <numdtt>.<numoo> n'existe pas => erreur
*/
sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
strcat(chemin,nomdatagroup2);
/*
* Modifie le nom de la première référence à un maillage
* si besoin est
*/
if ( (datagroup2 = _MEDdatagroupOuvrir(fid,chemin)) < 0 ) {
MESSAGE("Erreur à l'ouverture du datagroup : ");
SSCRUTE(chemin); goto ERROR;
}
if ( _MEDattrStringLire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maai) < 0 ) {
MESSAGE("Erreur de lecture de l'attribut MED_NOM_MAI : ");
SSCRUTE(maai); goto ERROR;
}
if ( MAJ_231_232_chaine(maai,maaf) ) {
fprintf(stdout," >>> Normalisation du nom de maillage par défaut [%s] associé au champ [%s] pour (n°dt,n°it) ("IFORMAT","IFORMAT")\n",maai,champ,numdt,numo);
ret = _MEDattrStringEcrire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maaf);
EXIT_IF(ret < 0,"Renommage du maillage en",maaf);
fprintf(stdout," >>> Normalisation du nom du maillage par défaut [%s] ... OK ... \n",maaf);
}
if (_MEDdatagroupFermer(datagroup2) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup2); goto ERROR;
}
strcat(chemin,"/");
/*
* Cherche le datagroup de niveau 3 <maa> correspondant à l'indice <num>
*/
num = indice - 1;
if (_MEDobjetIdentifier(fid,chemin,num,maa) < 0) {
MESSAGE("Impossible de trouver un groupe à l'indice spécifié : ");
SSCRUTE(chemin); ISCRUTE_int(num); goto ERROR;
};
if ( MAJ_231_232_chaine(maa,maaf) ) {
fprintf(stdout," >>> Normalisation du nom de maillage [%s] associé au champ [%s] pour (n°dt,n°it) ("IFORMAT","IFORMAT")\n",maa,champ,numdt,numo);
/* on accede au maillage */
strcpy(chemini,chemin);
strcat(chemini,maa);
strcat(chemin,maaf);
ret = H5Gmove(fid, chemini, chemin );
EXIT_IF(ret < 0,"Renommage du maillage en",maaf);
fprintf(stdout," >>> Normalisation du nom du maillage [%s] ... OK ... \n",maaf);
} else
strcat(chemin,maa);
/*
* Si le Data Group de niveau 3 <maa> n'existe pas => erreur
*/
if ((datagroup3 = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Erreur d'ouverture du datagroup lien au maillage : ");
SSCRUTE(chemin); goto ERROR;
};
/* Lire le nbre des points de GAUSS*/
if (_MEDattrEntierLire(datagroup3,MED_NOM_NGA,ngauss) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NGA : ");
ISCRUTE(*ngauss);goto ERROR;
};
/* Maillage local ou distant */
/* Les noms de maillages n'ayant pas encore été mis à jour
on garde l'ancien nom pour le test local/distant */
strcpy(chemin_maa,MED_MAA);
strcat(chemin_maa,maa);
/* Le maillage est il distant */
if ( (gid_maa = _MEDdatagroupOuvrir(fid,chemin_maa)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcpy(chemin_lien,MED_LIENS);
strcat(chemin_lien,maa);
if ((gid_lien = _MEDdatagroupOuvrir(fid,chemin_lien)) < 0) {
/* MESSAGE("Le maillage n'est ni local, ni distant : "); */
/* SSCRUTE(chemin_maa);SSCRUTE(chemin_lien); goto ERROR; */
*local = MED_FAUX;
}
*local = MED_FAUX;
} else
*local = MED_VRAI;
/*On retourne le nouveau nom de maillage*/
if ( strlen(maaf) ) strcpy(maa,maaf);
/*
* On ferme tout
*/
ret = 0;
ERROR:
if (datagroup3>0) if (_MEDdatagroupFermer(datagroup3) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup3); ret = -1;
}
if (gid_maa>0) if (_MEDdatagroupFermer(gid_maa) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid_maa); ret = -1;
}
if (gid_lien>0) if (_MEDdatagroupFermer(gid_lien) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
SSCRUTE(chemin_lien); ret = -1;
}
return ret;
}
med_err
MEDstructElementInfoByName(const med_idt fid,
const char * const modelname,
med_geometry_type * const mgeotype,
med_int* const modeldim,
char* const supportmeshname,
med_entity_type* const sentitytype,
med_int* const snnode,
med_int* const sncell,
med_geometry_type* const sgeotype,
med_int* const nconstantattribute,
med_bool* const anyprofile,
med_int* const nvariableattribute
)
{
med_err _ret=-1;
med_idt _elemid=0, _cstid=0;
char _path[MED_TAILLE_STRCT+MED_NAME_SIZE+1]=MED_STRCT;
char __profilename [MED_NAME_SIZE+1]=MED_NO_PROFILE_INTERNAL;
const char* _profilename = __profilename;
med_int _intentitytype = MED_UNDEF_ENTITY_TYPE;
med_int _nentity = 0;
med_size _tmpn = 0;
med_bool _chgt=MED_FALSE,_trsf=MED_FALSE;
med_int _medintmgeotype = MED_NONE;
med_int _medintsgeotype = MED_NONE;
med_int _intanyprofile = 0;
strcat(_path,modelname);
/*
* Si le DataGroup /STRUCT/<modelname> n'existe pas => erreur
*/
if ((_elemid = _MEDdatagroupOpen(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_NEO (numéro de type géométrique associé à un élément de structure)
*/
if ( _MEDattrEntierLire(_elemid,MED_NOM_NEO,&_medintmgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NEO);ISCRUTE(_medintmgeotype);
goto ERROR;
}
*mgeotype=_medintmgeotype;
/*
* Lecture de l'attribut MED_NOM_DIM (dimension de l'élément)
*/
if ( _MEDattrEntierLire(_elemid,MED_NOM_DIM,modeldim) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_DIM);ISCRUTE(*modeldim);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_NOM (nom du maillage support)
*/
/* Chercher plutôt ds le maillage support et supprimer les attributs NBM et NBN */
if ( _MEDattrStringLire(_elemid,MED_NOM_NOM,MED_NAME_SIZE,supportmeshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NOM);SSCRUTE(supportmeshname);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_ENT (type d'entité support)
*/
if ( _MEDattrEntierLire(_elemid,MED_NOM_ENT,&_intentitytype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_ENT);ISCRUTE(_intentitytype);
goto ERROR;
}
*sentitytype = (med_entity_type) _intentitytype;
/*
* Lecture de l'attribut MED_NOM_GEO (type géométrique des mailles support)
*/
if ( _MEDattrEntierLire(_elemid,MED_NOM_GEO,&_medintsgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_GEO);ISCRUTE(_medintsgeotype);
goto ERROR;
}
*sgeotype=_medintsgeotype;
/*
* Lecture du nombre de noeuds support
*/
if (strlen(supportmeshname)) {
if ( (*snnode = MEDmeshnEntity(fid,supportmeshname,MED_NO_DT,MED_NO_IT,
MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,
&_chgt,&_trsf) ) <= 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDmeshnEntity");
ISCRUTE(*snnode);goto ERROR;
}
} else {
*snnode=1;
}
/*
* Lecture du nombre de mailles support
*/
if (strlen(supportmeshname)) {
if ( (*sncell = MEDmeshnEntity(fid,supportmeshname,MED_NO_DT,MED_NO_IT,
MED_CELL,*sgeotype,MED_CONNECTIVITY,MED_NODAL,
&_chgt,&_trsf) ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDmeshnEntity");
ISCRUTE(*sncell);goto ERROR;
}
} else {
*sncell=0;
}
_MEDnObjects(_elemid,MED_CSTATR_NOM,&_tmpn);
if ( _tmpn > 0) {
if ((_cstid = _MEDdatagroupOpen(_elemid,MED_CSTATR_NOM)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_CSTATR_NOM);
SSCRUTE(_path);goto ERROR;
}
if ( _MEDattrEntierLire(_cstid,MED_NOM_PFU,&_intanyprofile) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_STRUCT_MSG);
SSCRUTE(modelname);SSCRUTE(MED_NOM_PFU);
goto ERROR;
}
*anyprofile=_intanyprofile;
*nconstantattribute = (med_int) _tmpn;
} else {
*anyprofile = MED_FALSE;
*nconstantattribute = 0;
}
_MEDnObjects(_elemid,MED_VARATR_NOM,&_tmpn);
if ( _tmpn > 0)
*nvariableattribute = (med_int) _tmpn;
else
*nvariableattribute = (med_int) 0;
_ret=0;
ERROR:
if (_cstid>0) if (_MEDdatagroupFermer(_cstid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_CSTATR_NOM);
ISCRUTE_id(_cstid);
}
if (_elemid>0) if (_MEDdatagroupFermer(_elemid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,modelname);
ISCRUTE_id(_elemid);
}
return _ret;
}
void
_MEDfieldInfoByName236(int dummy, ...) {
med_err _ret=-1,_err=-1;
med_idt _fieldgid=0,_meshgid=0,_linkgid=0;
char _fieldpath[MED_TAILLE_CHA+MED_TAILLE_NOM+1]=MED_CHA;
char _meshpath [MED_TAILLE_MAA+MED_TAILLE_NOM+1]=MED_MAA;
char _linkpath [MED_TAILLE_LIENS+MED_TAILLE_NOM+1]=MED_LIENS;
med_size _ncstp=0;
med_int _n=0;
med_int _intfieldtype=0;
char _meshrefpath236[(2*MED_TAILLE_NOM_ENTITE+1)+1+ (2*MED_MAX_PARA)+1]="";
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_field_type *, const , fieldtype );
MED_VARGS_DECL(, char *, const , componentname );
MED_VARGS_DECL(, char *, const , componentunit );
MED_VARGS_DECL(, char *, const , dtunit );
MED_VARGS_DECL(, med_int *, const , ncstp );
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 , fieldname );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_field_type *, const , fieldtype );
MED_VARGS_DEF(, char *, const , componentname );
MED_VARGS_DEF(, char *, const , componentunit );
MED_VARGS_DEF(, char *, const , dtunit );
MED_VARGS_DEF(, med_int *, const , ncstp );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
strcat(_fieldpath,fieldname);
if ((_fieldgid = _MEDdatagroupOuvrir(fid,_fieldpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_fieldpath);
goto ERROR;
}
/* Lecture de l'attribut MED_NOM_NCO */
if ( _MEDattrEntierLire(_fieldgid,MED_NOM_NCO,&_n) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NCO);
SSCRUTE(_fieldpath);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_TYP */
if ( _MEDattrEntierLire(_fieldgid,MED_NOM_TYP,&_intfieldtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(MED_NOM_TYP);
goto ERROR;
}
*fieldtype = (med_field_type) (_intfieldtype);
/*
* Les infos sur les composantes du champ
*/
if (_MEDattrStringLire(_fieldgid,MED_NOM_NOM,_n*MED_TAILLE_PNOM,
componentname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_NOM);
SSCRUTE(componentname);goto ERROR;
}
if (_MEDattrStringLire(_fieldgid,MED_NOM_UNI,_n*MED_TAILLE_PNOM,
componentunit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_UNI);
SSCRUTE(componentunit);goto ERROR;
}
/*
* On recupere le nom du premier couple (entitytype,geotype)
*/
if ( _MEDobjectGetName(_fieldgid, "." , 0, _meshrefpath236) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,".");
SSCRUTE(_meshrefpath236); goto ERROR;
}
/* Nombre d'étapes de calcul
* La gestion d'une incohérence sur le nombre de séquences de calcul par couple (entitytype,geotype)
* se fait à partir des appels :
* MEDfieldnProfile,MEDfieldnValue,MEDfieldnValueWithProfile
*/
if ( (_err=_MEDnObjects(_fieldgid,_meshrefpath236,&_ncstp)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_fieldpath);
goto ERROR;
}
*ncstp = (med_int) _ncstp;
/*
* On recupere le nom de maillage par défaut du premier couple (entitytype,geotype)
* La gestion des erreurs multimaillage 2.3.6 se fait à partir des appels :
* MEDfieldnProfile,MEDfieldnValue,MEDfieldnValueWithProfile
*/
strcat(_meshrefpath236,"/");
if ( _MEDobjectGetName(_fieldgid, _meshrefpath236 , 0, &_meshrefpath236[strlen(_meshrefpath236)]) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_meshrefpath236);
goto ERROR;
}
/* Lecture de l'attribut MED_NOM_UNI */
if ( _MEDattributeStringRdByName(_fieldgid,_meshrefpath236,MED_NOM_UNI,MED_TAILLE_PNOM,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_meshrefpath236);SSCRUTE(MED_NOM_UNI);
SSCRUTE(dtunit);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_MAI */
if ( _MEDattributeStringRdByName(_fieldgid,_meshrefpath236,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_meshrefpath236);SSCRUTE(MED_NOM_MAI);SSCRUTE(meshname);
goto ERROR;
}
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
_ret = 0;
ERROR:
if (_fieldgid>0) if (_MEDdatagroupFermer(_fieldgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_fieldpath);
ISCRUTE_id(_fieldgid);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
med_err
MEDindicesCoordLire(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;
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;
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)
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;
}
if ((ret = _MEDdatasetNumLire(noeid,nom_dataset,MED_FLOAT64,MED_FULL_INTERLACE,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,MED_PFL_NON_COMPACT,0,
MED_NOPG,0,(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 "NOM" (nom de la composante)
*/
if ((ret = _MEDattrStringLire(dataset,MED_NOM_NOM,MED_TAILLE_PNOM,comp)) < 0)
return -1;
/*
* Attribut "UNI" (unite de la composante)
*/
if ((ret = _MEDattrStringLire(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
_MEDfieldnProfile236(int dummy, ...) {
med_int _ret=-1,_err=-1;
med_idt _gid=0,_datagroup1=0;
char _path[(MED_TAILLE_CHA+MED_NAME_SIZE+1)+(2*MED_MAX_PARA+1)+1]=MED_CHA;
char _datagroupname1 [2*MED_TAILLE_NOM_ENTITE+2]="";
char _nomdatagroup2 [2*MED_MAX_PARA+1] ="";
char _geotype [MED_TAILLE_NOM_ENTITE+1] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _meshname [MED_NAME_SIZE+1] ="";
char _localizationname[MED_NAME_SIZE+1] ="";
med_int _numdt=0, _numit=0;
med_size _n=0,_ncpst=0;
med_bool _checkmultiplemesh=MED_TRUE, _multiplemesh =MED_FALSE;
med_bool _checkmeshname =MED_TRUE, _samedefaultmeshname=MED_FALSE;
char _tmp1 [MED_TAILLE_NOM_ENTITE+1]="";
/* med_size _rank; */
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(, char *, const , defaultprofilename );
MED_VARGS_DECL(, char *, const , defaultlocalizationname );
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 , fieldname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(, char *, const , defaultprofilename );
MED_VARGS_DEF(, char *, const , defaultlocalizationname );
MED_VARGS_DEF(, med_int * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
NOFINALBLANK(fieldname,ERROR);
/*
* Autorise la lecture du profile et de la localisation des points d'intégration
* s'il n'y a qu'un même maillage sur tous les pas de temps de tous les couples
* (typent,typgeo)
*/
#if ! defined(MED_CHECK_23FORMAT)
#error "Data model objects version checking must be either activated or deactivated, hence MED_CHECK_23FORMAT macro must be defined."
#error "Verify that you include med_config.h, thanks."
#endif
# if MED_CHECK_23FORMAT == 1
if ( _MEDfieldComputingStepCheck236(fid, fieldname,
&_ncpst,
_checkmultiplemesh, &_multiplemesh,
_checkmeshname, &_samedefaultmeshname) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FIELD,fieldname);
goto ERROR;
}
# endif
strcat(_path,fieldname);
strcat(_path,"/");
if (_MEDnomEntite(_datagroupname1,entitype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitype);SSCRUTE(_path);goto ERROR;
};
if ((entitype != MED_NOEUD)) {
if (_MEDnomGeometrie30(_tmp1,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(_path);goto ERROR;
}
strcat(_datagroupname1,".");
strcat(_datagroupname1,_tmp1);
}
strcat(_path,_datagroupname1);
if ((_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0) {
_ret = 0;
goto ERROR;
}
strcat(_path,"/");
/*TODO : Vérifier IFORMAT */
sprintf(_nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numit);
strcat(_path,_nomdatagroup2);
/* if ( _MEDobjectGetRank(fid, */
/* _path, */
/* _rank ) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDobjectGetRank"); */
/* goto ERROR; */
/* } */
if ((_gid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
_ret = 0;
goto ERROR;
}
strcat(_path,"/");
/*Lit l'attribut MED_NOM_NDT */
if ( _MEDattrEntierLire(_gid,MED_NOM_NDT, &_numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_NDT);
ISCRUTE(_numdt);goto ERROR;
}
if ( _numdt != numdt) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);ISCRUTE(_numdt);ISCRUTE(numdt);goto ERROR;
}
/*Lit l'attribut MED_NOM_NOR */
if ( _MEDattrEntierLire(_gid,MED_NOM_NOR, &_numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_NOR);
ISCRUTE(_numit); goto ERROR;
}
if ( _numit != numit) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);ISCRUTE(_numit);ISCRUTE(numit);goto ERROR;
}
/*Pas d'info maillage local ou distant*/
if (_MEDattrStringLire(_gid,MED_NOM_MAI,MED_TAILLE_NOM,_meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_MAI);
SSCRUTE(_meshname); goto ERROR;
};
strcat(_path,_meshname);
if ( _MEDattributeStringRdByName(fid, _path, MED_NOM_GAU, MED_TAILLE_NOM, _localizationname) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(MED_NOM_GAU);SSCRUTE(_localizationname);goto ERROR;
}
if ( ! strcmp(_localizationname,MED_NOGAUSSi))
strcpy(defaultlocalizationname,MED_NO_LOCALIZATION);
else
strcpy(defaultlocalizationname,_localizationname);
if ( _MEDattributeStringRdByName(fid, _path, MED_NOM_PFL, MED_TAILLE_NOM, _profilename) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NOPFLi) &&
strcmp(_profilename,"") ) /* le test MED_NOPFLi pour des raisons de compatibilité */
{
strcpy(defaultprofilename,_profilename);
} else {
strcpy(defaultprofilename, MED_NO_PROFILE);
}
_ret = (med_int) 1;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
SSCRUTE(_datagroupname1); ISCRUTE_id(_datagroup1);
}
if (_gid>0) if (_MEDdatagroupFermer(_gid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_gid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDfieldnProfile30(int dummy, ...) {
med_int _ret=-1,_err=-1;
med_idt _gid=0,_datagroup1=0;
char _path[(MED_TAILLE_CHA+MED_NAME_SIZE+1)+(2*MED_MAX_PARA+1)+1]=MED_CHA;
char _datagroupname1[2*MED_TAILLE_NOM_ENTITE+2]="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _profilename [MED_NAME_SIZE+1]="";
med_int _numdt=0, _numit=0;
med_size _n=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(, char *, const , defaultprofilename );
MED_VARGS_DECL(, char *, const , defaultlocalizationname );
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 , fieldname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(, char *, const , defaultprofilename );
MED_VARGS_DEF(, char *, const , defaultlocalizationname );
MED_VARGS_DEF(, med_int * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
NOFINALBLANK(fieldname,ERROR);
/*
* On construit le chemin d'acc�s jusqu'aux groupes <type_ent>[.<type_geo>]
*/
strcat(_path,fieldname);
strcat(_path,"/");
_MEDgetComputationStepName(MED_SORT_DTIT,numdt,numit,&_path[strlen(_path)]);
strcat(_path,"/");
if ((_gid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path); goto ERROR;
}
/*Lit l'attribut MED_NOM_NDT */
if ( _MEDattrEntierLire(_gid,MED_NOM_NDT, &_numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_NDT);
ISCRUTE(_numdt);goto ERROR;
}
if ( _numdt != numdt) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);ISCRUTE(_numdt);ISCRUTE(numdt);goto ERROR;
}
/*Lit l'attribut MED_NOM_NOR */
if ( _MEDattrEntierLire(_gid,MED_NOM_NOR, &_numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_NOR);
ISCRUTE(_numit); goto ERROR;
}
if ( _numit != numit) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);ISCRUTE(_numit);ISCRUTE(numit);goto ERROR;
}
/*
* Si le Data Group de niveau <type_ent>[.<type_geo>] n'existe pas retroune 0
*/
if (_MEDgetEntityTypeName(_datagroupname1,entitype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ENTITY,_datagroupname1);
goto ERROR;
}
if (entitype != MED_NODE) {
if ( entitype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid,geotype,_geotypename) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else {
if (_MEDgetInternalGeometryTypeName(_geotypename,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_GEOMETRIC,_geotypename);
goto ERROR;
}
}
strcat(_datagroupname1,".");
strcat(_datagroupname1,_geotypename);
}
/* strcat(_path,_datagroupname1); */
/* strcat(_path,"/"); */
if ((_datagroup1 = _MEDdatagroupOuvrir(_gid,_datagroupname1)) < 0) {
*defaultprofilename='\0';
*defaultlocalizationname='\0';
_ret = 0;
goto ERROR;
}
if ((_err=_MEDnObjects(_datagroup1,".",&_n)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
/* Lit le nom du profil associ� s'il en existe d�j� un */
if ( _MEDattrStringLire(_datagroup1,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_PFL);
goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(defaultprofilename,_profilename,MED_NAME_SIZE+1);
defaultprofilename[MED_NAME_SIZE]='\0';
} else {
defaultprofilename[0]='\0';
}
/* Lit le nom de la localization associ� s'il en existe d�j� une */
if ( _MEDattrStringLire(_datagroup1,MED_NOM_GAU,MED_NAME_SIZE,defaultlocalizationname) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_path);SSCRUTE(MED_NOM_GAU);
goto ERROR;
}
_ret = (med_int) _n;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
SSCRUTE(_datagroupname1); ISCRUTE_id(_datagroup1);
}
if (_gid>0) if (_MEDdatagroupFermer(_gid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_gid);
}
va_end(params);
*fret = _ret;
return;
}
