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;
}
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;
}
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
_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;
}
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;
}
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;
}
med_geometry_type
MEDstructElementCr(const med_idt fid,
const char* const modelname,
const med_int modeldim,
const char* const supportmeshname,
const med_entity_type sentitytype,
const med_geometry_type sgeotype
)
{
med_access_mode _MED_ACCESS_MODE;
med_err _err=-1;
med_idt _root=0,_elemid=0;
med_int _ret=-1;
char _path[MED_TAILLE_STRCT+MED_NAME_SIZE+1]=MED_STRCT;
med_size _tmpn=0;
med_geometry_type _stgeotype=0;
med_int _medintstgeotype = 0;
med_int _medintsgeotype = sgeotype;
med_int _intentitytype = sentitytype;
med_int _nnode=0,_ncell=0;
med_bool _chgt=MED_FALSE,_trsf=MED_FALSE;
/* char _entitytypename[MED_TAILLE_NOM_ENTITE+1]=""; */
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /STRUCT/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOpen(fid,_path)) < 0)
if ((_root = _MEDdatagroupCrOrderCr(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(modelname,ERROR);
/*
* Si le DataGroup /STRUCT/<modelname> n'existe pas, on le cree
*/
if ((_elemid = _MEDdatagroupOpen(_root,modelname)) < 0) {
if ((_elemid = _MEDdatagroupCreer(_root,modelname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,modelname);
SSCRUTE(_path);goto ERROR;
}
} else {
/*
* 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,&_medintstgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NEO);ISCRUTE(_medintstgeotype);
goto ERROR;
}
_stgeotype = _medintstgeotype;
}
strcat(_path,modelname);
/*
* Creation/Ecriture de l'attribut MED_NOM_DIM (dimension de l'�l�ment)
*/
if ( _MEDattributeIntWr(_elemid,MED_NOM_DIM,&modeldim) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_DIM);ISCRUTE(modeldim);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_NOM (nom du maillage support)
*/
if ( _MEDattributeStringWr(_elemid,MED_NOM_NOM,MED_NAME_SIZE,supportmeshname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NOM);SSCRUTE(supportmeshname);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_ENT (type d'entit� support)
*/
/* if (_MEDgetEntityTypeName(_entitytypename,sentitytype) < 0) { */
/* MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG); */
/* ISCRUTE_int(sentitytype);SSCRUTE(_entitytypename);SSCRUTE(_path); */
/* goto ERROR; */
/* } */
if ( _MEDattributeIntWr(_elemid,MED_NOM_ENT,&_intentitytype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_ENT);ISCRUTE(_intentitytype);
goto ERROR;
}
/*
Lecture dans le maillages support du nombre de noeuds
S'il n'y a pas de maillage support : 1
*/
if (strlen(supportmeshname)) {
if ( (_nnode = 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(_nnode);goto ERROR;
}
} else {
_nnode=1;
}
if (strlen(supportmeshname)) {
if ( (_ncell = 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(_ncell);goto ERROR;
}
} else {
_ncell=0;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_GEO (type g�om�trique des mailles support)
*/
_medintsgeotype = sgeotype;
if ( _MEDattributeIntWr(_elemid,MED_NOM_GEO,&_medintsgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_GEO);ISCRUTE(_medintsgeotype);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_NAV (nombre d'attributs variables associ�s � un �l�ment de structure)
*/
/* if ( _MEDattributeIntWr(_elemid,MED_NOM_NAV,&nvariableattribute) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path); */
/* SSCRUTE(MED_NOM_NAV);ISCRUTE(nvariableattribute); */
/* goto ERROR; */
/* } */
/*
* Creation/Ecriture de l'attribut MED_NOM_NAC (nombre d'attributs constant associ�s � un �l�ment de structure)
*/
/* if ( _MEDattributeIntWr(_elemid,MED_NOM_NAC,&nconstattribute) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path); */
/* SSCRUTE(MED_NOM_NAC);ISCRUTE(nconstattribute); */
/* goto ERROR; */
/* } */
/*
* Nombre d'�l�ments de structure
*/
if ( !_stgeotype ) {
/*Si l'�l�ment de struture ne pr�-existait pas,
il a �t� cr�e en d�but de proc�dure (il y a au moins 1 �l�ment dans le groupe) */
if ((_err=_MEDnObjects(fid,MED_STRCT,&_tmpn)) <0) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_STRUCT,MED_STRCT);
goto ERROR;
}
_stgeotype=_tmpn+MED_STRUCT_GEO_INTERNAL;
_medintstgeotype=_stgeotype;
/*
* Ecriture de l'attribut MED_NOM_NEO (num�ro de type g�om�trique associ� � un �l�ment de structure)
*/
if ( _MEDattributeIntWr(_elemid,MED_NOM_NEO,&_medintstgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NEO);ISCRUTE(_medintstgeotype);
goto ERROR;
}
}
_ret = _stgeotype;
ERROR:
if (_elemid>0) if (_MEDdatagroupFermer(_elemid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_elemid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_STRCT);
ISCRUTE_id(_root);
}
return _ret;
}
med_err _MEDfieldComputingStepCheck236(med_idt fid, const char * const fieldname,
med_size * const ncpst,
med_bool checkmultiplemesh, med_bool * const multiplemesh,
med_bool checkmeshname, med_bool * const samedefaultmeshname)
{
med_err _ret=-1,_err=0;
med_idt _cstpid=0;
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;
int _pathlen=0;
med_size _i=0,_n=0;
med_size _prevnseq=0,_nseq =0;
med_string_itdatas _itdatas;
if( _MEDfieldChecked(fid,fieldname) ) goto SORTIE;
/*
* On construit le nom du datagroup
*/
strcat(_path,fieldname);
/*
* On compte le nombre de couple (entitytype,geotype)
*/
if ((_err=_MEDnObjects(fid,_path,&_n)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,MED_NOM_ENT "." MED_NOM_GEO);
goto ERROR;
}
_pathlen = strlen(_path);
/*
* Pour tous les couples (entitytype,geotype)
* on vérifie qu'il y a le même nombre de séquences de calcul (sinon le fichier n'est pas conforme au modèle 2.3.6)
* Ceci est une vérification partielle que le modèle 2.3.6 a été respecté :
* - Il faudrait normalement vérifier qu'il s'agit aussi des mêmes séquences de calcul
* Etant donnée la faible utilisation du usecase multimaillages et le coût de traitement associé à cette
* vérification complémentaire, celle-ci n'est pas faite.
* Par contre, il est necessaire de savoir si plusieurs noms de maillages
apparaissent ou si un seul est utilisé (ici on vérifie uniquement que le maillage par défaut est le même)
*/
/*L'attribut dont il faut vérifier la valeur pour toutes les étapes de calcul de tous les
couple (entitytype,geotype) est MED_NOM_MAI*/
if (checkmeshname) _MEDcheckAttributeStringInit(&_itdatas,MED_NOM_MAI,MED_TAILLE_NOM);
for (_i=0; _i <_n; ++_i ) {
/*
* On recupere le nom du couple (entitytype,geotype) n°_i
*/
if ( _MEDobjectGetName(fid, _path ,_i, _ent_geo) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); goto ERROR;
}
/* SSCRUTE(_path); */
strcpy(&_path[_pathlen],"/");
strcat(_path,_ent_geo);
/* SSCRUTE(_path); */
/* ISCRUTE(_prevnseq); */
/* ISCRUTE(_nseq); */
/*
* On vérifie qu'il y a le même nombre de séquences de calcul
* que pour le couple (entitytype,geotype) précédent
* on le vérifie pas que ce sont bien les mêmes
*/
if ( _prevnseq != _nseq ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_ent_geo);
ISCRUTE_size(_prevnseq);ISCRUTE_size(_nseq);ISCRUTE_size(_i);
goto ERROR;
}
/*
* On compte le nombre de séquences de calcul pour le couple (entitytype,geotype) n°_i
*/
if ((_err=_MEDnObjects(fid,_path,&_nseq)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_ent_geo);
goto ERROR;
}
_prevnseq = _nseq;
if (checkmeshname || checkmultiplemesh) {
if ((_cstpid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
}
if (checkmeshname) {
/*
* On vérifie que le nom du maillage par défaut est le même pour toutes
* les étapes de calcul de tous les couples (entitytype,geotype)
*/
if (_MEDiterate(_cstpid, _MEDcheckAttributeStringFunc, &_itdatas ) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ATTRIBUTE,MED_ERR_VALUE_MSG);
SSCRUTE(_itdatas.attvalprec); SSCRUTE(_itdatas.attval); goto ERROR;
}
}
/*
* On vérifie qu'un seul maillage est utilisé pour toutes
* les étapes de calcul de tous les couples (entitytype,geotype)
*/
if (checkmultiplemesh) {
if (_MEDiterate(_cstpid, _MEDchecknSublinkFunc, multiplemesh ) < 0) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,MED_ERR_NBR_MSG MED_ERR_MESH_MSG);
SSCRUTE(_path);goto ERROR;
}
}
if (_cstpid>0) if (_MEDdatagroupFermer(_cstpid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_cstpid);
}
_path[_pathlen]='\0';
}
if (checkmeshname) _MEDcheckAttributeStringFin(&_itdatas);
*ncpst = _nseq;
_MEDfieldCheckedSetCache(fid, fieldname,MED_TRUE);
SORTIE:
_ret = 0;
ERROR:
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;
}
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;
}
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 _MEDnFamily30(int dummy, ...)
{
med_int _ret=-1;
char _path[MED_FAMILY_GRP_SIZE+MED_NAME_SIZE+MED_TAILLE_FAS_ENTITE+MED_NAME_SIZE+1]=MED_FAMILY_GRP;
int _pathreflen=0;
med_int _n=0;
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
*/
_MEDmodeErreurVerrouiller();
strcat(_path,meshname);
_pathreflen=strlen(_path);
/* SSCRUTE(_path); */
if ( (_ret=_MEDnObjects(fid,_path,&_tmpn)) < 0)
if ( _ret == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
_n = (med_int ) _tmpn;
/* ISCRUTE(_n); */
/* Comptage des familles de mailles/faces/aretes */
strcat(_path,MED_FAS_ELEME);
/* SSCRUTE(_path); */
if ( (_ret=_MEDnObjects(fid,_path,&_tmpn)) < 0 ) {
if ( _ret == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
} else {
/* ISCRUTE(_ret); */
_n --; _n += (med_int ) _tmpn;
}
/* ISCRUTE(_ret); */
/* ISCRUTE(_n); */
/* Comptage des familles de noeuds */
strncpy(&_path[_pathreflen],MED_FAS_NOEUD,MED_TAILLE_FAS_ENTITE+1);
/* SSCRUTE(_path); */
if ( (_ret=_MEDnObjects(fid,_path,&_tmpn)) < 0 ) {
if ( _ret == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
} else {
_n --; _n += (med_int ) _tmpn;
}
/* ISCRUTE(_n); */
_ret = _n;
ERROR:
va_end(params);
*fret = _ret;
return;
}
void
_MEDmeshnEntity236(int dummy, ...)
{
med_int _ret=-1,_n=0,_tmpn=0;
med_size _nn =0;
med_data_type _meddatatype;
med_int _nfaces=0;
char _meshpath[MED_TAILLE_MAA+MED_TAILLE_NOM+1]=MED_MAA;
med_idt _meshid=0,_datagroup1=0;
char _datagroupname1[MED_TAILLE_NOM_ENTITE+1]="";
med_err _err =0;
med_bool _datagroupexist=MED_FALSE;
med_bool _isasoftlink =MED_FALSE;
int _cmodeit=0, _ncmode=1;
med_connectivite _cmode[2] = { MED_NO_CMODE, MED_NO_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 );
_meddatatype=meddatatype;
if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
_cmode[0]= (med_connectivite) cmode;
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) goto SORTIE;
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
strcat(_meshpath,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);goto ERROR;
}
if( _MEDdatagroupExist(_meshid,MED_NOM_NOE,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_NOE);goto ERROR;
}
if ( _datagroupexist ) _nn++;
if( _MEDdatagroupExist(_meshid,MED_NOM_MAI,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_MAI);goto ERROR;
}
if ( _datagroupexist ) _nn++;
if( _MEDdatagroupExist(_meshid,MED_NOM_FAC,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_FAC);goto ERROR;
}
if ( _datagroupexist ) _nn++;
if( _MEDdatagroupExist(_meshid,MED_NOM_ARE,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_ARE);goto ERROR;
}
if ( _datagroupexist ) _nn++;
/* En 2.3.6 les familles, les équivalences ... sont stockées dans le groupe <meshname>*/
/* _err=_MEDnObjects(_meshid,".",&_nn); */
/* if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) { */
/* MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_meshid); */
/* goto ERROR; */
/* } */
_n = _nn;
goto SORTIE;
}
if ( geotype == MED_GEO_ALL ) {
strcat(_meshpath,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);goto ERROR;
}
if (_MEDgetEntityTypeName(_datagroupname1,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);goto ERROR;
}
if ((_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0) {
_n=0;_datagroup1=0;
goto SORTIE;
}
_err=_MEDnObjects(_datagroup1,".",&_nn);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
/* SSCRUTE(_datagroupname1);ISCRUTE_long(_nn); */
if ( ( entitytype == MED_NODE ) && (_nn > 0) ) _nn=1;
/* SSCRUTE(_datagroupname1);ISCRUTE_long(_nn); */
_n = _nn;
goto SORTIE;
}
switch( meddatatype )
{
case MED_GLOBAL_NUMBER:
case MED_NAME:
case MED_NUMBER:
case MED_FAMILY_NUMBER:
switch (entitytype) {
case MED_NODE:
/*Pour connaître le nombre d'entités des attributs optionnels,
on se base sur le tableau de coordonnées */
/* _meddatatype = MED_COORDINATE; */
break;
case MED_CELL:
case MED_DESCENDING_FACE:
case MED_DESCENDING_EDGE:
/*Pour connaître le nombre d'entités des attributs optionnels,
on se base sur le tableau de connectivité */
/* _meddatatype = MED_CONNECTIVITY; */
/*
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et le cmode non
* positionné.
* Cette Information est necessaire pour construire le nom du datatset.
*/
if ( _cmode[0] == MED_NO_CMODE ) {
_ncmode =2;_cmode[0]=MED_NOD;_cmode[1]=MED_DESC;
}
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);goto ERROR;
}
goto CALL_NENT;
case MED_COORDINATE: /*Par extension au CONNECTIVITY mais ne devrait pas être utilisé.*/
case MED_CONNECTIVITY:
if ( geotype == MED_POLYGON2 ) {_n=0; break;}
if ( geotype == MED_POLYGON ) {
if ( MEDpolygoneInfo( fid,(char *)meshname, (med_entite_maillage) entitytype, (med_connectivite) _cmode[0],
&_n) < 0) {
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDpolygoneInfo");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
_n=0;
}
break;
}
if ( geotype == MED_POLYHEDRON ) {
if ( MEDpolyedreInfo(fid,(char *) meshname, (med_connectivite) _cmode[0]
,&_nfaces,&_n) < 0) {
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDpolyedreInfo");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
_n=0;
}
break;
}
goto CALL_NENT;
case MED_INDEX_FACE:
if ( geotype == MED_POLYHEDRON ) {
_meddatatype = MED_CONNECTIVITY;
_n=1 ;
goto CALL_NENT;
/* if ( (_n = MEDnEntMaa(fid,meshname,(med_table) MED_CONNECTIVITY, (med_entite_maillage) MED_CELL, */
/* (med_geometrie_element) MED_POLYHEDRON, (med_connectivite) MED_NOD)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDnEntMaa");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
/* } */
_n+=1;
break;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);
goto ERROR;
}
case MED_INDEX_NODE:
if ( geotype == MED_POLYHEDRON ) {
if ( MEDpolyedreInfo(fid,(char *) meshname, (med_connectivite) _cmode[0],&_nfaces, &_n) < 0) {
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDpolyedreInfo");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
_nfaces=0;
}
_n=_nfaces;
break;
} else
if ( (geotype == MED_POLYGON) || (geotype == MED_POLYGON2) ) {
_meddatatype = MED_CONNECTIVITY;
_n = 1;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);goto ERROR;
}
case MED_COORDINATE_AXIS1:
case MED_COORDINATE_AXIS2:
case MED_COORDINATE_AXIS3:
CALL_NENT:
for (_cmodeit=0; _cmodeit < _ncmode; ++_cmodeit)
if ( (_tmpn = MEDnEntMaa( fid, (char *) meshname,
(med_table) _meddatatype,
(med_entite_maillage) entitytype,
(med_geometrie_element) geotype,
(med_connectivite) _cmode[_cmodeit]) ) > 0 )
break;
if ( _tmpn < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDnEntMaa");SSCRUTE(meshname);
ISCRUTE_int(_meddatatype);ISCRUTE_int(entitytype);ISCRUTE_int(geotype);goto ERROR;
}
_n+=_tmpn;
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_MEDDATATYPE,MED_ERR_VALUE_MSG);
ISCRUTE_int(meddatatype);goto ERROR;
}
SORTIE:
*transformation = MED_FALSE;
/*TODO : 3.0.1 : Tester la présence d'autres datasets
que les coord/conn/index pour positionner chgt TRUE uniquement
dans ce cas de figure.*/
*changement = MED_TRUE;
*profilesize = 0;
profilename[0] = '\0';
_ret = _n;
ERROR:
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);
}
*fret = _ret;
va_end(params);
return;
}
void _MEDequivalenceComputingStepInfo30(int dummy, ...) {
med_err _ret=-1,_err=-1;
med_idt _eqid=0,_datagroup1=0;
int _num;
char _cstppath[MED_TAILLE_EQS+2*MED_NAME_SIZE+2+2*MED_MAX_PARA+1]=MED_EQS;
char _cstpname[2*MED_MAX_PARA+1]="";
med_size _ncorrespondence=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, char * , const , equivname );
MED_VARGS_DECL(const, int , , csit );
MED_VARGS_DECL(, med_int *, const , numdt );
MED_VARGS_DECL(, med_int *, const , numit );
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, char * , const , equivname );
MED_VARGS_DEF(const, int , , csit );
MED_VARGS_DEF(, med_int *, const , numdt );
MED_VARGS_DEF(, med_int *, const , numit );
MED_VARGS_DEF(, med_int *, const , nocstpncorrespondence );
MED_VARGS_DEF(, med_err * ,, fret );
_num = csit -1;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
strcat( _cstppath, meshname);
strcat( _cstppath, "/");
strcat( _cstppath, equivname);
if ((_eqid = _MEDdatagroupOuvrir(fid,_cstppath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_cstppath);
ISCRUTE_id(_eqid);goto ERROR;
}
strcat( _cstppath, "/");
/*
* On recupere le nom de l'~tape de calcul
*/
if ( _MEDobjectGetName(fid, _cstppath ,_num, &_cstppath[strlen(_cstppath)]) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_cstppath);ISCRUTE_int(csit);
goto ERROR;
}
if ( (_datagroup1 = _MEDdatagroupOuvrir(fid,_cstppath)) < 0 ) {
MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_COMPUTINGSTEP,_cstppath);
SSCRUTE(_cstppath);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_NDT pour lecture */
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_NDT,numdt) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(_cstppath);SSCRUTE(MED_NOM_NDT);
ISCRUTE(*numdt);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_PDT pour lecture */
/* if ( _MEDattrFloatLire(_datagroup1,MED_NOM_PDT,dt) < 0) { */
/* MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG); */
/* SSCRUTE(equivname);SSCRUTE(_cstppath);SSCRUTE(MED_NOM_PDT); */
/* RSCRUTE(*dt);goto ERROR; */
/* } */
/*Cree ou ouvre l'attribut MED_NOM_NOR pour lecture */
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_NOR,numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(_cstppath);SSCRUTE(MED_NOM_NOR);
ISCRUTE(*numit); goto ERROR;
}
/*
* Nombre de tableau d'~quivalence
*/
if ((_err=_MEDnObjects(_datagroup1,".",&_ncorrespondence)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,equivname);
goto ERROR;
}
*nocstpncorrespondence = (med_int) _ncorrespondence;
_ret = 0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_cstppath);
ISCRUTE_id(_datagroup1);
}
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_eqid);
}
va_end(params);
*fret = _ret;
return;
}
void MAJ_236_300_champs(med_idt fid)
{
med_err lret,ret;
/* med_idt _datagroup=0; */
med_field_type typcha;
char nomcha [MED_NAME_SIZE+1]="";
char _meshname [MED_NAME_SIZE+1]="";
char _dtunit [MED_SNAME_SIZE+1]="";
char *comp= NULL, *unit= NULL;
med_int ncomp,ncha;
med_int _ncstp=0;
med_bool _local=MED_FALSE;
htri_t _datasetexist;
char _pathi[MED_TAILLE_CHA+1+MED_NAME_SIZE+1]=MED_CHA;
char _pathf[MED_TAILLE_CHA+2+MED_NAME_SIZE+1]="/CHA_/";
char _pathtmp[MED_TAILLE_CHA+3]="/CHA__/";
int i,j;
char nomlien[MED_NAME_SIZE+1]="";
char * lien = NULL;
med_int nln,nval;
med_int _nloc,_intgeotype,_sdim;
char _pathloc[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
med_int _npar,_numdt,_numit;
char _pathpari[MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1+2*MED_MAX_PARA+1+1]=MED_NUM_DATA;
char _pathparf[MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1+2*MED_MAX_PARA+1+1]=MED_NUM_DATA;
int _pathparlen;
med_size _n=0;
char _cpstnamei[2*MED_MAX_PARA+1]="";
char _cpstnamef[2*MED_MAX_PARA+1]="";
char _uniname[MED_SNAME_SIZE+1]="";
/* hid_t _lac_plist_id; */
hid_t _lcp_plist_id;
hid_t _ocp_plist_id;
med_bool _createunt = MED_TRUE;
MAJ_version_num(fid,2,3,6);
/* MAJ des varaibles scalaires */
_npar = MEDnParameter(fid);
if (_npar > 0) {
fprintf(stdout," >>> Normalisation des paramètres scalaires\n");
_pathparf[MED_TAILLE_NUM_DATA-2]='_';
/* _lac_plist_id = H5Pcreate( H5P_LINK_ACCESS ); */
_ocp_plist_id = H5Pcreate( H5P_OBJECT_COPY );
_lcp_plist_id = H5Pcreate( H5P_LINK_CREATE );
H5Pset_create_intermediate_group( _lcp_plist_id, 1 );
H5Pset_copy_object( _ocp_plist_id, H5O_COPY_SHALLOW_HIERARCHY_FLAG);
}
for (i=0 ; i < _npar ; i++ ) {
MED_ERR_EXIT_IF (_MEDobjectGetName(fid, _pathpari ,i, &_pathpari[MED_TAILLE_NUM_DATA]) < 0,
MED_ERR_ACCESS,MED_ERR_DATAGROUP,_pathpari);
strcpy(&_pathparf[MED_TAILLE_NUM_DATA],&_pathpari[MED_TAILLE_NUM_DATA]);
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
/*Copie le group avec ses attributs et les objets de premier niveau.*/
ret = H5Ocopy(fid,_pathpari,fid,_pathparf,_ocp_plist_id,_lcp_plist_id);
/* ret = H5Lcopy(fid,_pathpari,fid,_pathparf,_lcp_plist_id,_lac_plist_id); */
EXIT_IF(ret < 0,"Copie du datagroup",_pathpari);
_pathparlen=strlen(_pathpari);
_pathpari[_pathparlen]='/';_pathparf[_pathparlen]='/';
++_pathparlen;
_pathpari[_pathparlen]='\0';_pathparf[_pathparlen]='\0';
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
ret =_MEDnObjects(fid,_pathpari, &_n);
MED_ERR_EXIT_IF( (ret == (MED_ERR_COUNT + MED_ERR_DATAGROUP)), MED_ERR_COUNT,MED_ERR_PARAMETER,_pathpari);
for (j=0 ; j < _n ; ++j ) {
MED_ERR_EXIT_IF (_MEDobjectGetName(fid, _pathpari ,j, &_pathpari[_pathparlen]) < 0,
MED_ERR_ACCESS,MED_ERR_DATAGROUP,_pathpari);
MED_ERR_EXIT_IF (_MEDattributeNumRdByName(fid,_pathpari,MED_NOM_NOR,
MED_INTERNAL_INT,(unsigned char * const ) &_numit) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
MED_ERR_EXIT_IF (_MEDattributeNumRdByName(fid,_pathpari,MED_NOM_NDT,
MED_INTERNAL_INT,(unsigned char * const ) &_numdt) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
MED_ERR_EXIT_IF (_MEDattributeStringRdByName(fid,_pathpari,MED_NOM_UNI,
MED_SNAME_SIZE,_uniname) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
_MEDgetComputationStepName(MED_SORT_DTIT,_numdt,_numit,&_pathparf[_pathparlen]);
/* strcat(_pathpari,"/"); */
/* strcat(_pathparf,"/"); */
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
/* ret = H5Ocopy(fid,_pathpari,fid,_pathparf,_ocp_plist_id,_lcp_plist_id); */
/* ret = H5Lcopy(fid,_pathpari,fid,_pathparf,_lcp_plist_id,_lac_plist_id); */
/* H5Eprint1(stderr); */
/* EXIT_IF(ret < 0,"Copie d'une étape de calcul du paramètre scalaire ",_pathpari); */
/*On modifie temporairement _pathpari pour pointer dans _pathparf*/
_pathpari[MED_TAILLE_NUM_DATA-2]='_';
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
ret = H5Gmove(fid, _pathpari, _pathparf );
EXIT_IF(ret < 0,"Renommage de l'étape de calcul",_pathpari);
_pathpari[MED_TAILLE_NUM_DATA-2]='A';
MED_ERR_EXIT_IF(H5Adelete_by_name( fid, _pathparf, MED_NOM_UNI, H5P_DEFAULT ) < 0,
MED_ERR_DELETE,MED_ERR_ATTRIBUTE,_pathparf);
_pathparf[_pathparlen]='\0';
_pathpari[_pathparlen]='\0';
if ( _createunt ) {
MED_ERR_EXIT_IF (_MEDattributeStringWrByName(fid,_pathparf,MED_NOM_UNT, MED_SNAME_SIZE,_uniname) < 0,
MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_UNT);
_createunt = MED_FALSE;
}
}
_createunt = MED_TRUE;
_pathpari[MED_TAILLE_NUM_DATA]='\0';
}
if ( _npar > 0 ) {
_pathpari[MED_TAILLE_NUM_DATA]='\0';
_pathparf[MED_TAILLE_NUM_DATA]='\0';
MED_ERR_EXIT_IF ( H5Ldelete(fid,_pathpari,H5P_DEFAULT) < 0 ,
MED_ERR_DELETE,MED_ERR_LINK,_pathpari);
ret = H5Gmove(fid, _pathparf, _pathpari );
EXIT_IF(ret < 0,"Renommage du group de paramètres scalaires",_pathparf);
}
/* MAJ des localisations */
_nloc = MEDnLocalization(fid);
/* ISCRUTE(_nloc); */
if (_nloc > 0)
fprintf(stdout," >>> Normalisation des localisations des points d'intégration\n");
for (i=0 ; i < _nloc ; i++ ) {
/* SSCRUTE(_pathloc); */
MED_ERR_EXIT_IF (_MEDobjectGetName(fid, _pathloc ,i, &_pathloc[MED_TAILLE_GAUSS]) < 0,
MED_ERR_ACCESS,MED_ERR_DATAGROUP,_pathloc);
/* SSCRUTE(_pathloc); */
MED_ERR_EXIT_IF (_MEDattributeNumRdByName(fid,_pathloc,MED_NOM_GEO,
MED_INTERNAL_INT,(unsigned char * const ) &_intgeotype) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
_sdim = (_intgeotype/100);
MED_ERR_EXIT_IF (_MEDattributeNumWrByName(fid,_pathloc,MED_NOM_DIM,
MED_INTERNAL_INT,(const unsigned char * const) &_sdim) < 0,
MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_DIM);
MED_ERR_EXIT_IF ( _MEDattributeStringWrByName(fid,_pathloc,MED_NOM_INM,MED_NAME_SIZE,"") < 0,
MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_INM);
_pathloc[MED_TAILLE_GAUSS]='\0';
}
/* MAJ des liens */
nln = MEDnLink(fid);
if (nln > 0)
fprintf(stdout," >>> Normalisation des liens\n");
for (i=1 ; i <= nln ; i++ ) {
ret = MEDlinkInfo(fid, i, nomlien, &nval);
EXIT_IF(ret,"Erreur a la demande d'information sur le lien",NULL);
/* printf("\t- Lien n°%i de nom |%s| et de taille "IFORMAT"\n",i,nomlien,nval); */
lien = (char *) malloc((nval+1)*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
ret = MEDlinkRd(fid, nomlien, lien );
EXIT_IF(ret,"Erreur a la lecture du lien : ",nomlien);
MAJ_version_num(fid,3,0,8);
ret = MED30linkWr(fid,nomlien,lien);
EXIT_IF(ret,"Erreur a l'écrtiure du lien : ",nomlien);
MAJ_version_num(fid,2,3,6);
lien[nval] = '\0';
/* printf("\t\t|%s|\n\n",lien); */
free(lien);
}
/* combien de champs dans le fichier */
ncha = MEDnField(fid);
EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
/* MAJ des champs */
for (i =0;i<ncha;i++) {
lret = 0;
/* Lecture du nombre de composantes */
ncomp = MEDfieldnComponent(fid,i+1);
if (ncomp < 0) {
MESSAGE("Erreur à la lecture du nombre de composantes : "); ISCRUTE(ncomp);
exit(1);
}
/* Lecture du type du champ, des noms des composantes et du nom de l'unité*/
comp = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
EXIT_IF(comp == NULL,NULL,NULL);
unit = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
EXIT_IF(unit == NULL,NULL,NULL);
/* ret = MED231champInfoEtRen(fid,i+1,nomcha,&typcha,comp,unit,ncomp); */
ret = MEDfieldInfo(fid,i+1,nomcha,_meshname,&_local,&typcha,comp,unit,_dtunit,&_ncstp);
MED_ERR_EXIT_IF(ret,MED_ERR_ACCESS,MED_ERR_FIELD,nomcha);
/* creation du champ destination */
MAJ_version_num(fid,3,0,8);
EXIT_IF( H5Gmove(fid, _pathi, _pathtmp ) < 0,"Switch to ",_pathtmp);
_datasetexist=H5Lexists( fid, _pathf, H5P_DEFAULT );
if (_datasetexist ) { EXIT_IF( (H5Gmove(fid, _pathf, _pathi ) < 0) ,"Switch to ",_pathi); }
MED_ERR_EXIT_IF( MEDfieldCr(fid,nomcha,typcha,ncomp,comp,unit,_dtunit,_meshname ) < 0,
MED_ERR_CREATE,MED_ERR_FIELD,_pathf);
EXIT_IF( H5Gmove(fid, _pathi , _pathf ) < 0,"Switch to ",_pathf);
EXIT_IF( H5Gmove(fid, _pathtmp, _pathi ) < 0,"Switch to ",_pathi);
MAJ_version_num(fid,2,3,6);
free(comp);
free(unit);
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_NODE,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux noeuds "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_CELL,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux mailles "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_DESCENDING_FACE,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux faces "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_DESCENDING_EDGE,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux aretes "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_NODE_ELEMENT,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux aretes "); exit(1);
}
}
_datasetexist=H5Lexists( fid, _pathf, H5P_DEFAULT );
if (_datasetexist ) {
EXIT_IF( (H5Ldelete(fid,_pathi, H5P_DEFAULT) < 0) ,"Delete ",_pathi);
EXIT_IF( (H5Gmove(fid, _pathf, _pathi ) < 0) ,"Switch to ",_pathf);
}
}
med_err
_MEDmeshCr(const med_idt fid, const char * const root,
const char * const meshname, const med_int spacedim,
const med_int meshdim, const med_mesh_type meshtype,
const char * const description, const char * const dtunit,
const med_sorting_type sortingtype,
const med_axis_type axistype, const char * const axisname,
const char * const axisunit)
{
med_access_mode _MED_ACCESS_MODE;
med_err _ret=-1;
med_idt _root=0,_datagroup1=0;
/* _datagroup2=0,_datagroup3=0; */
med_int _intmeshtype = (med_int) meshtype;
med_int _intaxistype = (med_int) axistype;
char _datagroupname1[MED_NAME_SIZE+1]="";
/* char _geotypename[MED_NAME_SIZE_ENTITE+1]=""; */
med_int _lastnumdt=MED_NO_DT, _lastnumit=MED_NO_IT;
med_int _intsortingtype =(med_int) MED_SORT_UNDEF;
med_int _intexistingmeshtype=(med_int) MED_UNDEF_MESH_TYPE;
med_mesh_type _existingmeshtype = meshtype;
med_sorting_type _existingsortingtype = sortingtype;
med_size _nstep=0;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
if ( sortingtype == MED_SORT_UNDEF) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_PARAMETER,"sortingtype");
ISCRUTE_int(sortingtype);
goto ERROR;
}
/*
* Si le DataGroup root n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,root)) < 0)
if ((_root = _MEDdatagroupCreer(fid,root)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,root);
goto ERROR;
}
NOFINALBLANK(meshname,ERROR);
/*
* Si le Data Group "/MAA.../<meshname>" n'existe pas, on le cree
*/
if ((_datagroup1 = _MEDdatagroupOuvrir(_root,meshname)) < 0)
if ((_datagroup1 = _MEDdatagroupCreer(_root,meshname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,meshname);
goto ERROR;
}
/*
* Creation de l'attribut dimension du maillage
*/
if (meshdim > spacedim) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_PARAMETER,"meshdim");
ISCRUTE(meshdim);ISCRUTE(spacedim);
SSCRUTE(root);SSCRUTE(meshname);goto ERROR;
}
/*
* Creation de l'attribut dimension de l'espace
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_ESP,&spacedim) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_ESP);
ISCRUTE(spacedim);goto ERROR;
}
/*
* Creation de l'attribut dimension du maillage
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_DIM,&meshdim) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_DIM);
ISCRUTE(meshdim);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_TYP */
if (_MEDattrEntierLire(_datagroup1,MED_NOM_TYP,&_intexistingmeshtype) >= 0)
_existingmeshtype = (med_mesh_type) (_intexistingmeshtype);
if ( _existingmeshtype != meshtype ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_WRITE,MED_ERR_ATTRIBUTE_MSG);
SSCRUTE(MED_NOM_TYP);SSCRUTE(meshname);SSCRUTE(_datagroupname1);
ISCRUTE_int(_existingmeshtype);ISCRUTE_int(meshtype);goto ERROR;
}
/*
* Creation de l'attribut correspondant au type du maillage (MED_STRUCTURE, MED_NON_STRUCTURE)
* L'attribut "TYP"
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_TYP);
ISCRUTE(_intmeshtype);goto ERROR;
}
/*
* La description associee au maillage
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_DES,MED_COMMENT_SIZE,description) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_DES);
SSCRUTE(description);goto ERROR;
}
/*
* Creation de l'attribut nom de l'unit~ des dates
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/*
* Test de l'existence de l'attribut de tri des s~quences de calcul
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_SRT,&_intsortingtype) >= 0) {
_existingsortingtype = (med_sorting_type) (_intsortingtype);
/* Nombre d'~tapes de calcul existantes */
_MEDnObjects(_datagroup1,".",&_nstep);
}
if ( (_existingsortingtype != sortingtype) && _nstep ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,MED_ERR_ATTRIBUTE_MSG);
SSCRUTE(MED_NOM_SRT);SSCRUTE(meshname);SSCRUTE(_datagroupname1);
ISCRUTE_int(_existingsortingtype);ISCRUTE_int(sortingtype);goto ERROR;
}
/*
* Creation de l'attribut de tri des s~quences de calcul
*/
_intsortingtype = sortingtype;
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_SRT);
ISCRUTE_int(sortingtype);goto ERROR;
}
/*
* Creation de l'attribut de la derni~re it~ration cr~e
*/
/* if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NXI,&_lastnumit) < 0) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG); */
/* SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NXI); */
/* ISCRUTE(_lastnumit);goto ERROR; */
/* } */
/*
* L'attribut "REP"
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_REP,&_intaxistype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_REP);
ISCRUTE(_intaxistype);goto ERROR;
}
/*
* Attribut "NOM"
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_NOM,spacedim*MED_SNAME_SIZE,axisname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NOM);
SSCRUTE(axisname);goto ERROR;
}
/*
* Attribut "UNI"
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNI,spacedim*MED_SNAME_SIZE,axisunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNI);
SSCRUTE(axisunit);goto ERROR;
}
/*
* Cr~ation du datagroup des mailles associ~es ~ un maillage structur~
* Cel~ permet d'utiliser les routines famille, num~ros/noms optionnels
* de la m~me fa~on que pour les maillages non structur~s
*/
/* if ( meshtype == MED_STRUCTURE ) { */
/* if ((_datagroup2 = _MEDdatagroupCreer(_datagroup1,MED_NOM_MAI)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,root); */
/* SSCRUTE(meshname);SSCRUTE(MED_NOM_MAI);goto ERROR; */
/* } */
/* switch ( meshdim ) { */
/* case 1 : strcpy(_geotypename,MED_NOM_SE2); */
/* break; */
/* case 2 : strcpy(_geotypename,MED_NOM_QU4); */
/* break; */
/* case 3 : strcpy(_geotypename,MED_NOM_HE8); */
/* break; */
/* case 0 : strcpy(_geotypename,MED_NOM_PO1); */
/* break; */
/* default : */
/* MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_PARAMETER,""); */
/* ISCRUTE(meshdim);SSCRUTE(root);SSCRUTE(meshname);goto ERROR; */
/* } */
/* if ((_datagroup3 = _MEDdatagroupCreer(_datagroup2,_geotypename)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_geotypename); */
/* SSCRUTE(root);SSCRUTE(meshname);SSCRUTE(MED_NOM_MAI);ISCRUTE_int(_geotypename); */
/* goto ERROR; */
/* } */
/* } */
/*
* Nettoyages divers
*/
_ret = 0;
ERROR:
/* if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_geotypename); */
/* ISCRUTE_id(_datagroup3); */
/* } */
/* if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_NOM_MAI); */
/* ISCRUTE_id(_datagroup2); */
/* } */
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_datagroup1);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,root);
ISCRUTE_id(_root);
}
return _ret;
}
