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
MEDparameterComputationStepInfo(const med_idt fid,
const char * const paramname,
const int csit,
med_int * const numdt,
med_int * const numit,
med_float * const dt )
{
med_err _ret = -1, _err = -1;
med_idt _cpstidt = 0;
char _path[(MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1)+2*MED_MAX_PARA+1]=MED_NUM_DATA;
int _num=csit-1;
char _cstpname[2*MED_MAX_PARA+1]="";
_MEDmodeErreurVerrouiller();
/* On recupere le nom du pas de temps */
strcat(_path, paramname);
if ( _MEDobjectGetName(fid, _path ,_num, _cstpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
/* on ouvre le groupe HDF correspondant */
strcat(_path,"/");
strcat(_path,_cstpname);
if ((_cpstidt = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/* Lecture des attributs */
if (_MEDattrEntierLire(_cpstidt, MED_NOM_NDT, (med_int*) numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
SSCRUTE(_path);ISCRUTE(*numdt);goto ERROR;
}
if (_MEDattrFloatLire(_cpstidt, MED_NOM_PDT, (med_float*) dt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_PDT);
SSCRUTE(_path);RSCRUTE(*dt);goto ERROR;
}
if (_MEDattrEntierLire(_cpstidt, MED_NOM_NOR, (med_int*) numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
SSCRUTE(_path);ISCRUTE(*numit);goto ERROR;
}
_ret = 0;
ERROR:
/* on ferme tout */
if (_cpstidt > 0)
if (_MEDdatagroupFermer(_cpstidt) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_cpstidt);
}
return _ret;
}
med_err _MEDattributeStringRdByName(med_idt pid,
const char * const path,
const char * const attname,
const med_size attsize,
char * const val)
{
med_err _ret=-1;
med_idt _attid=0;
int type_hdf=0;
if ( (type_hdf = H5Tcopy(H5T_C_S1)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_HDFTYPE, MED_ERR_NAME_MSG );
SSCRUTE("H5T_C_S1"); goto ERROR;
}
if ( H5Tset_size(type_hdf,attsize+1) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_HDFTYPE, MED_ERR_NAME_MSG );
SSCRUTE("H5T_C_S1"); goto ERROR;
}
if ( (_attid=H5Aopen_by_name( pid, path, attname, H5P_DEFAULT, H5P_DEFAULT )) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(attname); SSCRUTE(path);goto ERROR;
}
if ( H5Aread(_attid,type_hdf,val) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(attname); SSCRUTE(path);goto ERROR;
}
_ret=0;
ERROR:
if (type_hdf >0) if ( H5Tclose(type_hdf) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_HDFTYPE, MED_ERR_ID_MSG );
ISCRUTE_int(type_hdf);
}
if (_attid >0) if ( H5Aclose(_attid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_ATTRIBUTE, MED_ERR_ID_MSG );
ISCRUTE_id(_attid);
}
return _ret;
}
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
_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
MEDfamCr231(int dummy,...)
{
med_idt fid;
char *maa;
char *famille;
med_int numero;
med_int *attr_ident;
med_int *attr_val;
char *attr_desc;
med_int n_attr;
char *groupe;
med_int n_groupe;
med_err *fret ;
med_idt root=0, datagroup=0, famid=0;
med_err ret=-1;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_FAS_ENTITE+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_FAS+1];
char stockage[MED_TAILLE_FAS_ENTITE+1] = "NONE";
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params, med_idt );
maa = va_arg(params, char* );
famille = va_arg(params, char* );
numero = va_arg(params, med_int );
attr_ident = va_arg(params, med_int*);
attr_val = va_arg(params, med_int*);
attr_desc = va_arg(params, char* );
n_attr = va_arg(params, med_int );
groupe = va_arg(params, char* );
n_groupe = va_arg(params, med_int );
fret = va_arg(params, med_err*);
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE) {
MESSAGE("Impossible de créer une famille en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group FAS n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
/* BUG NON CORRIGE en 2.3.1 à cause
des noms de familles crées en F77
NOFINALBLANK(maa,ERROR);*/
strcat(chemin,maa);
strncpy(tmp,MED_FAS,MED_TAILLE_FAS-1);
tmp[MED_TAILLE_FAS-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Le lieu de stockage varie selon le signe du "numero"
* de famille
* = 0 => FAMILLE NEUTRE
* > 0 => FAMILLE DE NOEUD
* < 0 => FAMILLE DE MAILLE/FACE/ARETE
*/
if (numero != 0) {
if ((ret = _MEDdatagroupFermer(root)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret = -1;
goto ERROR;
}
if (numero > 0)
strncpy(stockage,MED_FAS_NOEUD,MED_TAILLE_FAS_ENTITE-1);
if (numero < 0)
strncpy(stockage,MED_FAS_ELEME,MED_TAILLE_FAS_ENTITE-1);
stockage[MED_TAILLE_FAS_ENTITE-1] = '\0';
strcat(chemin,stockage);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
}
/*
* Si le Data Group de meme nom que famille existe => erreur
* Sinon on le cree
*/
/*
* POUR LA FAMILLE DE NUMERO 0, ON FORCE LE NOM
*/
if (numero == 0)
strcpy(famille,FAMILLE_ZERO);
/*
* Création de la famille
*/
if ((famid = _MEDdatagroupCreer(root,famille)) < 0) {
MESSAGE("Erreur à la création du famille : ");
SSCRUTE(famille);
goto ERROR;
}
/*
* L'attribut NUM
*/
if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero)) < 0) {
MESSAGE("Erreur à l'écriture du numéro de famille : ");
ISCRUTE(numero);
goto ERROR;
}
/*
* Le Data Group "GRO"
*/
if (n_groupe > 0) {
/*
* On cree le Data Group
*/
if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(MED_NOM_GRO);
goto ERROR;
}
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe)) < 0) {
MESSAGE("Erreur à l'écriture du nombre de groupe : ");
ISCRUTE(n_groupe);
goto ERROR;
}
/*
* Data Set des noms des groupes "NOM"
*/
dimd[0] = n_groupe*MED_TAILLE_LNOM+1;
if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe))<0) {
MESSAGE("Erreur à l'écriture des noms des groupes : ");
SSCRUTE(groupe);
goto ERROR;
}
/*
* On ferme le Data Group
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup);
goto ERROR;
}
}
/*
* Le Data Group "ATT"
*/
if (n_attr > 0) {
if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(MED_NOM_ATT);
goto ERROR;
}
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr)) < 0) {
MESSAGE("Erreur à l'écriture du nombre d'attributs : ");
ISCRUTE(n_attr);
goto ERROR;
}
/*
* Le Data Set "IDE"
*/
dimd[0] = n_attr;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char *)attr_ident)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_IDE);
goto ERROR;
}
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char *)attr_ident)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_IDE);
goto ERROR;
}
#endif
/*
* Le Data Set "VAL"
*/
dimd[0] = n_attr;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*)attr_val)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_VAL);
goto ERROR;
}
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*)attr_val)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_VAL);
goto ERROR;
}
#endif
/*
* Le Data Set "DES"
*/
dimd[0] = n_attr*MED_TAILLE_DESC+1;
if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_DES);
goto ERROR;
}
/*
* On ferme le Data Group
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup);
goto ERROR;
}
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (famid>0) if (_MEDdatagroupFermer(famid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(famid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
med_err
MEDdimEspaceCr(med_idt fid, char *maillage, med_int dim)
{
med_idt maaid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_int maadim;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un maillage en mode MED_LECTURE.");
goto ERROR;
};
/*
* On regarde si le groupe existe => erreur si non
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Erreur à l'ouverture du maillage : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* On va lire l'attribut dimension du maillage et on controle
* la coherence
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&maadim)) < 0) {
MESSAGE("Erreur à la lecture de la dimension du maillage : ");
ISCRUTE(maadim);
goto ERROR;
}
if (maadim > dim) {
MESSAGE("La dimension de l'espace : ");
ISCRUTE(dim);
MESSAGE("doit être supérieur à la dimension du maillage : ");
ISCRUTE(maadim);
goto ERROR;
}
/*
* On ecrit la dimension de l'espace
*/
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_ESP,&dim)) < 0) {
MESSAGE("Erreur à l'écriture de la dimension de l'espace : ");
ISCRUTE(dim);
goto ERROR;
}
/*
* Fermetures des objets HDF
*/
ret = 0;
ERROR:
if (maaid>0) if (_MEDdatagroupFermer(maaid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(maaid);ret = -1;
}
return ret;
}
void
_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;
}
med_err
MEDprofileWr(const med_idt fid,
const char* const profilename,
const med_int profilesize,
const med_int* const profilearray)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_pfid=0;
med_err _ret=-1;
char _path[MED_TAILLE_PROFILS+MED_NAME_SIZE+1]=MED_PROFILS;
med_filter _filter = MED_FILTER_INIT;
/*
* 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 /PROFILS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(profilename,ERROR);
/*
* Si le DataGroup /PROFILS/<profilename> n'existe pas, on le cree
*/
if ((_pfid = _MEDdatagroupOuvrir(_root,profilename)) < 0)
if ((_pfid = _MEDdatagroupCreer(_root,profilename)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,profilename);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,profilename);
/*
* On stocke "profilesize" sous forme d'attribut
*/
if (_MEDattributeIntWr(_pfid,MED_NOM_NBR,&profilesize) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_PROFILE_MSG);
SSCRUTE(profilename);SSCRUTE(MED_NOM_NBR);ISCRUTE(profilesize);
goto ERROR;
}
/*
* On stocke le profil dans un dataset
*/
if ( MEDfilterEntityCr(fid, profilesize, 1, 1, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_PFLMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
if ( _MEDdatasetWr(_pfid,MED_NOM_PFL,MED_INTERNAL_INT,&_filter, profilearray) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_PFL);SSCRUTE(_path);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_PROFILE_MSG); SSCRUTE(_path);
goto ERROR;
}
_ret = 0;
ERROR:
if (_pfid>0) if (_MEDdatagroupFermer(_pfid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,profilename);
ISCRUTE_id(_pfid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_PROFILS);
ISCRUTE_id(_root);
}
return _ret;
}
void
_MEDfieldCr31(int dummy, ...) {
med_err _ret=-1;
med_idt _root=0,_datagroup1=0;
med_int _fieldtype ;
char _datagroupname1[MED_NAME_SIZE+1]="";
med_access_mode _MED_ACCESS_MODE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_field_type , , fieldtype );
MED_VARGS_DECL(const, med_int , , ncomponent );
MED_VARGS_DECL(const, char *, const , componentname );
MED_VARGS_DECL(const, char *, const , componentunit );
MED_VARGS_DECL(const, char *, const , dtunit );
MED_VARGS_DECL(const, char *, const , meshname );
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, med_field_type, , fieldtype );
MED_VARGS_DEF(const, med_int , , ncomponent );
MED_VARGS_DEF(const, char *, const , componentname );
MED_VARGS_DEF(const, char *, const , componentunit );
MED_VARGS_DEF(const, char *, const , dtunit );
MED_VARGS_DEF(const, char *, const , meshname );
MED_VARGS_DEF(, med_err * , , fret );
_MEDmodeErreurVerrouiller();
_fieldtype = (med_int) fieldtype;
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 MED_FIELD_GRP n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,MED_FIELD_GRP)) < 0)
if ((_root = _MEDdatagroupCreer(fid,MED_FIELD_GRP)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
goto ERROR;
}
NOFINALBLANK(fieldname,ERROR);
/*
* Si le Data Group "/CHA/<fieldname>" n'existe pas, on le cree
*/
if ((_datagroup1 = _MEDdatagroupOuvrir(_root,fieldname)) < 0)
if ((_datagroup1 = _MEDdatagroupCrOrderCr(_root,fieldname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
SSCRUTE(fieldname);goto ERROR;
}
/*
* Les infos sur les composantes du champ
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NCO,&ncomponent) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NCO);
ISCRUTE(ncomponent);goto ERROR;
}
/* Tous les types med_field_type sont autorisés dans MEDfieldCr mais :
Avant la 3.3.0 seuls les types : MED_FLOAT64,MED_INT32 et MED_INT64 étaient autorisés dans MEDfieldValueAdvancedWr
et seul le type med_int et med_float64 pouvaient être utilisés en C.
A l'écriture, si med_int=int les champs MED_INT32 étaient stockés en interne en HDFINT32bits
A l'écriture, si med_int=long les champs MED_INT32 étaient stockés en interne en HDFINT64bits
A la lecture : - si med_int=int le champ MED_INT32 est relu en en HDFINT32bit avec conversion 64->32 si necessaire
- si med_int=long le champ MED_INT32 est relu en en HDFINT64bit avec conversion 32->64 si necessaire
A l'écriture, si med_int=int les champs MED_INT64 étaient interdits
A l'écriture, si med_int=long les champs MED_INT64 étaient stockés en interne en HDFINT64bits
A la lecture : - si med_int=int le champ MED_INT64 ne pouvait pas être relu (pour prevenir la perte d'information)
- si med_int=long le champ MED_INT64 est relu sans conversion
Depuis la 3.3.0 en plus des types MED_FLOAT64,MED_INT32 et MED_INT64 les types MED_FLOAT32 et MED_INT sont autorisés dans MEDfieldValueAdvancedWr et aux types med_int et med_float64 utilisés en C sont ajoutés les types med_float32, med_int32 et med_int64.
MED_INT32 :
A l'écriture : si med_int=int les champs MED_INT32 sont toujours stockés en interne en HDFINT32bits (utiliser med_int32 ou med_int(!))
si med_int=long les champs MED_INT32 sont désormais stockés en interne en HDFINT32bits (utiliser le type med_int64) et désormais
A la lecture : si med_int=int les champs MED_INT32 sont toujours relus en HDFINT32bits sans conversion (utiliser med_int32 ou med_int(!))
si med_int=long les champs MED_INT32 sont désormais relus en HDFINT32bits sans conversion (utiliser le type med_int32)
MED_INT64 :
A l'écriture : si med_int=int les champs MED_INT64 sont désormais autorisés et stockés en interne en HDFINT64bits (utiliser le type med_int64)
si med_int=long les champs MED_INT64 sont toujours autorisés et stockés en interne en HDFINT64bits (utiliser le type med_int64 ou med_int(!))
A la lecture : si med_int=int les champs MED_INT64 sont désormais relus en HDFINT64bits sans conversion (utiliser le type med_int64)
si med_int=long les champs MED_INT64 sont toujours relus en HDFINT64bits sans conversion (utiliser le type med_int64 ou med_int(!))
MED_INT :
A l'écriture : si med_int=int les champs MED_INT sont désormais acceptés et stockés en interne en HDFINT32bits (utiliser med_int ou med_int32(!))
si med_int=long les champs MED_INT sont désormais acceptés et stockés en interne en HDFINT64bits (utiliser med_int ou med_int64(!))
A la lecture : si med_int=int les champs MED_INT sont désormais acceptés et relus en HDFINT32bits avec conversion/maxint si necessaire (utiliser med_int ou med_int32(!))
si med_int=long les champs MED_INT sont désormais acceptés et relus en HDFINT64bits avec conversion si necessaire (utiliser le type med_int32)
Plateforme 32 bits : TODO si la plateforme est 32 bits, il faut .... ?
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_TYP,&_fieldtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_TYP);
ISCRUTE(_fieldtype);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_NOM,
MED_SNAME_SIZE*ncomponent,componentname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NOM);
SSCRUTE(componentname);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNI,
MED_SNAME_SIZE*ncomponent,componentunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);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 ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/*MODEL : MED_NOM_MAI est écrit dans l'API de création de champ
* Si c'est la première référence à un maillage, initialise l'attribut MED_MAI à ce maillage
*/
NOFINALBLANK(meshname,ERROR);
if (_MEDattributeStringWr(_datagroup1,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_MAI);
SSCRUTE(meshname);
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,meshname);
goto ERROR;
}
/*
* On ferme tout
*/
_ret=0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
ISCRUTE_id(_root);
}
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
_MEDequivalenceCorrespondenceRd30(int dummy, ...) {
med_idt _root=0,_eqid=0,_meshid=0,_cstpid=0,_datagroup2=0;
med_idt _dataset=0;
med_err _ret=-1;
char _path[MED_TAILLE_EQS+2*MED_NAME_SIZE+2]=MED_EQS;
char _computationstepname[2*MED_MAX_PARA+1]="";
char _datagroupname2[2*MED_TAILLE_NOM_ENTITE+2]="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype=0;
med_filter _filter = MED_FILTER_INIT;
med_geometry_type _geotype=MED_NONE;
med_int _nentity=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, 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(, med_int *, const , correspondence );
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, 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(, med_int *, const , correspondence );
MED_VARGS_DEF(, med_err * ,, fret );
if ( entitype == MED_NODE_ELEMENT ) _geotype=MED_NODE ;
if ( (geotype / 100 ) > 2 ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);ISCRUTE_int(geotype);
goto ERROR;
}
if ( entitype != MED_NODE ) _geotype=geotype ;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
/*
* Ouverture du dataGroup /EQS/
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Ouverture du dataGroup <meshname>
*/
if ((_meshid = _MEDdatagroupOuvrir(_root,meshname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,meshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,meshname);
/*
* Si le Data Group "/EQS/<meshname>/<equivname>" n'existe pas, on le cree
*/
if ((_eqid = _MEDdatagroupOuvrir(_meshid,equivname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,equivname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,"/");
strcat(_path,equivname);
if ( MEDmeshSortingTypeRd(fid,meshname,&_sortingtype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API," MEDmeshSortingTypeRd");
SSCRUTE(meshname);ISCRUTE_int(_sortingtype);goto ERROR;
}
_MEDgetComputationStepName(_sortingtype,numdt,numit,_computationstepname);
if ((_cstpid = _MEDdatagroupOuvrir(_eqid,_computationstepname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_computationstepname);
SSCRUTE(_path);goto ERROR;
}
/*
* Ouverture du datagroup de niveau <entitype>[.<geotype>]
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitype);SSCRUTE(equivname);goto ERROR;
}
if ( entitype != MED_NODE ) {
if ( _MEDgetInternalGeometryTypeName(_geotypename,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(equivname);goto ERROR;
}
strcat(_datagroupname2,".");
strcat(_datagroupname2,_geotypename);
}
if ( (_datagroup2 = _MEDdatagroupOuvrir(_cstpid,_datagroupname2)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_datagroupname2);
SSCRUTE(_path);SSCRUTE(equivname);goto ERROR;
}
if ((_dataset = _MEDdatasetOuvrir(_datagroup2,MED_NOM_COR)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);SSCRUTE(_datagroupname2);
goto ERROR;
}
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_nentity) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);SSCRUTE(_datagroupname2);
SSCRUTE(MED_NOM_NBR);ISCRUTE(_nentity);goto ERROR;
}
if ( MEDfilterEntityCr(fid, _nentity, 1, 2, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_PFLMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
if ( _MEDdatasetRd(_datagroup2,MED_NOM_COR,MED_INTERNAL_INT,&_filter, (unsigned char *) correspondence) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
_ret=0;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COR);
ISCRUTE_id(_dataset);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
}
if (_cstpid>0) if (_MEDdatagroupFermer(_cstpid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_computationstepname);
ISCRUTE_id(_cstpid);SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
}
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,equivname);
ISCRUTE_id(_eqid);SSCRUTE(_path);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_eqid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_EQS);
ISCRUTE_id(_eqid);
}
va_end(params);
*fret = _ret;
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;
}
med_err
MEDlinkWr(const med_idt fid,
const char * const meshname,
const char * const link)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _lid=0, _root=0;
med_err _ret=-1;
char _path[MED_TAILLE_LIENS+MED_NAME_SIZE+1]=MED_LIENS;
med_int _n=0;
med_filter _filter = MED_FILTER_INIT;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_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 /LIENS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(link,ERROR);
/*
* Si le DataGroup /LIENS/<meshname> n'existe pas, on le cree
*/
if ((_lid = _MEDdatagroupOuvrir(_root,meshname)) < 0)
if ((_lid = _MEDdatagroupCreer(_root,meshname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,meshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,meshname);
/*
* On stocke <n> sous forme d'attribut
*/
_n = strlen(link);
if (_MEDattributeIntWr(_lid,MED_NOM_NBR,&_n) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_LINK_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(_n);
goto ERROR;
}
/*
* On stocke le link dans un dataset
*/
if ( MEDfilterEntityCr(fid,_n, 1, 1, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_STMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
/* SSCRUTE(link); */
if ( _MEDdatasetWr(_lid,MED_NOM_LIE,MED_INTERNAL_CHAR,&_filter, link) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_LIE);SSCRUTE(_path);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_LINK_MSG); SSCRUTE(_path);
goto ERROR;
}
_ret = 0;
ERROR:
if (_lid>0) if (_MEDdatagroupFermer(_lid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_lid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_LIENS);
ISCRUTE_id(_root);
}
return _ret;
}
void _MEDsubdomainCorrespondenceSizeInfo30(int dummy, ...) {
med_err _ret=-1;
med_idt _datagroup1=0,_dataset=0;
int _num;
char _path[MED_TAILLE_JNT+2*MED_NAME_SIZE+2+2*MED_MAX_PARA+1+4*MED_TAILLE_NOM_ENTITE+4]=MED_JNT;
char _datagroupname1[2*MED_TAILLE_NOM_ENTITE+2]="";
char _cstpname[2*MED_MAX_PARA+1]="";
med_sorting_type _sortingtype=0;
med_int _intlocalentitype;
med_int _intlocalgeotype;
med_int _intremoteentitype;
med_int _intremotegeotype;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, char * , const , jointname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, int , , corit );
MED_VARGS_DECL(, med_entity_type *, const , localentitype );
MED_VARGS_DECL(, med_geometry_type *, const , localgeotype );
MED_VARGS_DECL(, med_entity_type *, const , remoteentitype );
MED_VARGS_DECL(, med_geometry_type *, const , remotegeotype );
MED_VARGS_DECL(, med_int *, const , nentitycor );
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 , jointname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, int , , corit );
MED_VARGS_DEF(, med_entity_type *, const , localentitype );
MED_VARGS_DEF(, med_geometry_type *, const , localgeotype );
MED_VARGS_DEF(, med_entity_type *, const , remoteentitype );
MED_VARGS_DEF(, med_geometry_type *, const , remotegeotype );
MED_VARGS_DEF(, med_int *, const , nentitycor );
MED_VARGS_DEF(, med_err * ,, fret );
_num = corit -1;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if ( MEDmeshSortingTypeRd(fid,meshname,&_sortingtype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API," MEDmeshSortingTypeRd");
SSCRUTE(meshname);ISCRUTE_int(_sortingtype);goto ERROR;
}
strcat( _path, meshname);
strcat( _path, "/");
strcat( _path, jointname);
strcat( _path, "/");
_MEDgetComputationStepName(_sortingtype,numdt,numit,&_path[strlen(_path)]);
strcat( _path, "/");
/*
* On recupere le nom de <localentitype>[.<localgeotype>].<remoteentitype>[.<remotegeotype>]
*/
if ( _MEDobjectGetName(fid, _path ,_num, &_path[strlen(_path)]) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(corit);
goto ERROR;
}
if ( (_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*lecture localentitype et localgeotype */
if (_MEDattrEntierLire(_datagroup1,MED_NOM_ENT,&_intlocalentitype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_ENT);
ISCRUTE(_intlocalentitype);goto ERROR;
}
*localentitype = (med_entity_type) _intlocalentitype;
if (_MEDattrEntierLire(_datagroup1,MED_NOM_GEO,&_intlocalgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
ISCRUTE(_intlocalgeotype);goto ERROR;
}
*localgeotype = (med_geometry_type) _intlocalgeotype;
/*lecture remoteentitype et remotegeotype */
if (_MEDattrEntierLire(_datagroup1,MED_NOM_END,&_intremoteentitype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_ENT);
ISCRUTE(_intremoteentitype);goto ERROR;
}
*remoteentitype = (med_entity_type) _intremoteentitype;
if (_MEDattrEntierLire(_datagroup1,MED_NOM_GED,&_intremotegeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
ISCRUTE(_intremotegeotype);goto ERROR;
}
*remotegeotype = (med_geometry_type) _intremotegeotype;
if ((_dataset = _MEDdatasetOuvrir(_datagroup1,MED_NOM_COR)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);
goto ERROR;
}
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,nentitycor) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nentitycor);
goto ERROR;
}
_ret = 0;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COR);
ISCRUTE_id(_dataset);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_datagroup1);
}
va_end(params);
*fret = _ret;
return;
}
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;
}
med_err _MEDsetFilter(const med_int nspaces,
const med_idt* const memspace,
const med_idt* const diskspace,
const med_int nentity,
const med_int nvaluesperentity,
const med_int nconstituentpervalue,
const med_int constituentselect,
const med_switch_mode switchmode,
const med_int filterarraysize,
const med_int profilearraysize,
const med_storage_mode storagemode,
const char* const profilename,
med_filter* const filter) {
med_err _ret=-1;
int _i=0;
if ( (*filter).nspaces > 0 ) {
MED_ERR_(_ret,MED_ERR_NOTNULL,MED_ERR_FILTER,"");
ISCRUTE((*filter).nspaces);
goto ERROR;
}
if ( (*filter).memspace[0] > 0 ) {
MED_ERR_(_ret,MED_ERR_NOTNULL,MED_ERR_FILTER,"");
ISCRUTE_id((*filter).memspace[0]);
goto ERROR;
}
if ( (*filter).diskspace[0] > 0 ) {
MED_ERR_(_ret,MED_ERR_NOTNULL,MED_ERR_FILTER,"");
ISCRUTE_id((*filter).diskspace[0]);
goto ERROR;
}
if ( nspaces > MED_MAX_FILTER_SPACES ) {
MESSAGE("Impossible de créer un filtre avec un nombre de memspace supérieur à : ");
ISCRUTE_int(MED_MAX_FILTER_SPACES);
goto ERROR;
}
/*Le champ filterarray23v30 est uniquement utilisé dans _MEDfilterEntityCr236
pour les besoins de _MEDmeshAdvancedRd236, il n'est donc pas intégré
à la signature de MEDsetFilter.*/
if ( (*filter).filterarray23v30 != NULL ) {
MESSAGE("Impossible de créer un filtre avec un tableau filterarray23v30 non desalloué : ");
XSCRUTE((void*) (*filter).filterarray23v30);
goto ERROR;
}
(*filter).nspaces = nspaces;
for (_i=0; _i < nspaces; ++_i) {
(*filter).memspace[_i] = memspace[_i];
(*filter).diskspace[_i] = diskspace[_i];
}
(*filter).nentity = nentity;
(*filter).nvaluesperentity = nvaluesperentity;
(*filter).nconstituentpervalue = nconstituentpervalue;
(*filter).constituentselect = constituentselect;
(*filter).switchmode = switchmode;
(*filter).filterarraysize = filterarraysize;
/*Le champ filterarray23v30 est uniquement utilisé dans _MEDfilterEntityCr236
pour les besoins de _MEDmeshAdvancedRd236, il n'est donc pas intégré
à la signature de MEDsetFilter.*/
(*filter).filterarray23v30 = NULL;
(*filter).profilearraysize = profilearraysize;
(*filter).storagemode = storagemode;
strcpy((*filter).profilename,profilename);
/* ISCRUTE((*filter).nspaces ); */
/* ISCRUTE((*filter).nentity ); */
/* ISCRUTE((*filter).nvaluesperentity ); */
/* ISCRUTE((*filter).nconstituentpervalue ); */
/* ISCRUTE((*filter).constituentselect ); */
/* ISCRUTE((*filter).switchmode ); */
/* ISCRUTE((*filter).filterarraysize ); */
/* ISCRUTE((*filter).profilearraysize ); */
/* ISCRUTE((*filter).storagemode ); */
/* SSCRUTE((*filter).profilename ); */
_ret = 0;
ERROR:
return _ret;
}
/**\ingroup MEDinterp
\brief \MEDinterpCrBrief
\param fid \fid
\param interpname \interpname
\param geotype \geotype
\param cellnode \cellnode
\param nvariable \nvariable
\param maxdegree \maxdegree
\param nmaxcoef \nmaxcoef
\return \error
\details \MEDinterpCrDetails
\see MEDinterpBaseFunctionWr
\remarks
\li \MEDinterpCrcellnodeCm1
\li \MEDinterpCrcellnodeCm2
*/
med_err
MEDinterpCr(const med_idt fid,
const char* const interpname,
const med_geometry_type geotype,
const med_bool cellnode,
const med_int nvariable,
const med_int maxdegree,
const med_int nmaxcoef
)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_interpid=0;
med_int _ret=-1;
char _path[MED_INTERPOLATION_GRP_SIZE+MED_NAME_SIZE+1]=MED_INTERPOLATION_GRP;
med_int _cellnodes = cellnode;
med_int _geotype = geotype;
/*
* 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 /INTERP/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOpen(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(interpname,ERROR);
/*
* Si le DataGroup /INTERP/<interpname> n'existe pas, on le cree
*/
if ((_interpid = _MEDdatagroupOpen(_root,interpname)) < 0)
if ((_interpid = _MEDdatagroupCreer(_root,interpname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,interpname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,interpname);
/*
* Creation/Ecriture de l'attribut MED_NOM_GEO
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_GEO,&_geotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_GEO);ISCRUTE(_geotype);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_NBB
*/
/* if ( _MEDattributeIntWr(_interpid,MED_NOM_NBB,&nbasisfunc) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path); */
/* SSCRUTE(MED_NOM_NBB);ISCRUTE(nbasisfunc); */
/* goto ERROR; */
/* } */
/*
* Creation/Ecriture de l'attribut MED_NOM_NBV
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_NBV,&nvariable) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NBV);ISCRUTE(nvariable);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_MDG
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_MDG,&maxdegree) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_MDG);ISCRUTE(maxdegree);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_MCF
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_MCF,&nmaxcoef) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_MCF);ISCRUTE(nmaxcoef);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_FCN
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_FCN,&_cellnodes) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_FCN);ISCRUTE(_cellnodes);
goto ERROR;
}
_ret = 0;
ERROR:
if (_interpid>0) if (_MEDdatagroupFermer(_interpid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_interpid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_INTERPOLATION_GRP);
ISCRUTE_id(_root);
}
return _ret;
}
med_err
MEDscalaireCr(med_idt fid,char *scalaire, med_type_champ type, char *desc)
{
med_err ret=-1;
med_idt root=0,gid=0;
char chemin[MED_TAILLE_NUM_DATA+1];
med_int _type = (med_int) type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer une variable scalaire en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Groupe HDF "/NUM_DATA" n'existe pas, on le cree
*/
strncpy(chemin,MED_NUM_DATA,MED_TAILLE_NUM_DATA-1);
chemin[MED_TAILLE_NUM_DATA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0){
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si le groupe HDF "scalaire" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(scalaire,ERROR);
if ((gid = _MEDdatagroupCreer(root,scalaire)) < 0) {
MESSAGE("Erreur à la création de la variable scalaire : ");
SSCRUTE(scalaire);
goto ERROR;
}
/*
* On stocke l'unite, et le type de la valeur scalaire
*/
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type)) < 0) {
MESSAGE("Erreur à l'écriture du type de la varaible scalaire : ");
ISCRUTE(_type);
goto ERROR;
}
if ((ret = _MEDattrStringEcrire(gid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description de la variable scalaire : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* On ferme tout
*/
ret = 0;
ERROR:
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret=-1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret=-1;
}
return ret;
}
med_err
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;
}
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 _MEDmeshGridIndexCoordinateRd30(int dummy, ...) {
med_idt _meshid=0;
med_err _ret = -1;
med_data_type _datatype = MED_UNDEF_DATATYPE;
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _meshdim = 0;
char _meshpath[MED_TAILLE_MAA+MED_NAME_SIZE+1]=MED_MAA;
med_int _intaxistype=0;
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_int , , axis );
MED_VARGS_DECL(, med_float *, const , gridindex );
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, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_int , , axis );
MED_VARGS_DEF(, med_float *, const , gridindex );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
strcat(_meshpath,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_meshpath); goto ERROR;
}
/*
* Lecture du type de grille (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;
if ((_gridtype != MED_CARTESIAN_GRID) && (_gridtype != MED_POLAR_GRID)) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_REP */
if ( _MEDattrEntierLire(_meshid,MED_NOM_REP,&_intaxistype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_REP);
ISCRUTE(_intaxistype);goto ERROR;
}
if ((med_mesh_type)( _intaxistype) != MED_CARTESIAN ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_AXISTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(_intaxistype);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_DIM */
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;
}
if (axis > _meshdim ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(_meshdim);ISCRUTE(axis);goto ERROR;
}
/*
* On ecrit le tableau d'indice dans un dataset HDF
*/
switch(axis)
{
case 1 :
_datatype = MED_COORDINATE_AXIS1;
break;
case 2 :
_datatype = MED_COORDINATE_AXIS2;
break;
case 3 :
_datatype = MED_COORDINATE_AXIS3;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
if (_MEDmeshAdvancedRd(fid,
meshname,
_datatype,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
MED_NODE,
MED_NONE,
MED_NO_CMODE,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
(unsigned char *) gridindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedRd");
goto ERROR;
}
_ret = 0;
ERROR:
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
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;
}
med_err
MEDequivalenceCr(const med_idt fid,
const char * const meshname,
const char * const equivname,
const char * const description)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_eqid=0,_meshid=0;
med_err _ret=-1;
char _path[MED_TAILLE_EQS+MED_NAME_SIZE+1]=MED_EQS;
/*
* 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 /EQS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(meshname,ERROR);
/*
* Si le DataGroup /EQS/<meshname> n'existe pas, on le cree
*/
if ((_meshid = _MEDdatagroupOuvrir(_root,meshname)) < 0)
if ((_meshid = _MEDdatagroupCreer(_root,meshname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,meshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,meshname);
NOFINALBLANK(equivname,ERROR);
/*
* Si le Data Group "/EQS/<meshname>/<equivname>" n'existe pas, on le cree
*/
if ((_eqid = _MEDdatagroupOuvrir(_meshid,equivname)) < 0)
if ((_eqid = _MEDdatagroupCreer(_meshid,equivname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,equivname);
SSCRUTE(_path);goto ERROR;
}
/* if ( (_eqid = _MEDmeshAssociatedGroupCr(fid, */
/* MED_EQS_NOM, */
/* meshname, */
/* numdt, */
/* numit, */
/* -1, */
/* MED_FALSE, */
/* equivalencename ) ) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAssociatedGroupCr"); */
/* SSCRUTE(MED_EQS_NOM);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(equivalencename); */
/* goto ERROR; */
/* } */
/*
* L'attribut "DES"
*/
if ((_ret = _MEDattributeStringWr(_eqid,MED_NOM_DES,MED_COMMENT_SIZE,
description)) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(description);
goto ERROR;
}
_ret=0;
ERROR:
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,equivname);
ISCRUTE_id(_eqid);SSCRUTE(_path);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_eqid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_EQS);
ISCRUTE_id(_eqid);
}
return _ret;
}
void
_MEDlocalizationInfoByName236(int dummy, ...) {
med_idt _lzid=0;
med_err _ret=-1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
med_int _intgeotype = -1;
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;
*spacedimension = (_intgeotype/100);
sectionmeshname[0]='\0';
geointerpname[0]='\0';
*nsectionmeshcell=0;
*sectiongeotype=MED_UNDEF_GEOTYPE;
_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
_MEDfield23ComputingStepMeshInfo30(int dummy,...)
{
med_err _ret=-1;
med_idt _gid=0,_datagroup1=0,_meshgid=0,_linkgid=0;
int _num;
char _datagroupname1[2*MED_MAX_PARA+1]="";
char _path [(MED_FIELD_GRP_SIZE+MED_NAME_SIZE+1)+2*MED_MAX_PARA+1]=MED_FIELD_GRP;
char _meshpath [MED_MESH_GRP_SIZE+MED_NAME_SIZE+1]=MED_MESH_GRP;
char _linkpath [MED_TAILLE_LIENS+MED_NAME_SIZE+1]=MED_LIENS;
char _cstpname[2*MED_MAX_PARA+1]="";
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);
/* Lecture de l'attribut MED_NOM_MAI */
if ( _MEDattributeStringRdByName(fid,_path,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_MAI);SSCRUTE(meshname);
goto ERROR;
}
/*
* On recupere le nom de la séquence de calcul
*/
if ( _MEDobjectGetName(fid, _path ,_num, _cstpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
strcat(_path,"/");
strcat(_path,_cstpname);
if ((_gid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Lecture des attributs
*/
if (_MEDattrEntierLire(_gid,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(_gid,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(_gid,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 (_MEDattrEntierLire(_gid,MED_NOM_RDT,(med_int*) meshnumdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_RDT);
SSCRUTE(_path);ISCRUTE(*meshnumdt);goto ERROR;
}
if (_MEDattrEntierLire(_gid,MED_NOM_ROR,(med_int*) meshnumit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_ROR);
SSCRUTE(_path);ISCRUTE(*meshnumit);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;
*nmesh = 1;
_ret = 0;
ERROR:
if (_gid>0) if (_MEDdatagroupFermer(_gid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_gid);
}
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 _MEDsubdomainCorrespondenceSize30(int dummy, ...) {
med_err _ret=-1;
med_idt _eqid=0,_datagroup1=0,_dataset=0;
char _path[MED_JOINT_GRP_SIZE+2*MED_NAME_SIZE+2+2*MED_MAX_PARA+1+4*MED_TAILLE_NOM_ENTITE+4]=MED_JOINT_GRP;
char _datagroupname1[2*MED_TAILLE_NOM_ENTITE+2]="";
char _cstpname[2*MED_MAX_PARA+1]="";
med_size _njointarray=0;
med_sorting_type _sortingtype=0;
med_int _intlocalentitype;
med_int _intlocalgeotype;
char _localgeotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _remotegeotypename [MED_TAILLE_NOM_ENTITE+1]="";
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, char * , const , jointname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , localentitype );
MED_VARGS_DECL(const, med_geometry_type , , localgeotype );
MED_VARGS_DECL(const, med_entity_type , , remoteentitype );
MED_VARGS_DECL(const, med_geometry_type , , remotegeotype );
MED_VARGS_DECL(, med_int *, const , nentitycor );
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 , jointname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , localentitype );
MED_VARGS_DEF(const, med_geometry_type , , localgeotype );
MED_VARGS_DEF(const, med_entity_type , , remoteentitype );
MED_VARGS_DEF(const, med_geometry_type , , remotegeotype );
MED_VARGS_DEF(, med_int *, const , nentitycor );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if ( MEDmeshSortingTypeRd(fid,meshname,&_sortingtype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API," MEDmeshSortingTypeRd");
SSCRUTE(meshname);ISCRUTE_int(_sortingtype);goto ERROR;
}
strcat( _path, meshname);
strcat( _path, "/");
strcat( _path, jointname);
strcat( _path, "/");
_MEDgetComputationStepName(_sortingtype,numdt,numit,&_path[strlen(_path)]);
strcat( _path, "/");
/*
* Construction du nom de datagroup <localentitype>[.<localgeotype>].<remoteentitype>[.<remotegeotype>]
*/
if (_MEDgetEntityTypeName(&_path[strlen(_path)],localentitype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(localentitype);SSCRUTE(jointname);goto ERROR;
}
if ( localentitype != MED_NODE ) {
if ( _MEDgetInternalGeometryTypeName(0,_localgeotypename,localgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(localgeotype);SSCRUTE(jointname);goto ERROR;
}
strcat(_path,".");
strcat(_path,_localgeotypename);
}
strcat(_path,".");
if (_MEDgetEntityTypeName(&_path[strlen(_path)],remoteentitype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(remoteentitype);SSCRUTE(jointname);goto ERROR;
}
if ( remoteentitype != MED_NODE ) {
if ( _MEDgetInternalGeometryTypeName(fid,_remotegeotypename,remotegeotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(remotegeotype);SSCRUTE(jointname);goto ERROR;
}
strcat(_path,".");
strcat(_path,_remotegeotypename);
}
if ( (_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0 ) {
*nentitycor=0;
goto SORTIE;
}
if ((_dataset = _MEDdatasetOuvrir(_datagroup1,MED_NOM_COR)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);
goto ERROR;
}
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,nentitycor) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nentitycor);
goto ERROR;
}
SORTIE:
_ret = 0;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COR);
ISCRUTE_id(_dataset);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_datagroup1);
}
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;
}
void
MEDjointCr231(int dummy,...) {
med_idt fid ;
char * maa_lcl ;
char * jn ;
char * desc ;
med_int dom ;
char * maa_dist ;
med_err * fret ;
med_idt root=0,jntid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_JNT+1];
med_int nbc=0;
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params,med_idt);
maa_lcl = va_arg(params,char *);
jn = va_arg(params,char *);
desc = va_arg(params,char *);
dom = va_arg(params,med_int);
maa_dist = va_arg(params,char*);
fret = va_arg(params,med_err *);
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un joint en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group "JNT" n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
NOFINALBLANK(maa_lcl,ERROR);
strcat(chemin,maa_lcl);
strncpy(tmp,MED_JNT,MED_TAILLE_JNT-1);
tmp[MED_TAILLE_JNT-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si un joint du meme nom existe => erreur
* Sinon on le cree
*/
NOFINALBLANK(jn,ERROR);
if ((jntid = _MEDdatagroupCreer(root,jn)) < 0) {
MESSAGE("Erreur à la création du joint : ");
SSCRUTE(jn);
goto ERROR;
}
/*
* L'attribut "DES"
*/
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description du joint : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* L'attribut "MAI"
*/
/* BUG CORRIGE EN 232 MED_TAILLE_NOM au lieu de MED_TAILLE_MAA */
/* conservé ici pour éviter de reprendre en lib2.3.2 un fichier 2.3.1
en écrivant l'attribut avec une taille plus grande que celle des fichiers 2.3.1 */
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_MAI,MED_TAILLE_MAA,maa_dist)) < 0) {
MESSAGE("Erreur à l'écriture du nom du maillage distant : ");
SSCRUTE(maa_dist);
goto ERROR;
}
/*
* L'attribut "DOM"
*/
if ((ret = _MEDattrEntierEcrire(jntid,MED_NOM_DOM,&dom)) < 0) {
MESSAGE("Erreur à l'écriture du domaine : ");
ISCRUTE(dom);
goto ERROR;
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (jntid>0) if (_MEDdatagroupFermer(jntid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(jntid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
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;
}
