med_err
_MEDgetComputationStepName(const med_sorting_type sortingtype, const med_int numdt,
const med_int numit, char * const datagroupname)
{
med_err _ret=-1;
long _numdt = numdt;
long _numit = numit;
switch (sortingtype) {
case MED_SORT_DTIT:
sprintf(datagroupname,"%0*li%0*li",MED_MAX_PARA, _numdt,MED_MAX_PARA, _numit);
break;
case MED_SORT_ITDT:
sprintf(datagroupname,"%0*li%0*li",MED_MAX_PARA, _numit,MED_MAX_PARA, _numdt);
break;
default:
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_PARAMETER,"");
ISCRUTE_int(sortingtype);
goto ERROR;
}
_ret=0;
ERROR:
return _ret;
}
med_err
MEDstructElementInfo(const med_idt fid,
const int mit,
char * const modelname,
med_geometry_type * const mgeotype,
med_int* const modeldim,
char* const supportmeshname,
med_entity_type* const sentitytype,
med_int* const snnode,
med_int* const sncell,
med_geometry_type* const sgeotype,
med_int* const nconstantattribute,
med_bool* const anyprofile,
med_int* const nvariableattribute
)
{
med_err _ret=-1;
char _path[MED_TAILLE_STRCT+MED_NAME_SIZE+1]=MED_STRCT;
int _num = mit -1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom de l'élément de structure
*/
if ( _MEDobjectGetName(fid, _path ,_num, modelname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(mit);
goto ERROR;
}
strcat(_path,modelname);
if (
MEDstructElementInfoByName(fid,
modelname,
mgeotype,
modeldim,
supportmeshname,
sentitytype,
snnode,
sncell,
sgeotype,
nconstantattribute,
anyprofile,
nvariableattribute
) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_STRUCT_MSG);
SSCRUTE(modelname);SSCRUTE(_path);SSCRUTE("MEDstructElementInfoByName");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_int
MEDfieldnComponent(const med_idt fid,
const int ind)
{
med_err _ret = -1;
char _fieldname[MED_NAME_SIZE+1]="";
int _num = ind-1;
char _path [MED_TAILLE_CHA+MED_NAME_SIZE+1]=MED_CHA;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom du champ
*/
if ( _MEDobjectGetName(fid, _path ,_num, _fieldname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
if ( (_ret=MEDfieldnComponentByName( fid, _fieldname )) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_FIELD_MSG);
SSCRUTE(_fieldname);SSCRUTE(_path);SSCRUTE("MEDfieldnComponentbyName");
goto ERROR;
}
ERROR:
return _ret;
}
void
_MEDequivalenceCorrespondenceRd236(int dummy, ...) {
med_err _ret=-1;
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 ( MEDequivLire(fid, (char *) meshname, (char *) equivname, correspondence, -1 ,
entitype, geotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDequivLire");
SSCRUTE(meshname); SSCRUTE(equivname);
ISCRUTE_int(entitype);ISCRUTE_int(geotype);goto ERROR;
}
_ret=0;
ERROR:
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;
}
int main (int argc, char **argv)
{
int _i=0;
med_err _ret=-1;
med_idt _fid=0;
med_int _ngeotype=0;
const char _meshname[MED_NAME_SIZE+1]="maa1";
med_bool _chgt=MED_FALSE,_trsf=MED_FALSE;
/*TODO : Traduire MED_TAILLE_NOM_ENTITE */
char _geotypename[MED_NAME_SIZE+1]="";
med_geometry_type _geotype=MED_NO_GEOTYPE;
/* Ouverture en mode creation du fichier med */
_fid = MEDfileOpen("Test_MEDmeshStructElementVarAttWr.med",MED_ACC_RDONLY);
if (_fid < 0) {
MESSAGE("Erreur a la creation du fichier current.med");
return -1;
}
/* TODO : Créer un itérateur sur les types d'entités*/
if ( (_ngeotype = MEDmeshnEntity(_fid,_meshname,MED_NO_DT,MED_NO_IT,
MED_STRUCT_ELEMENT,MED_GEO_ALL,MED_CONNECTIVITY,MED_GLOBAL_STMODE,
&_chgt,&_trsf) ) < 0 ) {
MESSAGE ("Erreur à la lecture du nombre de type géométrique pour le type d'entités MED_STRUCT_ELEMENT");
goto ERROR;
}
ISCRUTE(_ngeotype);
for (_i=0; _i < _ngeotype; _i++) {
if ( MEDmeshEntityInfo(_fid,
_meshname,
MED_NO_DT,MED_NO_IT,
MED_STRUCT_ELEMENT,
_i+1,
_geotypename,&_geotype
) <0 ){
MESSAGE ("Erreur à la demande d'informations pour le type d'entités MED_STRUCT_ELEMENT");
ISCRUTE_int(_i);
goto ERROR;
}
SSCRUTE(_geotypename);
ISCRUTE(_geotype);
}
_ret = 0;
ERROR:
if (MEDfileClose(_fid) < 0) {
MESSAGE("ERROR : file closing");
return -1;
}
return _ret;
}
/**\ingroup MEDinterp
\brief \MEDinterpInfoBrief
\param fid \fid
\param interpit \interpit
\param interpname \interpname
\param geotype \geotype
\param cellnode \cellnode
\param nbasisfunc \nbasisfunc
\param nvariable \nvariable
\param maxdegree \maxdegree
\param nmaxcoef \nmaxcoef
\return \error
\details \MEDinterpInfoDetails
\see MEDinterpInfoByName
*/
med_err
MEDinterpInfo(const med_idt fid,
const int interpit,
char* const interpname,
med_geometry_type* const geotype,
med_bool* const cellnode,
med_int* const nbasisfunc,
med_int* const nvariable,
med_int* const maxdegree,
med_int* const nmaxcoef
)
{
med_err _ret=-1;
char _interppath[MED_TAILLE_INTERP+MED_NAME_SIZE+1]=MED_INTERP;
int _num = interpit -1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom de l'interpolation
*/
if ( _MEDobjectGetName(fid, _interppath ,_num, interpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_interppath);ISCRUTE_int(interpit);
goto ERROR;
}
strcat(_interppath,interpname);
if ( MEDinterpInfoByName(fid,
interpname,
geotype,
cellnode,
nbasisfunc,
nvariable,
maxdegree,
nmaxcoef
) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_INTERP_MSG);
SSCRUTE(interpname);SSCRUTE(_interppath);SSCRUTE("MEDinterpInfoByName");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err _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 MEDmeshEntityAttributeAdvancedWr(const med_idt fid,
const char* const meshname,
const med_data_type datatype,
const med_int numdt,
const med_int numit,
const med_entity_type entitype,
const med_geometry_type geotype,
const med_filter * const filter,
const void * const attval)
{
med_err _ret=-1;
switch (datatype) {
case MED_NAME:
case MED_NUMBER:
case MED_FAMILY_NUMBER:
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_PARAMETER,"");
ISCRUTE_int(datatype);
goto ERROR;
}
_ret= _MEDmeshAdvancedWr(fid,
meshname,
datatype,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
MED_UNDEF_DT, /*Si la séquence de calcul n'existe pas, ce champ sera initialisé correctement par d'autres appels.*/
entitype,
geotype,
MED_NODAL,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_UNDEF_INTERLACE,
MED_ALL_CONSTITUENT,
filter,
MED_UNDEF_SIZE,
attval);
ERROR:
return _ret;
}
med_err
MEDlocalizationInfo(const med_idt fid,
const int localizationit,
char * const localizationname,
med_geometry_type * const geotype,
med_int * const spacedimension,
med_int * const nipoint,
char * const geointerpname,
char * const sectionmeshname,
med_int * const nsectionmeshcell,
med_geometry_type * const sectiongeotype)
{
med_err _ret=-1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
int _num=localizationit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* ouverture du groupe /GAUSS/"nom"
*/
if ( _MEDobjectGetName(fid, _path ,_num, localizationname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
ISCRUTE_int(localizationit);
goto ERROR;
}
if ( MEDlocalizationInfoByName(fid, localizationname, geotype, spacedimension,
nipoint,geointerpname,
sectionmeshname, nsectionmeshcell,sectiongeotype ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDlocalizationInfoByName");
SSCRUTE(localizationname);
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_int
MEDnProfil(med_idt fid)
{
int n=0;
med_idt datagroup=0;
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (datagroup = _MEDdatagroupOuvrir(fid,MED_PROFILS)) < 0)
return 0;
else
if (datagroup) if ( _MEDdatagroupFermer(datagroup) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup); return -1;
}
if ( _MEDnObjets(fid,MED_PROFILS,&n) < 0 ) return -1;
return (med_int) n;
}
med_err
MEDconnEcr(med_idt fid,char *maa, med_int mdim, med_int *connectivite,med_mode_switch mode_switch,
med_int nbre, med_entite_maillage type_ent,
med_geometrie_element type_geo,med_connectivite type_conn)
{
med_idt maaid, entid, geoid, dataset;
med_err ret;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
char nom_ent[MED_TAILLE_NOM_ENTITE+1];
char nom_geo[MED_TAILLE_NOM_ENTITE+1];
char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
int dim, nnoe, ndes;
int taille;
med_entite_maillage _type_ent=type_ent;
if ( type_ent == MED_NOEUD_MAILLE ) _type_ent=MED_NOEUD ;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* On met a jour le nom du Data Group representant
* le type des entites
*/
if ((ret = _MEDnomEntite(nom_ent,_type_ent)) < 0)
return -1;
/*
* Si le Data Group des entites n'existe pas on le cree
*/
if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
return -1;
/*
* On cree s'il n'existe pas le Data Group du type geometrique
*/
if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
return -1;
if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
return -1;
/*
* On regarde si le Data Set existe et on le cree sinon
*/
if ((ret=_MEDparametresGeometrie(_type_ent,type_geo,&dim,&nnoe,&ndes))<0)
return -1;
switch(type_conn)
{
case MED_NOD :
strcpy(nom_dataset,MED_NOM_NOD);
taille = nnoe;
break;
case MED_DESC :
strcpy(nom_dataset,MED_NOM_DES);
taille = ndes;
break;
default :
return -1;
}
dimd[0] = nbre*taille;
#if defined(HAVE_F77INT64)
ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT64,mode_switch,(med_size)taille,MED_ALL,
MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) connectivite);
#else
ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT32,mode_switch,(med_size)taille,MED_ALL,
MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) connectivite);
#endif
if (ret < 0 ) {
MESSAGE("Impossible d'ecrire le dataset coon de taille : ");
ISCRUTE_int(taille); return -1;
}
/*
* Attribut NBR (nombre de noeuds ou d'elements)
*/
if ((dataset = _MEDdatasetOuvrir(geoid,nom_dataset)) < 0)
return -1;
if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&nbre)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(geoid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(entid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
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
_MEDequivalenceInfo30(int dummy, ...)
{
med_idt _eqid=0;
med_err _ret=-1,_err=-1;
char _path[MED_TAILLE_EQS+2*MED_NAME_SIZE+2]=MED_EQS;
char _cstpname[2*MED_MAX_PARA+1]="";
int _num;
int _pathreflen=0;
med_size _nstep=0,_nocstpncorrespondence=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, int , , equivit );
MED_VARGS_DECL(, char *, const , equivname );
MED_VARGS_DECL(, char *, const , equivdescription );
MED_VARGS_DECL(, med_int *, const , nstep );
MED_VARGS_DECL(, med_int *, const , nocstpncorrespondence );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, int , , equivit );
MED_VARGS_DEF(, char *, const , equivname );
MED_VARGS_DEF(, char *, const , equivdescription );
MED_VARGS_DEF(, med_int *, const , nstep );
MED_VARGS_DEF(, med_int *, const , nocstpncorrespondence );
MED_VARGS_DEF(, med_err * ,, fret );
_num=equivit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On recupere le nom de l'equivalence
*/
strcat(_path,meshname);
_pathreflen=strlen(_path);
if ( _MEDobjectGetName(fid, _path ,_num, equivname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(equivit);
goto ERROR;
}
_path[_pathreflen]='/';
strncpy(&_path[_pathreflen+1],equivname,MED_NAME_SIZE+1);
if ((_eqid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(_path);
goto ERROR;
}
/*
* L'attribut DES
*/
if ( _MEDattrStringLire(_eqid,MED_NOM_DES,MED_COMMENT_SIZE,equivdescription) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(_path);SSCRUTE(MED_NOM_DES);
goto ERROR;
}
/*
* Nombre d'$(0!;(Btapes de calcul
*/
if (_MEDnObjects(_eqid,".",&_nstep) <0) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
*nstep = (med_int) _nstep;
/*
* Nombre de correspondence pour <MED_NO_DT,MED_NO_IT>
*/
_MEDgetComputationStepName(MED_SORT_DTIT,MED_NO_DT,MED_NO_IT,_cstpname);
if ( (_err=_MEDnObjects(_eqid, _cstpname, &_nocstpncorrespondence)) < 0 )
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_cstpname);
goto ERROR;
}
*nocstpncorrespondence = (med_int) _nocstpncorrespondence;
_ret = 0;
ERROR:
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,&_path[_pathreflen]);
ISCRUTE_id(_eqid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDmeshnEntity30(int dummy, ...)
{
med_access_mode _MED_ACCESS_MODE;
med_int _ret=-1,_err=-1;
med_idt _meshid=0, _datagroup=0,_datagroupf=0,_datagroup1=0;
med_idt _datagroup2=0,_datagroup3=0,_datagroup4=0,_dataset=0;
char _meshpath [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
char _datagroupname1 [2*MED_MAX_PARA+1] ="";
char _datagroupname2 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname3 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname4 [MAX(MED_TAILLE_VARATR,MED_TAILLE_COOTRF)]="";
char _datasetconame [3 + 1 + 3 + 1 ] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _datasetname [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype = 0;
med_int _intsortingtype = 0;
med_int _profilearraysize = 0;
med_int _changement=0, _changement_s=0, _transformation=0;
med_bool _changement_co = MED_FALSE;
med_size _n=0;
med_int _intn=0;
med_bool _isasupportmesh = MED_FALSE;
med_bool _isasoftlink = MED_FALSE;
med_bool _datasetexist = MED_FALSE;
med_int _ntmpmeddatatype = 1;
med_data_type _tmpmeddatatype[4] = {MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE};
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _intmeshtype = 0;
med_int _meshdim = 0;
int _i = 0;
med_connectivity_mode _cmode ;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_cmode = cmode;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/*
* Ouverture du datagroup de niveau 1 <_meshpath>/<meshname>
*/
NOFINALBLANK(meshname,ERROR);
if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(_meshpath); goto ERROR;
}
/* Lecture de la dimension du maillage */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
/* Lecture du type de maillage (attribut MED_NOM_TYP) */
if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
}
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
/* Lecture de l'attribut MED_NOM_GTY */
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype= (med_grid_type) _intgridtype;
}
/*
* Ouverture du datagroup de niveau 2 <numdt>.<numit>
*/
if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
}
_sortingtype = (med_sorting_type) (_intsortingtype);
_MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
}
/*
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_CGT);goto ERROR;
}
*changement = (med_bool) _changement;
*transformation = MED_FALSE;
/*
* Gestion entitytype == MED_UNDEF_ENTITY_TYPE
*/
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) {
_n=0; goto SORTIE;
}
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
_err=_MEDnObjects(_datagroup1,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
goto SORTIE;
}
/*
* Ouverture du datagroup de niveau 3 <entitytype>
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
}
if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
*changement = (med_bool) MED_FALSE;
_n=0;_datagroup2=0;
goto SORTIE;
}
/* MAJ du changement pour le type d'entité <entitytype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup2,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
/*
* Ouverture du datagroup de niveau 4 <geotype>
*/
/* Pas Utilisation pour MED_NODE */
if ( geotype == MED_GEO_ALL ) {
_err=_MEDnObjects(_datagroup2,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname2);
goto ERROR;
}
/*Par construction du modèle, le tableau de coordonnées preexiste aux autres */
if ( ( entitytype == MED_NODE ) && (_n > 0) ) _n=1;
goto SORTIE;
}
if ( entitytype != MED_NODE ) {
/* Lecture du nom de type géométrique */
/*TODO : Remplacer les deux appels suivants par un seul gérant les geotype dynamiques et statiques*/
if ( entitytype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid, geotype,_datagroupname3) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else
if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);goto ERROR;
}
if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
_n=0;
*changement = MED_FALSE;
goto SORTIE;
}
}
if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
/* MAJ du changement pour le type géométrique d'entité <geotype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
* Prend en charge le cas d'un dataset vide écrit pour un typegeo donné (CHGT==1)
*/
if (_datagroup3) {
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
}
/*
* Lecture du flag de modification sur autre chose que MED_CONNECTIVITY,MED_COORDINATE,MED_COORDINATE_AXIS<i>
*
*/
if ( _MEDattrEntierLire(_datagroup,MED_NOM_CGS,&_changement_s) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGS);goto ERROR;
}
/* 1) Lorsque l'utilisateur interroge un <meddatatype> qui est relatif a des coordonnées (famille,....) il faut mettre
* le flag chgt à jour par rapport à des modifications potentiellement effectuées sur ces coordonnées
* <=>
* Si on interroge autre chose que MED_CONNECTIVITY,MED_COORDINATE
* et qu'un changement est présent sur MED_CONNECTIVITY,MED_COORDINATE
* le flag chgt doit être positionné à vrai
* Une demande entitype==MED_NODE && (meddatatype == MED_COORDINATE_AXIS1)||(meddatatype == MED_COORDINATE_AXIS2)
* ||(meddatatype === MED_COORDINATE_AXIS3) est assimilée à une demande concernant des coordonnées
* <=>
* Y-a-t'il une modification des datasets COO(si NOE)| NOD|DES(si !NOE)
*/
/* 2)
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et que le cmode n'a pas été
* spécifié par l'utilisateur.
* Cette Information est necessaire pour construire le nom du dataset.
*/
if ( (meddatatype != MED_CONNECTIVITY) && ( meddatatype != MED_COORDINATE )
&& (meddatatype != MED_COORDINATE_AXIS1)
&& (meddatatype != MED_COORDINATE_AXIS2)
&& (meddatatype != MED_COORDINATE_AXIS3)
&& (meddatatype != MED_INDEX_FACE)
&& (meddatatype != MED_INDEX_NODE)) {
if (entitytype == MED_NODE) {
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
if ( (_gridtype == MED_CARTESIAN_GRID) ||
(_gridtype == MED_CURVILINEAR_GRID) ) {
_ntmpmeddatatype=_meshdim;
_tmpmeddatatype[0] = MED_COORDINATE_AXIS1;
_tmpmeddatatype[1] = MED_COORDINATE_AXIS2;
_tmpmeddatatype[2] = MED_COORDINATE_AXIS3;
} else if (_gridtype == MED_CURVILINEAR_GRID ) {
/*Les grilles curvilinéaires utilisent MED_COORDINATE_AXISx pour stocker la structure et le tableau MED_COORDINATE pour stocker les coordonnées des noeuds */
++_ntmpmeddatatype;
_tmpmeddatatype[3] = MED_COORDINATE;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
} else
_tmpmeddatatype[0] = MED_COORDINATE;
} else {
switch (geotype) {
case MED_POLYHEDRON:
_ntmpmeddatatype=3;
_tmpmeddatatype[2] = MED_CONNECTIVITY;
_tmpmeddatatype[1] = MED_INDEX_FACE;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
case MED_POLYGON:
_ntmpmeddatatype=2;
_tmpmeddatatype[1] = MED_CONNECTIVITY;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
default:
if ( ( (med_mesh_type) _intmeshtype ) == MED_STRUCTURED_MESH ) {
_ntmpmeddatatype=0;
break;
}
_tmpmeddatatype[0] = MED_CONNECTIVITY;
if ( cmode == MED_NO_CMODE ) {
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_NODAL,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
if ( _datasetexist ) _cmode= MED_NODAL;
else
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_DESCENDING,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
} else
_cmode = MED_DESCENDING;
}
}
}
*changement = MED_FALSE;
for (_i=0; _i < _ntmpmeddatatype ;++_i) {
if ( _MEDgetDatasetChgt( _datagroup, _tmpmeddatatype[_i], _cmode,
&_isasoftlink, &_changement_co ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"getDatasetChgt");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
*changement |= _changement_co;
}
}
/*
* Niveau de datagroup 5 supplémentaire pour les éléments de structure ou les transformations.
*/
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) ) {
if (meddatatype == MED_VARIABLE_ATTRIBUTE)
strcpy(_datagroupname4,MED_VARATR_NOM);
else
strcpy(_datagroupname4,MED_COOTRF_NOM);
if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
_n=0;
goto SORTIE;
}
}
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) )
_datagroupf=_datagroup4;
else
_datagroupf=_datagroup;
/*
* Construction du nom du dataset à lire
*/
if ( _MEDgetDatasetName(_datasetname,meddatatype,cmode) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetName");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
/*
* MAJ du champ transformation pour le (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if (_datagroup4) {
if ( _MEDattrEntierLire(_datagroup4,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
if ( (_dataset = _MEDdatasetOuvrir(_datagroupf,_datasetname)) < 0) {
_n=0;_dataset=0;*transformation = (med_bool) MED_FALSE;
/* if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname); */
/* SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4); */
/* ISCRUTE_size(_n); */
/* goto ERROR; */
/* } */
goto SORTIE;
}
if (!_datagroup4) {
/*
* Lire l'attribut CGT pour savoir si le dataset a changé
* n'a pas de sens si le dataset est en fait un lien vers le dataset précedent.
* En testant si le dataset est un lien on détermine si un changement a eu lieu
* depuis la séquence de calcul précédente.
* Ce traitement ne doit pas être effectué pour le pas de temps initial et pour
* (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if ( _MEDisasoftlink(_datagroupf, _datasetname,MED_TRUE, &_isasoftlink ) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_LINK,_datasetname);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
ISCRUTE_size(_n);goto ERROR;
}
if (_isasoftlink)
_transformation = MED_FALSE;
else {
if ( _MEDattrEntierLire(_dataset,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
}
*transformation = (med_bool) _transformation;
if ( ( meddatatype == MED_CONNECTIVITY) && ( meddatatype == MED_COORDINATE ) ) {
*transformation &= (med_bool) !_changement_s;
}
/*
* Attribut PFL (nombre de noeuds ou d'elements)
* la lecture est faite sur le datagroup _datagroup et non sur _datagroupf
* pour (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
_profilearraysize = 0;
profilename[0]='\0';
if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(profilename,_profilename,MED_NAME_SIZE+1);
profilename[MED_NAME_SIZE]='\0';
if ( ( _profilearraysize = MEDprofileSizeByName( fid,_profilename) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_profilename);SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
*profilesize=(med_int) _profilearraysize;
/*
* Attribut NBR (nombre d'entité)
*/
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_intn) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
SSCRUTE(_datasetname);SSCRUTE(MED_NOM_NBR);ISCRUTE_size(_n);goto ERROR;
}
_n = _intn;
if (_profilearraysize)
switch(storagemode) {
case MED_GLOBAL_PFLMODE :
break;
case MED_COMPACT_PFLMODE :
if ( meddatatype!=MED_COORDINATE_TRSF )
_n=_profilearraysize;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_STORAGEMODE,MED_ERR_VALUE_MSG);
ISCRUTE_int(storagemode);goto ERROR;
break;
}
SORTIE:
_ret = _n;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
ISCRUTE_id(_dataset);
}
if (_datagroup4>0) if (_MEDdatagroupFermer(_datagroup4) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname4);
ISCRUTE_id(_datagroup4);
}
if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
ISCRUTE_id(_datagroup3);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
/* _MEDobjetsOuverts(fid); */
*fret = _ret;
va_end(params);
return;
}
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
_MEDfieldnValue236(int dummy, ...)
{
med_int _ret =-1;
med_int _nprofile = 0;
med_int _n = 0;
med_int _profilearraysize = 0,_nvaluesperentity=0;
med_int _nintegrationpoint= 0;
med_bool _anyprofile = MED_FALSE;
med_geometrie_element _locgeotype = 0;
med_int _intlocgeotype = 0;
med_int _nvaluesperentityfromloc=0;
int _dummy =0;
char _localizationname [MED_TAILLE_NOM+1] = "";
char _tmpprofilename [MED_NAME_SIZE+1] = "", *_profilename=0;
char _path [MED_LOCALIZATION_GRP_SIZE+MED_TAILLE_NOM+1]= MED_LOCALIZATION_GRP;
char _geotype [MED_TAILLE_NOM_ENTITE+1] = "";
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(const, int , , profileit );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, char *, const , localizationname );
MED_VARGS_DECL(, med_int *, const , nintegrationpoint );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(const, int , , profileit );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, char *, const , localizationname );
MED_VARGS_DEF(, med_int *, const , nintegrationpoint );
MED_VARGS_DEF(, med_int * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
NOFINALBLANK(fieldname,ERROR);
if ( (profileit != 1) &&
(profileit != -1)) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_PARAMETER,MED_ERR_VALUE_MSG);
ISCRUTE_int(profileit);goto ERROR;
}
/*
* Cette appel effectue l'appel à _MEDfieldComputingStepCheck236
*/
_MEDfieldnProfile236(_dummy,fid,fieldname,numdt,numit,entitytype,geotype,
&_tmpprofilename,&_localizationname,&_nprofile );
if ( _nprofile < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDfieldnProfile236");
goto ERROR;
}
/* REM: MEDnVal prend en compte le nombre de points de Gauss, ce qui n'est pas le cas
de MEDfieldnValue */
if ( (_n = MEDnVal(fid, (char *) fieldname,entitytype,geotype,
numdt,numit,MED_NOREF,(med_mode_profil) storagemode) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDnVal");
goto ERROR;
}
/*
* Lecture de la taille du profil (eventuellement MED_ALLENTITIES_PROFILE)
*/
/* REM: (profileit < 0 ) signifie que l'on nous a fourni <profilename> */
if ( profileit < 0 ) {
if ( !strlen(profilename)) {
_profilename = MED_NOPFL;
} else {
if ( strcmp(_tmpprofilename,profilename) ) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_PARAMETER,profilename);
SSCRUTE(_tmpprofilename); goto ERROR;
}
_profilename=profilename;
_anyprofile=MED_TRUE;
}
} else {
strncpy(profilename,_tmpprofilename,MED_TAILLE_NOM+1);
profilename[MED_TAILLE_NOM]='\0';
_profilename=profilename;
if ( strlen(profilename)) _anyprofile=MED_TRUE;
}
if ( _anyprofile ) {
if ( (_profilearraysize=MEDprofileSizeByName(fid, _profilename)) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname); SSCRUTE(_profilename);
SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
/*
* Lecture du nombre de points d'intégration.
*/
strncpy(localizationname,_localizationname,MED_TAILLE_NOM+1);
localizationname[MED_TAILLE_NOM]='\0';
/* Vérification de la cohérence du nombre de valeurs pas entité */
if (entitytype == MED_NODE_ELEMENT ) {
if ( strlen( _localizationname) ) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_PARAMETER,_localizationname);
SSCRUTE(MED_NO_LOCALIZATION);ISCRUTE_int(entitytype);goto ERROR;
}
_nvaluesperentityfromloc = geotype % 100;
} else if (! strcmp(_localizationname,MED_GAUSS_ELNO)) {
/* Les points de Gauss sont d"finis sur les noeuds de l'element (mot cle) */
/* le nombre de points de Gauss est egal au nombre de noeuds de l'element */
_nvaluesperentityfromloc = geotype % 100;
} else if ( strlen(_localizationname) ) {
strcat(_path,_localizationname);
if ( _MEDattributeNumRdByName(fid, _path, MED_NOM_NBR,MED_INTERNAL_INT,(unsigned char *) &_nvaluesperentityfromloc) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(MED_NOM_NBR);SSCRUTE(_path); ISCRUTE(_nvaluesperentityfromloc);goto ERROR;
}
if ( _MEDattributeNumRdByName(fid, _path, MED_NOM_GEO, MED_INTERNAL_INT,(unsigned char *) &_intlocgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(MED_NOM_GEO);SSCRUTE(_path); ISCRUTE(_intlocgeotype);goto ERROR;
}
_locgeotype = (med_geometry_type) _intlocgeotype;
if ( _locgeotype != geotype ) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE_int(_locgeotype);ISCRUTE_int(geotype);
goto ERROR;
}
} else {
_nvaluesperentityfromloc = 1;
}
/* Pour effectuer la vérification suivante (incohérence dans le fichier suite à une
maj de la localisation ou du champ sans prise en compte d'un nombre de points d'intégration différent),
il faudrait lire l'attribut MED_NOM_NGA sur le maillage par défaut du champ*/
/* Pour celà il faut soit developper une nouvelle routine soit utiliser MEDpasdetempsInfo mais qui
est itérative*/
/* if ( _nvaluesperentityfromloc != _nvaluesperentity ) { */
/* MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG); */
/* SSCRUTE(_localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE(_nvaluesperentityfromloc); */
/* ISCRUTE(_nvaluesperentity);goto ERROR; */
/* } */
*nintegrationpoint = _nvaluesperentityfromloc;
_n/=_nvaluesperentityfromloc;
/*Rectification de la valeur 2.3.6 qui prend en compte le nombre de points d'intégration*/
if (_anyprofile)
*profilesize=_profilearraysize;
else
*profilesize=_n;
_ret = _n;
ERROR:
va_end(params);
*fret = _ret;
return;
}
med_err generateFieldFile( const med_size nentities, const med_size nvaluesperentity, const med_size nconstituentpervalue,
const med_switch_mode constituentmode,GetBlocksOfEntitiesType getBlockOfEntities, const med_int nbblocksperproc,
GenerateDataType generateDatas,
const med_storage_mode storagemode, const med_size profilearraysize, const char * const fieldnameprefix, COM_info * const cominfo ) {
/* static int _fileno=0; */
med_err _ret=-1;
char _filename [255]="";
char _meshname[MED_NAME_SIZE+1]="Empty mesh";
med_int _meshdim=3;
char _meshcomponentname[3*MED_SNAME_SIZE+1] = "x y z ";
char _meshcomponentunit[3*MED_SNAME_SIZE+1] = "cm cm cm ";
char _fieldname [MED_NAME_SIZE+1]="";
char *componentname,*componentunit;
char _profilename[MED_NAME_SIZE+1]=MED_NO_PROFILE;
med_int *_profilearray=0;
int _i=0,_j=0,_k=0, _lastusedrank=0;
med_size _blocksize=0,_lastblocksize=0,_count=0,_stride=0,_start=0,_index=0;
med_float *_arrayvalues;
med_filter filter = MED_FILTER_INIT;
med_size _nusedentities = nentities;
med_size _io_count = nbblocksperproc;
med_idt _fidseq,_fid;
MPI_Info info = cominfo->info;
MPI_Comm comm = cominfo->comm;
int mpi_size = cominfo->mpi_size;
int mpi_rank = cominfo->mpi_rank;
char *_MED_MODE_SWITCH_MSG[3]={"MED_FULL_INTERLACE", "MED_NO_INTERLACE","MED_UNDEF_INTERLACE",};
char *_MED_STORAGE_MODE_MSG[3]={"MED_NO_STMODE","MED_GLOBAL_STMODE", "MED_COMPACT_STMODE"};
med_geometry_type _geotype = MED_TRIA6;
med_int _geodim = _geotype/100;
med_int _geonnodes = _geotype%100;
char _ipointname[MED_NAME_SIZE+1];
med_float* _ipointrefcoo = 0;
med_int _ipoint = nvaluesperentity;
med_float* _ipointcoo = 0;
med_float* _ipointwg = 0;
sprintf(_filename,"%s_CPU-%03d_@_%s_%s.med",fieldnameprefix,mpi_size,_MED_MODE_SWITCH_MSG[constituentmode],_MED_STORAGE_MODE_MSG[storagemode]);
/* SSCRUTE(_filename); */
/* Ouverture du fichier en mode parallel */
if ((_fid = MEDparFileOpen(_filename, MODE_ACCES ,comm, info)) < 0){
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_FILE,_filename);
goto ERROR;
}
/* SSCRUTE(_meshname); */
if (MEDmeshCr( _fid,_meshname,_meshdim,_meshdim, MED_UNSTRUCTURED_MESH,
"Un maillage pour le test parallel","s", MED_SORT_DTIT,
MED_CARTESIAN, _meshcomponentname, _meshcomponentunit) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_MESH,_meshname);
goto ERROR;
};
componentname = (char*) malloc((nconstituentpervalue*MED_SNAME_SIZE+1)*sizeof(char));
componentunit = (char*) malloc((nconstituentpervalue*MED_SNAME_SIZE+1)*sizeof(char));
/*TODO : Compléter le nom */
strcpy(componentname,"");
strcpy(componentunit,"");
strcpy(_fieldname,fieldnameprefix);
if ( MEDfieldCr(_fid,_fieldname,MED_FLOAT64,nconstituentpervalue,componentname,componentunit,"s",_meshname ) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FIELD,_fieldname);
goto ERROR;
};
free(componentname);
free(componentunit);
if ( _ipoint > 1 ) {
MESSAGE("Creating a localization of integration points...");
strcpy(_ipointname,_fieldname);
strcat(_ipointname,"_loc");
/*Attention ancienne spec*/
_ipointrefcoo = (med_float *) calloc(_geodim*_geonnodes,sizeof(med_float));
_ipointcoo = (med_float *) calloc(_ipoint*_geodim,sizeof(med_float));
_ipointwg = (med_float *) calloc(_ipoint,sizeof(med_float));
if (MEDlocalizationWr(_fid, _ipointname, _geotype, _geotype/100, _ipointrefcoo, constituentmode,
_ipoint, _ipointcoo, _ipointwg, MED_NO_INTERPOLATION, MED_NO_MESH_SUPPORT ) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_LOCALIZATION,_ipointname);
ISCRUTE_int(constituentmode);
goto ERROR;
}
free(_ipointrefcoo );
free(_ipointcoo );
free(_ipointwg );
} else {
strcpy(_ipointname,MED_NO_LOCALIZATION);
}
if (profilearraysize) {
MESSAGE("Creating a profile...");
strcpy(_profilename,_fieldname);strcat(_profilename,"_profile");
_profilearray = (med_int*) calloc(profilearraysize,sizeof(med_int));
for (_i=0; _i < profilearraysize; ++_i) _profilearray[_i]=_i;
if ( MEDprofileWr(_fid,_profilename,profilearraysize,_profilearray) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_PROFILE,_profilename);
goto ERROR;
};
_nusedentities = profilearraysize;
} else {
strcpy(_profilename,MED_NO_PROFILE);
}
MESSAGE("Generating partition...");
getBlockOfEntities ( mpi_rank , mpi_size, _nusedentities,
&_start, &_stride, &_io_count, &_blocksize,
&_lastusedrank, &_lastblocksize);
_count=_io_count;
MESSAGE("Generating filter...");
if ( MEDfilterBlockOfEntityCr(_fid, nentities, nvaluesperentity, nconstituentpervalue,
MED_ALL_CONSTITUENT, constituentmode, storagemode, _profilename,
_start,_stride,_count,_blocksize,_lastblocksize, &filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,"");
goto ERROR;
}
MESSAGE("Generating datas...");
generateDatas(mpi_rank, _lastusedrank, sizeof(med_float),
storagemode, profilearraysize, _profilearray,
_start, _stride, _count, _blocksize, _lastblocksize,
nentities, nvaluesperentity, nconstituentpervalue,
&_arrayvalues );
MESSAGE("Writing field...");
if ( MEDfieldValueAdvancedWr(_fid,_fieldname,MED_NO_DT,MED_NO_IT,0.0, MED_CELL, _geotype,
_ipointname, &filter, (unsigned char*)_arrayvalues ) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_FIELD,_fieldname);
ISCRUTE(mpi_rank);
goto ERROR;
}
/* Test de lecture du même fichier avec filtre simple par un seul processeur */
/* TODO : Créer MEDflush */
H5Fflush(_fid, H5F_SCOPE_GLOBAL );
/*Le flush suffit pas besoin de synchroniser les processus : MPI_Barrier(MPI_COMM_WORLD); */
if (mpi_rank == 0 ) {
MESSAGE("Reading field...");
med_int _nentitiesarrayvalues=0;
med_float *_filteredarrayvalues=NULL;
med_filter filter2=MED_FILTER_INIT;
int _ind=0;
FILE * _asciifile;
char _asciifilename[255]="";
if ((_fidseq = MEDfileOpen(_filename, MED_ACC_RDONLY )) < 0){
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_FILE,_filename);
goto ERROR;
}
sprintf(_asciifilename,"%s_CPU-%03d_@_%s_%s.ascii",fieldnameprefix,mpi_size,_MED_MODE_SWITCH_MSG[constituentmode],_MED_STORAGE_MODE_MSG[storagemode]);
_asciifile=fopen(_asciifilename, "w");
/*Génère un filtre de selection simple s'il n'a pas déjà été généré lors d'un précédent appel */
/*TODO : Déplacer cette appel dans le main après avoir externaliser la génération du profile */
if (!(cominfo->filterarray))
if ( generateFilterArray( nentities, nvaluesperentity, nconstituentpervalue,
profilearraysize, _profilearray,
&(cominfo->nentitiesfiltered), &(cominfo->filterarray) ) < 0 ) {
goto ERROR;
}
ISCRUTE(cominfo->nentitiesfiltered);
/*Stocke le filtre utilisé dans le fichier .ascii*/
for (_i=0; _i < cominfo->nentitiesfiltered; ++_i ) {
/* ISCRUTE(cominfo->filterarray[_i]); */
fprintf(_asciifile,"%d ",cominfo->filterarray[_i]) ;
}
fprintf(_asciifile,"\n") ;
/*Pas de profile possible (profilearraysize == 0) en MED_GLOBAL_STMODE sur un fichier géré en parallel */
if ( profilearraysize ) {
_nentitiesarrayvalues = profilearraysize;
} else {
_nentitiesarrayvalues = nentities;
}
/*Attention allocation mémoire potentiellement grosse car réalisée uniquement par le processus 0
qui rassemble les données.*/
/* C'est une taille maxi qui ne prend pas en compte le COMPACT+filter */
/* TODO : Ajuster la taille au storage_mode*/
_filteredarrayvalues = (med_float*) malloc(_nentitiesarrayvalues*
nvaluesperentity*
nconstituentpervalue*sizeof(med_float));
/* Permet de vérifier une erreur d'indiçage après la lecture */
for (_i=0;_i<_nentitiesarrayvalues*nvaluesperentity*nconstituentpervalue; ++_i)
_filteredarrayvalues[_i]=-_i;
/*Création d'un filtre de sélection simple, pour une lecture séquentielle par le processys 0*/
if ( MEDfilterEntityCr(_fidseq, nentities, nvaluesperentity, nconstituentpervalue,
MED_ALL_CONSTITUENT, constituentmode, storagemode, _profilename,
cominfo->nentitiesfiltered,cominfo->filterarray, &filter2) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,"");
goto ERROR;
}
if ( MEDfieldValueAdvancedRd(_fidseq,_fieldname,MED_NO_DT,MED_NO_IT, MED_CELL, _geotype,
&filter2, (unsigned char*)_filteredarrayvalues ) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_FIELD,_fieldname);
ISCRUTE(mpi_rank);
goto ERROR;
}
/*AFFICHAGE TOUJOURS EN FULL INTERLACE QUELQUES SOIENT LES COMBINAISONS*/
/*TODO : Externaliser l'affichage*/
if ( storagemode == MED_GLOBAL_STMODE ) {
switch (constituentmode) {
case MED_FULL_INTERLACE:
for (_i=0; _i < cominfo->nentitiesfiltered; ++_i)
for (_j=0; _j < nvaluesperentity; ++_j)
for (_k=0; _k < nconstituentpervalue; ++_k) {
_ind = (cominfo->filterarray[_i]-1)*nvaluesperentity*nconstituentpervalue+ _j*nconstituentpervalue+_k;
/* fprintf(stdout,"%s%3d%s = %f\n","_filteredarrayvaluesFULLGLB[",_ind,"]",_filteredarrayvalues[_ind]) ; */
fprintf(_asciifile,"%f\n",_filteredarrayvalues[_ind]) ;
}
break;
case MED_NO_INTERLACE:
for (_j=0; _j < cominfo->nentitiesfiltered; ++_j)
for (_k=0; _k < nvaluesperentity; ++_k)
for (_i=0; _i < nconstituentpervalue; ++_i) {
_ind =_i*nentities*nvaluesperentity+ (cominfo->filterarray[_j]-1)*nvaluesperentity +_k;
/* fprintf(stdout,"%s%3d%s = %f\n","_filteredarrayvaluesNOGLB[",_ind,"]",_filteredarrayvalues[_ind]); */
fprintf(_asciifile,"%f\n",_filteredarrayvalues[_ind]);
}
break;
}
} else
switch (constituentmode) {
case MED_FULL_INTERLACE:
for (_i=0; _i < cominfo->nentitiesfiltered; ++_i )
for (_j=0; _j < nvaluesperentity; ++_j)
for (_k=0; _k < nconstituentpervalue; ++_k) {
_ind = _i*nvaluesperentity*nconstituentpervalue+_j*nconstituentpervalue+_k;
/* fprintf(stdout,"%s%3d%s = %f\n","_filteredarrayvaluesFULLCP[",_ind,"]",_filteredarrayvalues[_ind]) ; */
fprintf(_asciifile,"%f\n",_filteredarrayvalues[_ind]) ;
}
break;
case MED_NO_INTERLACE:
for (_j=0; _j < cominfo->nentitiesfiltered; ++_j)
for (_k=0; _k < nvaluesperentity; ++_k)
for (_i=0; _i < nconstituentpervalue; ++_i) {
_ind =_i*cominfo->nentitiesfiltered*nvaluesperentity+ _j*nvaluesperentity +_k;
/* _ind =_i*_nentitiesarrayvalues*nvaluesperentity+ (_filterarray[_j]-1)*nvaluesperentity +_k; */
/* fprintf(stdout,"%s%3d%s = %f\n","_filteredarrayvaluesNOCP[",_ind,"]",_filteredarrayvalues[_ind]); */
fprintf(_asciifile,"%f\n",_filteredarrayvalues[_ind]);
}
break;
}
free(_filteredarrayvalues);
fclose(_asciifile);
if ( MEDfilterClose(&filter2) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,"");
goto ERROR;
}
} /*fin if (mpi_rank == 0) */
if ( MEDfilterClose(&filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,"");
goto ERROR;
}
_ret=0;
ERROR:
if (_arrayvalues) free(_arrayvalues);
if (profilearraysize) free(_profilearray);
if ( MEDfileClose(_fid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILE,""); _ret = -1;
}
if (mpi_rank == 0 ) {
if ( MEDfileClose(_fidseq) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILE,""); _ret = -1;
}
}
return _ret;
}
med_idt
MEDparFileOpen(const char* const filename,
const med_access_mode accessmode,
const MPI_Comm comm, const MPI_Info info)
{
med_idt _fid = -1;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/*
* On ouvre le fichier MED sous HDF
*/
switch(accessmode)
{
case MED_ACC_RDONLY :
if (access(filename,F_OK)) {
MED_ERR_(_fid,MED_ERR_DOESNTEXIST,MED_ERR_FILE,filename);
goto ERROR;
} else {
if ((_fid = _MEDparFileOpen((char*) filename, accessmode, comm, info)) < 0) {
MED_ERR_(_fid,MED_ERR_OPEN,MED_ERR_FILE,filename);
goto ERROR;
}
};
break;
case MED_ACC_RDWR :
if (access(filename,F_OK)) {
if ((_fid = _MEDparFileCreate((char*) filename,accessmode, comm, info)) < 0) {
MED_ERR_(_fid,MED_ERR_CREATE,MED_ERR_FILE,filename);
goto ERROR;
}
} else
if ((_fid = _MEDparFileOpen((char*) filename,accessmode, comm, info)) < 0) {
MED_ERR_(_fid,MED_ERR_OPEN,MED_ERR_FILE,filename);
goto ERROR;
}
break;
case MED_ACC_RDEXT :
if (access(filename,F_OK))
{
if ((_fid = _MEDparFileCreate((char*) filename,accessmode, comm, info)) < 0) {
MED_ERR_(_fid,MED_ERR_CREATE,MED_ERR_FILE,filename);
goto ERROR;
}
} else
if ((_fid = _MEDparFileOpen((char *) filename, accessmode, comm, info)) < 0) {
MED_ERR_(_fid,MED_ERR_OPEN,MED_ERR_FILE,filename);
goto ERROR;
}
break;
case MED_ACC_CREAT :
if ((_fid = _MEDparFileCreate((char *) filename,MED_ACC_RDWR, comm, info)) < 0) {
MED_ERR_(_fid,MED_ERR_CREATE,MED_ERR_FILE,filename);
goto ERROR;
}
break;
default :
MED_ERR_(_fid,MED_ERR_RANGE,MED_ERR_PARAMETER,"");
ISCRUTE_int(accessmode);
goto ERROR;
}
if (_MEDcheckVersion30(_fid) < 0) {
MEDfileClose(_fid);
_fid=-1;goto ERROR;
}
ERROR:
return _fid;
}
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 _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
_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;
}
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 _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
MEDmeshPolygon2Rd(const med_idt fid,
const char* const meshname,
const med_int numdt,
const med_int numit,
const med_entity_type entitype,
const med_geometry_type polytype,
const med_connectivity_mode cmode,
med_int * const polyindex,
med_int * const connectivity )
{
med_access_mode _MED_ACCESS_MODE;
med_idt _meshid=0;
med_err _ret = -1;
med_data_type _datatype = MED_UNDEF_DATATYPE;
med_entity_type _entitytype=entitype;
/*
* 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;
}
/* Tester le type d'entité ?
* MAILLE Ok
* FACE OK
* ARETE ?
* NOEUD KO
* NOEUD_MAILLE ?
*/
if (entitype == MED_NODE_ELEMENT ) _entitytype=MED_NODE ;
switch(polytype)
{
case MED_POLYGON:
case MED_POLYGON2:
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(polytype);
goto ERROR;
}
if (_MEDmeshAdvancedRd(fid,
meshname,
MED_CONNECTIVITY,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
_entitytype,
polytype,
cmode,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
(unsigned char * const)connectivity) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedRd (MED_CONNECTIVITY) ");
goto ERROR;
}
if (_MEDmeshAdvancedRd(fid,
meshname,
MED_INDEX_NODE,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
_entitytype,
polytype,
cmode,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
(unsigned char * const)polyindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedRd (MED_INDEX_NODE) ");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
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
_MEDlocalizationInfoByName30(int dummy, ...) {
med_idt _lzid = 0;
med_err _ret = -1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
char _sectiongeotypename[MED_TAILLE_NOM_ENTITE+1]="";
med_int _intgeotype = -1,_nsectiongeotype=0, _nsectionmeshcell=0;
med_entity_type _sectionentitype = MED_CELL;
med_geometry_type _sectiongeotype = MED_UNDEF_GEOTYPE;
med_data_type _conorcoo = MED_CONNECTIVITY;
med_bool _chgt=MED_FALSE,_trsf=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , localizationname );
MED_VARGS_DECL(, med_geometry_type *, const , geotype );
MED_VARGS_DECL(, med_int *, const , spacedimension );
MED_VARGS_DECL(, med_int *, const , nipoint );
MED_VARGS_DECL(, char *, const , geointerpname );
MED_VARGS_DECL(, char *, const , sectionmeshname );
MED_VARGS_DECL(, med_int *, const , nsectionmeshcell );
MED_VARGS_DECL(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , localizationname );
MED_VARGS_DEF(, med_geometry_type *, const , geotype );
MED_VARGS_DEF(, med_int *, const , spacedimension );
MED_VARGS_DEF(, med_int *, const , nipoint );
MED_VARGS_DEF(, char *, const , geointerpname );
MED_VARGS_DEF(, char *, const , sectionmeshname );
MED_VARGS_DEF(, med_int *, const , nsectionmeshcell );
MED_VARGS_DEF(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* ouverture du groupe /GAUSS/"nom"
*/
strcat(_path,localizationname);
if ((_lzid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_NBR
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_NBR,nipoint) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nipoint);
goto ERROR;
}
/*
* On lit <typgeo> sous forme d'attribut
*/
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long,
du coup sur machines 64 bits _MEDattributeIntWr utilise
le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
un enum.
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_GEO,&_intgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE(_intgeotype);
goto ERROR;
};
*geotype = (med_geometry_type) _intgeotype;
/*
* On lit <spacedimension>
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_DIM,spacedimension) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_DIM);ISCRUTE(*spacedimension);
goto ERROR;
};
/*
* Lecture de l'attribut MED_NOM_NOM (nom du maillage de section)
*/
if ( _MEDattrStringLire(_lzid,MED_NOM_NOM,MED_NAME_SIZE,sectionmeshname) < 0) {
sectionmeshname[0]='\0';
}
if ( strlen(sectionmeshname) &&
( _intgeotype > MED_STRUCT_GEO_INTERNAL) &&
( _intgeotype < MED_STRUCT_GEO_SUP_INTERNAL) ) {
if ( _MEDgetSupportMeshNbOfEntities(fid,sectionmeshname,&_sectionentitype,
&_sectiongeotype,NULL,&_nsectionmeshcell) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetSupportMeshNbOfEntities");
SSCRUTE(sectionmeshname);ISCRUTE_int(_sectionentitype);
ISCRUTE(_sectiongeotype);ISCRUTE(_nsectionmeshcell);goto ERROR;
}
}
*sectiongeotype= _sectiongeotype;
*nsectionmeshcell= _nsectionmeshcell;
if ( _MEDattrStringLire(_lzid,MED_NOM_INM,MED_NAME_SIZE,geointerpname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_INM);SSCRUTE(geointerpname);
goto ERROR;
}
_ret = 0;
ERROR:
if ( _lzid > 0 ) if ( _MEDdatagroupFermer(_lzid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_GAUSS);
ISCRUTE_id(_lzid);
}
va_end(params);
*fret = _ret;
return;
}
void _MEDfileObjectsMount236(int dummy,...) {
med_idt _ret = -1;
med_idt _id, _rootId=0;
char _mountPath[2*MED_NAME_SIZE+1];
char _link[MED_NAME_SIZE+1];
med_access_mode _accessMode;
med_int majeur=0, mineur=0, release=0;
med_int rfileversionMMR,rfileversionMM,rfileversionM;
med_int lfileversionMMR,lfileversionMM,lfileversionM;
med_bool _datagroupexist=MED_FALSE,_isasoftlink=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, med_idt , , gid );
MED_VARGS_DECL(const, char* , const , mountfilename );
MED_VARGS_DECL(const, med_class , , medclass );
MED_VARGS_DECL(, med_idt * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, med_idt , , gid );
MED_VARGS_DEF(const, char* , const , mountfilename );
MED_VARGS_DEF(const, med_class , , medclass );
MED_VARGS_DEF(, med_idt * ,, fret );
_MEDmodeErreurVerrouiller();
if ( MEDfileNumVersionRd(fid, &majeur, &mineur, &release) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDfileNumVersionRd");
ISCRUTE(majeur);ISCRUTE(mineur);ISCRUTE(release);
goto ERROR;
}
lfileversionM = 100*majeur;
lfileversionMM = 100*majeur+10*mineur;
lfileversionMMR = lfileversionMM+release;
/*
* does the file exist ?
*/
if (access(mountfilename,F_OK)) {
MED_ERR_(_ret,MED_ERR_EXIST,MED_ERR_FILE,mountfilename);
goto ERROR;
}
if ( (_accessMode = (med_access_mode)_MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_FILE,"");
ISCRUTE_int(_accessMode);
goto ERROR;
}
/*
* Open the file "mountfilename".
*/
if ((_id = _MEDfileOpen(mountfilename,_accessMode)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_FILE,mountfilename);
goto ERROR;
}
if ( MEDfileNumVersionRd(_id, &majeur, &mineur, &release) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDfileNumVersionRd");
SSCRUTE(mountfilename);ISCRUTE(majeur);ISCRUTE(mineur); ISCRUTE(release);
goto ERROR;
}
rfileversionM = 100*majeur;
rfileversionMM = 100*majeur+10*mineur;
rfileversionMMR = rfileversionMM+release;
if ( !( ( (rfileversionMM >= 220) && (lfileversionMM >= 220)
&& (rfileversionMMR <= 236) && (lfileversionMMR <= 236) ) ) ){
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FILE,mountfilename);
ISCRUTE(rfileversionMMR);ISCRUTE(lfileversionMMR);
goto ERROR;
}
/*
* Mount point creation in the local file
*/
_rootId = _MEDdatagroupOuvrir(fid,MED_MNT);
if (_rootId < 0)
if ((_rootId = _MEDdatagroupCreer(fid,MED_MNT)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_FILE,MED_MNT);
goto ERROR;
}
/*
* The file "mountfilename" is mounted in the local file
*/
strncpy(_mountPath,MED_MNT,strlen(MED_MNT)-1);
_mountPath[strlen(MED_MNT)-1] = '\0';
if (_MEDfichierMonter(fid,_mountPath,_id) < 0) {
MED_ERR_(_ret,MED_ERR_MOUNT,MED_ERR_FILE,mountfilename);
goto ERROR;
}
/*
* Give access to the class object in the local file
*/
switch(medclass) {
case MED_MESH :
strcpy(_link,MED_MAA);
break;
case MED_FIELD :
strcpy(_link,MED_CHA);
break;
default :
goto ERROR;
}
strcat(_mountPath,_link);
_mountPath[strlen(_mountPath)-1] = '\0';
_link[strlen(_link)-1] = '\0';
if (_MEDdatagroupLienCreer(fid,_mountPath,_link) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_LINK,_link);
SSCRUTE(_mountPath);
goto ERROR;
}
_ret = _id;
ERROR:
if (_rootId > 0)
if (_MEDdatagroupFermer(_rootId) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILE,MED_MNT);
}
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;
}
med_err
MEDmeshPolyhedronWr(const med_idt fid,
const char* const meshname,
const med_int numdt,
const med_int numit,
const med_float dt,
const med_entity_type entitype,
const med_connectivity_mode cmode,
const med_int faceindexsize,
const med_int * const faceindex,
const med_int nodeindexsize,
const med_int * const nodeindex,
const med_int * const connectivity )
{
med_access_mode _MED_ACCESS_MODE;
med_idt _meshid=0;
med_err _ret = -1;
med_data_type _datatype = MED_UNDEF_DATATYPE;
med_int _connectivitysize = 0;
/*
* 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;
}
/* Tester le type d'entité ?
* MAILLE Ok
* FACE OK
* ARETE ?
* NOEUD KO
* NOEUD_MAILLE ?
*/
switch(cmode)
{
case MED_NODAL :
_connectivitysize = nodeindex[nodeindexsize-1] - nodeindex[0];
break;
case MED_DESCENDING :
_connectivitysize = nodeindexsize;
break;
default :
return -1;
}
if (_MEDmeshAdvancedWr(fid,
meshname,
MED_CONNECTIVITY,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
dt,
entitype,
MED_POLYHEDRON,
cmode,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
_connectivitysize,
connectivity) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedWr (MED_CONNECTIVITY) ");
goto ERROR;
}
if (_MEDmeshAdvancedWr(fid,
meshname,
MED_INDEX_NODE,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
dt,
entitype,
MED_POLYHEDRON,
cmode,
MED_UNDEF_PFLMODE,
MED_SAME_PROFILE_INTERNAL,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
nodeindexsize,
nodeindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedWr (MED_INDEX_NODE) ");
goto ERROR;
}
if (_MEDmeshAdvancedWr(fid,
meshname,
MED_INDEX_FACE,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
dt,
entitype,
MED_POLYHEDRON,
cmode,
MED_UNDEF_PFLMODE,
MED_SAME_PROFILE_INTERNAL,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
faceindexsize,
faceindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedWr (MED_INDEX_FACE) ");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
