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;
}
med_err
MEDgaussInfo(med_idt fid, int indice, char * locname, med_geometrie_element * type_geo,
med_int * ngauss )
{
int numero=0;
med_idt locid=0;
med_err ret=-1;
char chemin[MED_TAILLE_GAUSS+MED_TAILLE_NOM+1]="";
med_int typegeo;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On recupere le nom du groupe de rang "indice"
*/
numero = indice-1;
if ( _MEDobjetIdentifier(fid,MED_GAUSS,numero,locname) < 0)
goto ERROR;
/*
* On va chercher l'attribut ngauss
*/
strcpy(chemin,MED_GAUSS);
strcat(chemin,locname);
if ((locid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Impossible d'ouvrir le datagroup : ");
SSCRUTE(chemin); goto ERROR;
}
/* Lecture de <ngauss> */
if (_MEDattrEntierLire(locid,MED_NOM_NBR,ngauss) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NBR : ");
ISCRUTE(*ngauss);goto ERROR;
};
/* Lecture <type_geo> sous forme d'attribut */
if (_MEDattrEntierLire(locid,MED_NOM_GEO,&typegeo) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_GEO : ");
ISCRUTE(*type_geo);goto ERROR;
};
*type_geo = ( med_geometrie_element ) typegeo;
ret = 0;
ERROR:
if ( locid > 0 ) if (_MEDdatagroupFermer(locid) < 0)
goto ERROR;
return 0;
}
med_err _MEDdatagroupExist(const med_idt gid,
const char * const datagroupname,
med_bool * const datagroupexist,
med_bool * const isasoftlink )
/*Pour l'instant, dans le modèle interne les liens sont uniquement des liens vers
des datasets*/
{
med_err _ret=-1;
H5L_info_t _linkinfo;
H5O_info_t _oinfo;
if ( H5Lget_info( gid, datagroupname, &_linkinfo, H5P_DEFAULT ) >= 0 ) {
switch ( _linkinfo.type ) {
case H5L_TYPE_SOFT:
*isasoftlink=MED_TRUE;
_oinfo.type=H5G_LINK;
break;
case H5L_TYPE_HARD:
*isasoftlink = MED_FALSE;
if ( H5Oget_info_by_name( gid, datagroupname, &_oinfo, H5P_DEFAULT ) <0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"H5Oget_info_by_name");
SSCRUTE( datagroupname);
}
break;
case H5L_TYPE_EXTERNAL:
case H5L_TYPE_ERROR:
default:
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_HDFTYPE, datagroupname);
ISCRUTE( _linkinfo.type);
goto ERROR;
break;
}
/*TODO : A vérifier sur un lien de datagroup, à mon avis ne fonctionne pas */
switch ( _oinfo.type ) {
case H5G_GROUP:
case H5G_LINK:
*datagroupexist = MED_TRUE;
break;
default:
*datagroupexist = MED_FALSE;
}
} else {
*datagroupexist = MED_FALSE;
*isasoftlink = MED_FALSE;
}
_ret = 0;
ERROR:
return _ret;
}
int main (int argc, char **argv)
{
med_err _ret=0;
med_idt _fid=0;
char _fieldname1[MED_NAME_SIZE+1] = "champ reel";
char _interpname[MED_NAME_SIZE+1] = "";
med_int _ninterp = 0;
int _interpit=0;
/* Ouverture en mode creation du fichier "current.med" */
_fid = MEDfileOpen("current.med",MED_ACC_RDONLY);
if (_fid < 0) {
MESSAGE("Erreur a la creation du fichier current.med");
return -1;
}
if ( (_ninterp = MEDfieldnInterp(_fid,
_fieldname1
) ) < 0 ) {
MESSAGE("Erreur à la lecture du nombre de fonctions d'interpolation sur le champ : ");
SSCRUTE(_fieldname1);_ret=_ninterp; goto ERROR;
}
for (_interpit=0;_interpit < _ninterp; ++_interpit ) {
if ( (_ret = MEDfieldInterpInfo(_fid,
_fieldname1,
_interpit+1,
_interpname ) <0) ) {
MESSAGE("Erreur à la lecture des informations de la fonction d'interpolation n° :");
ISCRUTE(_interpit);SSCRUTE("sur le champ : ");SSCRUTE(_fieldname1);
goto ERROR;
}
else
fprintf(stdout,"Le nom de la fonction d'interpolation n°%d du champ %s est %s\n",
_interpit+1,_fieldname1,_interpname);
}
ERROR:
if (MEDfileClose(_fid) < 0) {
MESSAGE("ERROR : file closing");
return -1;
}
return _ret;
}
med_int
MEDnValProfil(med_idt fid, char *nom)
{
med_int n = 0;
med_idt gid;
char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1];
med_err ret;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* ouverture du groupe /PROFILS/<nom>
*/
strcpy(chemin,MED_PROFILS);
strcat(chemin,nom);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0){
MESSAGE("Impossible d'ouvrir le groupe MED_PROFILS : ");
SSCRUTE(chemin); return -1;
}
if ((ret = _MEDattrEntierLire(gid,MED_NOM_NBR,&n)) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NBR : ");
ISCRUTE(n); return -1;
}
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return n;
}
void MAJ_236_300_champs(med_idt fid)
{
med_err lret,ret;
/* med_idt _datagroup=0; */
med_field_type typcha;
char nomcha [MED_NAME_SIZE+1]="";
char _meshname [MED_NAME_SIZE+1]="";
char _dtunit [MED_SNAME_SIZE+1]="";
char *comp= NULL, *unit= NULL;
med_int ncomp,ncha;
med_int _ncstp=0;
med_bool _local=MED_FALSE;
htri_t _datasetexist;
char _pathi[MED_TAILLE_CHA+1+MED_NAME_SIZE+1]=MED_CHA;
char _pathf[MED_TAILLE_CHA+2+MED_NAME_SIZE+1]="/CHA_/";
char _pathtmp[MED_TAILLE_CHA+3]="/CHA__/";
int i,j;
char nomlien[MED_NAME_SIZE+1]="";
char * lien = NULL;
med_int nln,nval;
med_int _nloc,_intgeotype,_sdim;
char _pathloc[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
med_int _npar,_numdt,_numit;
char _pathpari[MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1+2*MED_MAX_PARA+1+1]=MED_NUM_DATA;
char _pathparf[MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1+2*MED_MAX_PARA+1+1]=MED_NUM_DATA;
int _pathparlen;
med_size _n=0;
char _cpstnamei[2*MED_MAX_PARA+1]="";
char _cpstnamef[2*MED_MAX_PARA+1]="";
char _uniname[MED_SNAME_SIZE+1]="";
/* hid_t _lac_plist_id; */
hid_t _lcp_plist_id;
hid_t _ocp_plist_id;
med_bool _createunt = MED_TRUE;
MAJ_version_num(fid,2,3,6);
/* MAJ des varaibles scalaires */
_npar = MEDnParameter(fid);
if (_npar > 0) {
fprintf(stdout," >>> Normalisation des paramètres scalaires\n");
_pathparf[MED_TAILLE_NUM_DATA-2]='_';
/* _lac_plist_id = H5Pcreate( H5P_LINK_ACCESS ); */
_ocp_plist_id = H5Pcreate( H5P_OBJECT_COPY );
_lcp_plist_id = H5Pcreate( H5P_LINK_CREATE );
H5Pset_create_intermediate_group( _lcp_plist_id, 1 );
H5Pset_copy_object( _ocp_plist_id, H5O_COPY_SHALLOW_HIERARCHY_FLAG);
}
for (i=0 ; i < _npar ; i++ ) {
MED_ERR_EXIT_IF (_MEDobjectGetName(fid, _pathpari ,i, &_pathpari[MED_TAILLE_NUM_DATA]) < 0,
MED_ERR_ACCESS,MED_ERR_DATAGROUP,_pathpari);
strcpy(&_pathparf[MED_TAILLE_NUM_DATA],&_pathpari[MED_TAILLE_NUM_DATA]);
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
/*Copie le group avec ses attributs et les objets de premier niveau.*/
ret = H5Ocopy(fid,_pathpari,fid,_pathparf,_ocp_plist_id,_lcp_plist_id);
/* ret = H5Lcopy(fid,_pathpari,fid,_pathparf,_lcp_plist_id,_lac_plist_id); */
EXIT_IF(ret < 0,"Copie du datagroup",_pathpari);
_pathparlen=strlen(_pathpari);
_pathpari[_pathparlen]='/';_pathparf[_pathparlen]='/';
++_pathparlen;
_pathpari[_pathparlen]='\0';_pathparf[_pathparlen]='\0';
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
ret =_MEDnObjects(fid,_pathpari, &_n);
MED_ERR_EXIT_IF( (ret == (MED_ERR_COUNT + MED_ERR_DATAGROUP)), MED_ERR_COUNT,MED_ERR_PARAMETER,_pathpari);
for (j=0 ; j < _n ; ++j ) {
MED_ERR_EXIT_IF (_MEDobjectGetName(fid, _pathpari ,j, &_pathpari[_pathparlen]) < 0,
MED_ERR_ACCESS,MED_ERR_DATAGROUP,_pathpari);
MED_ERR_EXIT_IF (_MEDattributeNumRdByName(fid,_pathpari,MED_NOM_NOR,
MED_INTERNAL_INT,(unsigned char * const ) &_numit) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
MED_ERR_EXIT_IF (_MEDattributeNumRdByName(fid,_pathpari,MED_NOM_NDT,
MED_INTERNAL_INT,(unsigned char * const ) &_numdt) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
MED_ERR_EXIT_IF (_MEDattributeStringRdByName(fid,_pathpari,MED_NOM_UNI,
MED_SNAME_SIZE,_uniname) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
_MEDgetComputationStepName(MED_SORT_DTIT,_numdt,_numit,&_pathparf[_pathparlen]);
/* strcat(_pathpari,"/"); */
/* strcat(_pathparf,"/"); */
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
/* ret = H5Ocopy(fid,_pathpari,fid,_pathparf,_ocp_plist_id,_lcp_plist_id); */
/* ret = H5Lcopy(fid,_pathpari,fid,_pathparf,_lcp_plist_id,_lac_plist_id); */
/* H5Eprint1(stderr); */
/* EXIT_IF(ret < 0,"Copie d'une étape de calcul du paramètre scalaire ",_pathpari); */
/*On modifie temporairement _pathpari pour pointer dans _pathparf*/
_pathpari[MED_TAILLE_NUM_DATA-2]='_';
/* SSCRUTE(_pathparf); */
/* SSCRUTE(_pathpari); */
ret = H5Gmove(fid, _pathpari, _pathparf );
EXIT_IF(ret < 0,"Renommage de l'étape de calcul",_pathpari);
_pathpari[MED_TAILLE_NUM_DATA-2]='A';
MED_ERR_EXIT_IF(H5Adelete_by_name( fid, _pathparf, MED_NOM_UNI, H5P_DEFAULT ) < 0,
MED_ERR_DELETE,MED_ERR_ATTRIBUTE,_pathparf);
_pathparf[_pathparlen]='\0';
_pathpari[_pathparlen]='\0';
if ( _createunt ) {
MED_ERR_EXIT_IF (_MEDattributeStringWrByName(fid,_pathparf,MED_NOM_UNT, MED_SNAME_SIZE,_uniname) < 0,
MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_UNT);
_createunt = MED_FALSE;
}
}
_createunt = MED_TRUE;
_pathpari[MED_TAILLE_NUM_DATA]='\0';
}
if ( _npar > 0 ) {
_pathpari[MED_TAILLE_NUM_DATA]='\0';
_pathparf[MED_TAILLE_NUM_DATA]='\0';
MED_ERR_EXIT_IF ( H5Ldelete(fid,_pathpari,H5P_DEFAULT) < 0 ,
MED_ERR_DELETE,MED_ERR_LINK,_pathpari);
ret = H5Gmove(fid, _pathparf, _pathpari );
EXIT_IF(ret < 0,"Renommage du group de paramètres scalaires",_pathparf);
}
/* MAJ des localisations */
_nloc = MEDnLocalization(fid);
/* ISCRUTE(_nloc); */
if (_nloc > 0)
fprintf(stdout," >>> Normalisation des localisations des points d'intégration\n");
for (i=0 ; i < _nloc ; i++ ) {
/* SSCRUTE(_pathloc); */
MED_ERR_EXIT_IF (_MEDobjectGetName(fid, _pathloc ,i, &_pathloc[MED_TAILLE_GAUSS]) < 0,
MED_ERR_ACCESS,MED_ERR_DATAGROUP,_pathloc);
/* SSCRUTE(_pathloc); */
MED_ERR_EXIT_IF (_MEDattributeNumRdByName(fid,_pathloc,MED_NOM_GEO,
MED_INTERNAL_INT,(unsigned char * const ) &_intgeotype) < 0,
MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
_sdim = (_intgeotype/100);
MED_ERR_EXIT_IF (_MEDattributeNumWrByName(fid,_pathloc,MED_NOM_DIM,
MED_INTERNAL_INT,(const unsigned char * const) &_sdim) < 0,
MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_DIM);
MED_ERR_EXIT_IF ( _MEDattributeStringWrByName(fid,_pathloc,MED_NOM_INM,MED_NAME_SIZE,"") < 0,
MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_INM);
_pathloc[MED_TAILLE_GAUSS]='\0';
}
/* MAJ des liens */
nln = MEDnLink(fid);
if (nln > 0)
fprintf(stdout," >>> Normalisation des liens\n");
for (i=1 ; i <= nln ; i++ ) {
ret = MEDlinkInfo(fid, i, nomlien, &nval);
EXIT_IF(ret,"Erreur a la demande d'information sur le lien",NULL);
/* printf("\t- Lien n°%i de nom |%s| et de taille "IFORMAT"\n",i,nomlien,nval); */
lien = (char *) malloc((nval+1)*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
ret = MEDlinkRd(fid, nomlien, lien );
EXIT_IF(ret,"Erreur a la lecture du lien : ",nomlien);
MAJ_version_num(fid,3,0,8);
ret = MED30linkWr(fid,nomlien,lien);
EXIT_IF(ret,"Erreur a l'écrtiure du lien : ",nomlien);
MAJ_version_num(fid,2,3,6);
lien[nval] = '\0';
/* printf("\t\t|%s|\n\n",lien); */
free(lien);
}
/* combien de champs dans le fichier */
ncha = MEDnField(fid);
EXIT_IF(ncha < 0,"lors de la lecture du nombre de champs",NULL);
/* MAJ des champs */
for (i =0;i<ncha;i++) {
lret = 0;
/* Lecture du nombre de composantes */
ncomp = MEDfieldnComponent(fid,i+1);
if (ncomp < 0) {
MESSAGE("Erreur à la lecture du nombre de composantes : "); ISCRUTE(ncomp);
exit(1);
}
/* Lecture du type du champ, des noms des composantes et du nom de l'unité*/
comp = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
EXIT_IF(comp == NULL,NULL,NULL);
unit = (char*) malloc(ncomp*MED_SNAME_SIZE+1);
EXIT_IF(unit == NULL,NULL,NULL);
/* ret = MED231champInfoEtRen(fid,i+1,nomcha,&typcha,comp,unit,ncomp); */
ret = MEDfieldInfo(fid,i+1,nomcha,_meshname,&_local,&typcha,comp,unit,_dtunit,&_ncstp);
MED_ERR_EXIT_IF(ret,MED_ERR_ACCESS,MED_ERR_FIELD,nomcha);
/* creation du champ destination */
MAJ_version_num(fid,3,0,8);
EXIT_IF( H5Gmove(fid, _pathi, _pathtmp ) < 0,"Switch to ",_pathtmp);
_datasetexist=H5Lexists( fid, _pathf, H5P_DEFAULT );
if (_datasetexist ) { EXIT_IF( (H5Gmove(fid, _pathf, _pathi ) < 0) ,"Switch to ",_pathi); }
MED_ERR_EXIT_IF( MEDfieldCr(fid,nomcha,typcha,ncomp,comp,unit,_dtunit,_meshname ) < 0,
MED_ERR_CREATE,MED_ERR_FIELD,_pathf);
EXIT_IF( H5Gmove(fid, _pathi , _pathf ) < 0,"Switch to ",_pathf);
EXIT_IF( H5Gmove(fid, _pathtmp, _pathi ) < 0,"Switch to ",_pathi);
MAJ_version_num(fid,2,3,6);
free(comp);
free(unit);
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_NODE,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux noeuds "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_CELL,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux mailles "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_DESCENDING_FACE,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux faces "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_DESCENDING_EDGE,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux aretes "); exit(1);
}
lret = MAJ_236_300_fieldOnEntity( fid, nomcha, _meshname, typcha, ncomp, MED_NODE_ELEMENT,_ncstp, _pathi, _pathf);
if (lret != 0) {
MESSAGE("Erreur à la lecture des champs aux aretes "); exit(1);
}
}
_datasetexist=H5Lexists( fid, _pathf, H5P_DEFAULT );
if (_datasetexist ) {
EXIT_IF( (H5Ldelete(fid,_pathi, H5P_DEFAULT) < 0) ,"Delete ",_pathi);
EXIT_IF( (H5Gmove(fid, _pathf, _pathi ) < 0) ,"Switch to ",_pathf);
}
}
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
_MEDmeshnEntity236(int dummy, ...)
{
med_int _ret=-1,_n=0,_tmpn=0;
med_size _nn =0;
med_data_type _meddatatype;
med_int _nfaces=0;
char _meshpath[MED_TAILLE_MAA+MED_TAILLE_NOM+1]=MED_MAA;
med_idt _meshid=0,_datagroup1=0;
char _datagroupname1[MED_TAILLE_NOM_ENTITE+1]="";
med_err _err =0;
med_bool _datagroupexist=MED_FALSE;
med_bool _isasoftlink =MED_FALSE;
int _cmodeit=0, _ncmode=1;
med_connectivite _cmode[2] = { MED_NO_CMODE, MED_NO_CMODE };
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_meddatatype=meddatatype;
if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
_cmode[0]= (med_connectivite) cmode;
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) goto SORTIE;
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
strcat(_meshpath,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);goto ERROR;
}
if( _MEDdatagroupExist(_meshid,MED_NOM_NOE,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_NOE);goto ERROR;
}
if ( _datagroupexist ) _nn++;
if( _MEDdatagroupExist(_meshid,MED_NOM_MAI,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_MAI);goto ERROR;
}
if ( _datagroupexist ) _nn++;
if( _MEDdatagroupExist(_meshid,MED_NOM_FAC,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_FAC);goto ERROR;
}
if ( _datagroupexist ) _nn++;
if( _MEDdatagroupExist(_meshid,MED_NOM_ARE,&_datagroupexist,&_isasoftlink) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatagroupExist");
SSCRUTE(MED_NOM_ARE);goto ERROR;
}
if ( _datagroupexist ) _nn++;
/* En 2.3.6 les familles, les équivalences ... sont stockées dans le groupe <meshname>*/
/* _err=_MEDnObjects(_meshid,".",&_nn); */
/* if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) { */
/* MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_meshid); */
/* goto ERROR; */
/* } */
_n = _nn;
goto SORTIE;
}
if ( geotype == MED_GEO_ALL ) {
strcat(_meshpath,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);goto ERROR;
}
if (_MEDgetEntityTypeName(_datagroupname1,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);goto ERROR;
}
if ((_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0) {
_n=0;_datagroup1=0;
goto SORTIE;
}
_err=_MEDnObjects(_datagroup1,".",&_nn);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
/* SSCRUTE(_datagroupname1);ISCRUTE_long(_nn); */
if ( ( entitytype == MED_NODE ) && (_nn > 0) ) _nn=1;
/* SSCRUTE(_datagroupname1);ISCRUTE_long(_nn); */
_n = _nn;
goto SORTIE;
}
switch( meddatatype )
{
case MED_GLOBAL_NUMBER:
case MED_NAME:
case MED_NUMBER:
case MED_FAMILY_NUMBER:
switch (entitytype) {
case MED_NODE:
/*Pour connaître le nombre d'entités des attributs optionnels,
on se base sur le tableau de coordonnées */
/* _meddatatype = MED_COORDINATE; */
break;
case MED_CELL:
case MED_DESCENDING_FACE:
case MED_DESCENDING_EDGE:
/*Pour connaître le nombre d'entités des attributs optionnels,
on se base sur le tableau de connectivité */
/* _meddatatype = MED_CONNECTIVITY; */
/*
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et le cmode non
* positionné.
* Cette Information est necessaire pour construire le nom du datatset.
*/
if ( _cmode[0] == MED_NO_CMODE ) {
_ncmode =2;_cmode[0]=MED_NOD;_cmode[1]=MED_DESC;
}
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);goto ERROR;
}
goto CALL_NENT;
case MED_COORDINATE: /*Par extension au CONNECTIVITY mais ne devrait pas être utilisé.*/
case MED_CONNECTIVITY:
if ( geotype == MED_POLYGON2 ) {_n=0; break;}
if ( geotype == MED_POLYGON ) {
if ( MEDpolygoneInfo( fid,(char *)meshname, (med_entite_maillage) entitytype, (med_connectivite) _cmode[0],
&_n) < 0) {
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDpolygoneInfo");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
_n=0;
}
break;
}
if ( geotype == MED_POLYHEDRON ) {
if ( MEDpolyedreInfo(fid,(char *) meshname, (med_connectivite) _cmode[0]
,&_nfaces,&_n) < 0) {
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDpolyedreInfo");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
_n=0;
}
break;
}
goto CALL_NENT;
case MED_INDEX_FACE:
if ( geotype == MED_POLYHEDRON ) {
_meddatatype = MED_CONNECTIVITY;
_n=1 ;
goto CALL_NENT;
/* if ( (_n = MEDnEntMaa(fid,meshname,(med_table) MED_CONNECTIVITY, (med_entite_maillage) MED_CELL, */
/* (med_geometrie_element) MED_POLYHEDRON, (med_connectivite) MED_NOD)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDnEntMaa");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
/* } */
_n+=1;
break;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);
goto ERROR;
}
case MED_INDEX_NODE:
if ( geotype == MED_POLYHEDRON ) {
if ( MEDpolyedreInfo(fid,(char *) meshname, (med_connectivite) _cmode[0],&_nfaces, &_n) < 0) {
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDpolyedreInfo");SSCRUTE(meshname); */
/* ISCRUTE(meddatatype);ISCRUTE(entitytype);ISCRUTE(geotype);goto ERROR; */
_nfaces=0;
}
_n=_nfaces;
break;
} else
if ( (geotype == MED_POLYGON) || (geotype == MED_POLYGON2) ) {
_meddatatype = MED_CONNECTIVITY;
_n = 1;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);goto ERROR;
}
case MED_COORDINATE_AXIS1:
case MED_COORDINATE_AXIS2:
case MED_COORDINATE_AXIS3:
CALL_NENT:
for (_cmodeit=0; _cmodeit < _ncmode; ++_cmodeit)
if ( (_tmpn = MEDnEntMaa( fid, (char *) meshname,
(med_table) _meddatatype,
(med_entite_maillage) entitytype,
(med_geometrie_element) geotype,
(med_connectivite) _cmode[_cmodeit]) ) > 0 )
break;
if ( _tmpn < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDnEntMaa");SSCRUTE(meshname);
ISCRUTE_int(_meddatatype);ISCRUTE_int(entitytype);ISCRUTE_int(geotype);goto ERROR;
}
_n+=_tmpn;
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_MEDDATATYPE,MED_ERR_VALUE_MSG);
ISCRUTE_int(meddatatype);goto ERROR;
}
SORTIE:
*transformation = MED_FALSE;
/*TODO : 3.0.1 : Tester la présence d'autres datasets
que les coord/conn/index pour positionner chgt TRUE uniquement
dans ce cas de figure.*/
*changement = MED_TRUE;
*profilesize = 0;
profilename[0] = '\0';
_ret = _n;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
*fret = _ret;
va_end(params);
return;
}
void
_MEDfield23ComputingStepMeshInfo236(int dummy,...)
{
med_err _ret=-1,_err=0;
med_size _num,_nmesh=0;
med_idt _datagroup1=0,_meshgid=0,_linkgid=0;
char _datagroupname1[2*MED_MAX_PARA+1] ="";
char _ent_geo [2*MED_TAILLE_NOM_ENTITE+2]="";
char _path [(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+
(2*MED_TAILLE_NOM_ENTITE+1)+1+(2*MED_MAX_PARA)+1]=MED_CHA;
char _meshpath [MED_TAILLE_MAA+MED_TAILLE_NOM+1]=MED_MAA;
char _linkpath [MED_TAILLE_LIENS+MED_TAILLE_NOM+1]=MED_LIENS;
med_size _ncpst=0;
med_bool _checkmultiplemesh=MED_TRUE, _multiplemesh =MED_FALSE;
med_bool _checkmeshname =MED_TRUE, _samedefaultmeshname=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, int , , csit );
MED_VARGS_DECL(, med_int *, const , numdt );
MED_VARGS_DECL(, med_int *, const , numit );
MED_VARGS_DECL(, med_float *, const , dt );
MED_VARGS_DECL(, med_int *, const , nmesh );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_int *, const , meshnumdt );
MED_VARGS_DECL(, med_int *, const , meshnumit );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, int , , csit );
MED_VARGS_DEF(, med_int *, const , numdt );
MED_VARGS_DEF(, med_int *, const , numit );
MED_VARGS_DEF(, med_float *, const , dt );
MED_VARGS_DEF(, med_int *, const , nmesh );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_int *, const , meshnumdt );
MED_VARGS_DEF(, med_int *, const , meshnumit );
MED_VARGS_DEF(, med_err * ,, fret );
_num=csit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On construit le nom du datagroup
*/
strcat(_path,fieldname);
/* if ( _MEDfieldComputingStepCheck236(fid, fieldname, */
/* &_ncpst, */
/* _checkmultiplemesh, &_multiplemesh, */
/* _checkmeshname, &_samedefaultmeshname) < 0) { */
/* MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FIELD,fieldname); */
/* goto ERROR; */
/* } */
/*
* On suppose que le modèle 2.3.6 est respecté :
* Il y a les mêmes séquences de calcul pour tous les couples
* (typent,typegeo). Autrement dit selon l'utilisation de l'API 2.3.6 :
* A chaque séquence de calcul, on utilise le même ensemble de (typent,typegeo).
* En conséquence si l'on fixe le (typeent,typegeo) les séquences
* de calcul que l'on va trouver seront représentatives de celles
* présentent dans tous les (typent,typegeo) utilisés.
*/
if ( _MEDobjectGetName(fid, _path ,0, _ent_geo) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); SSCRUTE(_ent_geo); goto ERROR;
}
strcat(_path,"/");
strcat(_path,_ent_geo);
if ( _MEDobjectGetName(fid, _path ,_num, _datagroupname1) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); SSCRUTE(_ent_geo); goto ERROR;
}
strcat(_path,"/");
strcat(_path,_datagroupname1);
if ((_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Lecture des attributs
*/
if (_MEDattrEntierLire(_datagroup1,MED_NOM_NDT,(med_int*) numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
SSCRUTE(_path);ISCRUTE(*numdt);goto ERROR;
}
if (_MEDattrFloatLire(_datagroup1,MED_NOM_PDT,(med_float*) dt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_PDT);
SSCRUTE(_path);RSCRUTE(*dt);goto ERROR;
}
if (_MEDattrEntierLire(_datagroup1,MED_NOM_NOR,(med_int*) numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
SSCRUTE(_path);ISCRUTE(*numit);goto ERROR;
}
if (_MEDattrStringLire(_datagroup1,MED_NOM_MAI,MED_TAILLE_NOM,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_MAI);
SSCRUTE(_path);SSCRUTE(meshname);goto ERROR;
}
/* Nombre de maillages
* La gestion d'une incohérence sur le nombre de séquences de calcul par couple (entitytype,geotype)
* se fait à partir des appels :
* MEDfieldnProfile,MEDfieldnValue*
* La vérification complémentaire que l'ensemble des maillages utilisés sont les mêmes pour toutes les séquences
* de calcul identiques est effectué dans MEDfield23nValue
*/
if ( (_err=_MEDnObjects(_datagroup1,".",&_nmesh)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
*nmesh = (med_int) _nmesh;
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
*meshnumdt=MED_NO_DT;
*meshnumit=MED_NO_IT;
_ret = 0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_datagroup1);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
med_err getFieldsOn(med_idt fid, char * nomcha, med_type_champ typcha, med_int ncomp,
med_entite_maillage entite, med_mode_switch stockage) {
int j,k,l,m,n,nb_geo;
med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,*vale=NULL,nval;
med_int numdt=0,numo=0,lnsize,nbrefmaa;
med_float *valr=NULL,dt=0.0;
med_err ret=0;
med_booleen local;
char pflname [MED_TAILLE_NOM+1]="";
char locname [MED_TAILLE_NOM+1]="";
char * lien = NULL;
char maa_ass [MED_TAILLE_NOM+1]="";
char dt_unit [MED_TAILLE_PNOM+1]="";
med_geometrie_element * type_geo;
med_geometrie_element typ_noeud[1] = { MED_NONE };
med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE+2] = {MED_POINT1, MED_SEG2, MED_SEG3, MED_TRIA3,
MED_QUAD4, MED_TRIA6,MED_QUAD8, MED_TETRA4,
MED_PYRA5, MED_PENTA6, MED_HEXA8, MED_TETRA10,
MED_PYRA13, MED_PENTA15, MED_HEXA20,
MED_POLYGONE, MED_POLYEDRE};
med_geometrie_element typfac[MED_NBR_GEOMETRIE_FACE+1] = {MED_TRIA3,MED_TRIA6,
MED_QUAD4,MED_QUAD8,
MED_POLYGONE};
med_geometrie_element typare[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};
char ** AFF;
switch (entite) {
case MED_NOEUD :
type_geo = typ_noeud;
nb_geo = 1;
AFF = MED_GEOMETRIE_NOEUD_AFF;
break;
case MED_MAILLE :
type_geo = typmai;
nb_geo = MED_NBR_GEOMETRIE_MAILLE+2;
AFF = MED_GEOMETRIE_MAILLE_AFF;
break;
case MED_FACE :
type_geo = typfac;
nb_geo = MED_NBR_GEOMETRIE_FACE+1;
AFF = MED_GEOMETRIE_FACE_AFF;
break;
case MED_ARETE :
type_geo = typare;
nb_geo = MED_NBR_GEOMETRIE_ARETE;
AFF = MED_GEOMETRIE_ARETE_AFF;
break;
}
for (k=0;k<nb_geo;k++) {
/* Combien de (PDT,NOR) a lire */
nbpdtnor = MEDnPasdetemps(fid,nomcha,entite,type_geo[k]);
if (nbpdtnor < 1 ) continue;
for (j=0;j<nbpdtnor;j++) {
if ( MEDpasdetempsInfo(fid,nomcha,entite,type_geo[k],
j+1, &ngauss, &numdt, &numo, dt_unit,
&dt, maa_ass, &local, &nbrefmaa) <0) {
MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
ISCRUTE(numdt); ISCRUTE(numo);
ret = -1; continue;
};
printf("\n +Pas de Temps n.%i (%f) [%s], n. d'ordre %i, avec %i pts de gauss sur le maillage par defaut.\n",numdt,dt,dt_unit,numo,ngauss);
printf("\tLe maillage par defaut est : |%s|, sur un total de : %i maillages associes\n",
maa_ass, nbrefmaa);
/* Le maillage reference est-il porte par un autre fichier */
if ( !local ) {
if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) {
MESSAGE("Erreur a la lecture de la taille du lien : ");
SSCRUTE(maa_ass);
ret = -1;
} else {
lien = malloc(lnsize*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
if ( MEDlienLire(fid, lien, maa_ass) < 0 ) {
MESSAGE("Erreur a la lecture du lien : ");
SSCRUTE(maa_ass);SSCRUTE(lien);
ret = -1;
} else {
printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
}
free(lien);
}
}
/* Combien de maillages lies aux (nomcha,ent,geo,numdt,numo) */
/* Notons que cette information est egalement disponible a partir de MEDpasdetempsInfo */
if ( (nbrefmaa = MEDnChampRef(fid,nomcha,entite,type_geo[k],numdt,numo) ) < 0 ) {
MESSAGE("Erreur a la demande du nombre de maillages references par le champ : ");
SSCRUTE(nomcha); ISCRUTE(numdt); ISCRUTE(numo);
ret = -1; continue;
};
for (l=0;l<nbrefmaa;l++) {
if ( MEDchampRefInfo(fid,nomcha,entite,type_geo[k],
l+1,numdt, numo, maa_ass, &local, &ngauss) <0 ) {
MESSAGE("Erreur a la demande d'information sur le maillage utilise par le champ n° : ");
SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
ISCRUTE(l+1);ISCRUTE(numdt); ISCRUTE(numo);SSCRUTE(maa_ass);
ret = -1; continue;
};
/* Prend en compte le nbre de pt de gauss automatiquement */
if ((nval = MEDnVal(fid,nomcha,entite,type_geo[k],numdt,numo,maa_ass,USER_MODE)) <= 0) {
MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);ISCRUTE(USER_MODE);
ret = -1; continue;
};
printf("\t- Il y a %d valeurs en mode %i. Chaque entite %s\
de type geometrique %s associes au maillage |%s| a %i pts de gauss \n",
nval,USER_MODE,MED_ENTITE_MAILLAGE_AFF[(int)entite],AFF[k],maa_ass,ngauss);
/* Le maillage reference est-il porte par un autre fichier */
if ( !local ) {
if ( (lnsize=MEDnValLien(fid,maa_ass) ) < 0 ) {
MESSAGE("Erreur a la lecture de la taille du lien : ");
SSCRUTE(maa_ass);
ret = -1;
} else {
lien = malloc(lnsize*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
if ( MEDlienLire(fid, lien, maa_ass) < 0 ) {
MESSAGE("Erreur a la lecture du lien : ");
SSCRUTE(maa_ass);SSCRUTE(lien);
ret = -1;
} else {
printf("\tLe maillage |%s| est porte par un fichier distant |%s|\n",maa_ass,lien);
}
free(lien);
}
}
/*Lecture des valeurs du champ */
if (typcha == MED_FLOAT64) {
valr = (med_float*) calloc(ncomp*nval,sizeof(med_float));
EXIT_IF(valr == NULL,NULL,NULL);
if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)valr,stockage,MED_ALL,locname,
pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
ret = -1;
};
} else {
vale = (med_int*) calloc(ncomp*nval,sizeof(med_int));
EXIT_IF(vale == NULL,NULL,NULL);
if ( MEDchampLire(fid,maa_ass,nomcha,(unsigned char*)vale,stockage,MED_ALL,locname,
pflname,USER_MODE,entite,type_geo[k],numdt,numo) < 0 ) {
MESSAGE("Erreur a la lecture des valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE(entite);ISCRUTE(type_geo[k]);
ISCRUTE(numdt);ISCRUTE(numo);SSCRUTE(maa_ass);
ret = -1;
};
}
if ( ngauss > 1 )
printf("\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
switch (stockage) {
case MED_FULL_INTERLACE :
printf("\t- Valeurs :\n\t");
for (m=0;m<nval/ngauss;m++) {
printf("|");
for (n=0;n<ngauss*ncomp;n++)
if (typcha == MED_FLOAT64)
printf(" %f ",*(valr+(m*ngauss*ncomp)+n));
else
printf(" %d ",*(vale+(m*ngauss*ncomp)+n));
}
break;
/*Affichage en fonction du profil à traiter*/
case MED_NO_INTERLACE :
printf("\t- Valeurs :\n\t");
for (m=0;m<ncomp;m++) {
printf("|");
for (n=0;n<nval;n++)
if (typcha == MED_FLOAT64)
printf(" %f ",*(valr+(m*nval)+n));
else
printf(" %d ",*(vale+(m*nval)+n));
}
break;
}
printf("|\n");
if (typcha == MED_FLOAT64) {
if ( valr ) {free(valr);valr = NULL;}}
else
if (vale) { free(vale);vale = NULL; }
/*Lecture du profil associe */
if (strcmp(pflname,MED_NOPFL) == 0 )
printf("\t- Profil : MED_NOPFL\n");
else {
if ( (pflsize = MEDnValProfil(fid,pflname)) <0 ) {
MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
SSCRUTE(pflname);
ret = -1; continue;
}
printf("\t- Profil : |%s| de taille %i\n",pflname,pflsize);
pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
EXIT_IF(pflval == NULL,NULL,NULL);
if ( MEDprofilLire(fid,pflval,pflname) <0) {
MESSAGE("Erreur a la lecture des valeurs du profil : ");
SSCRUTE(pflname);
ret = -1;
}
printf("\t");
for (m=0;m<pflsize;m++) printf(" %i ",*(pflval+m));
printf("\n");
free(pflval);
}
}
}
} /* fin for sur les mailles*/
return ret;
}
int main (int argc, char **argv)
{
med_idt fid;
const char filename[] = "Unittest_MEDparameter_1.med";
const char comment[] = "Parameters unit tests";
const char p1name[] = "FLOAT_PARAMETER";
const char p2name[] = "INT_PARAMETER_1";
const char p3name[] = "INT_PARAMETER_2";
const med_parameter_type p1type = MED_FLOAT64;
const med_parameter_type p2type = MED_INT;
const med_parameter_type p3type = MED_INT;
const char p1description[] = "PARAMETER 1 DESCRIPTION";
const char p2description[] = "PARAMETER 2 DESCRIPTION";
const char p3description[] = "PARAMETER 3 DESCRIPTION";
const char dtunit1[] = "DT UNIT P1";
const char dtunit2[] = "DT UNIT P2";
const char dtunit3[] = "DT UNIT P3";
med_int np;
char nameToRead[MED_NAME_SIZE+1];
char descriptionToRead[MED_COMMENT_SIZE+1];
med_parameter_type typeToRead;
char dtunitToRead[MED_SNAME_SIZE+1];
med_int nstepToRead;
int i,j;
med_float p1v1 = 6.98;
med_float p1v2 = 19.07;
med_float p1v3 = 78.0;
med_int p1numdt1 = MED_NO_DT;
med_int p1numdt2 = 1;
med_int p1numdt3 = 1;
med_int p1numit1 = MED_NO_IT;
med_int p1numit2 = 3;
med_int p1numit3 = 2;
med_float p1dt1 = 0.0;
med_float p1dt2 = 0.1;
med_float p1dt3 = 5.5;
const med_int p1ncpst = 3;
med_int p2v1 = 5;
med_int p2v2 = 6;
med_int p2numit1 = MED_NO_IT;
med_int p2numdt1 = MED_NO_DT;
med_float p2dt1 = 0.0;
const med_int p2ncpst = 1;
med_int p3v1 = 77;
med_int p3v2 = 89;
med_int p3numdt1 = 1;
med_int p3numit1 = 1;
med_float p3dt1 = 18.9;
med_int p3numdt2 = MED_NO_DT;
med_int p3numit2 = MED_NO_IT;
med_float p3dt2 = 0.0;
const med_int p3ncpst = 2;
med_int numdtToRead;
med_int numitToRead;
med_float dtToRead;
med_float fvalueToRead;
med_int ivalueToRead;
/* file creation */
fid = MEDfileOpen(filename,MED_ACC_CREAT);
if (fid < 0) {
MESSAGE("ERROR : file creation ...");
SSCRUTE(filename);
return -1;
}
if (MEDfileCommentWr(fid,comment) < 0) {
MESSAGE("ERROR : write comment ...");
SSCRUTE(comment);
return -1;
}
/* create a MED_FLOAT64 parameter */
if (MEDparameterCr(fid, p1name, p1type, p1description, dtunit1) < 0) {
MESSAGE("ERROR : parameter p1 creation ...");
SSCRUTE(p1name);
return -1;
}
if (MEDparameterValueWr(fid, p1name, p1numdt1, p1numit1, p1dt1, (unsigned char*) &p1v1) < 0) {
MESSAGE("ERROR : write p1v1 ...");
SSCRUTE(p1name);
return -1;
}
if (MEDparameterValueWr(fid, p1name, p1numdt2, p1numit2, p1dt2, (unsigned char*) &p1v2) < 0) {
MESSAGE("ERROR : write p1v2 ...");
SSCRUTE(p1name);
return -1;
}
if (MEDparameterValueWr(fid, p1name, p1numdt3, p1numit3, p1dt3, (unsigned char*) &p1v3) < 0) {
MESSAGE("ERROR : write p1v3 ...");
SSCRUTE(p1name);
return -1;
}
/* create a MED_INT parameter with different values */
if (MEDparameterCr(fid, p2name, p2type, p2description, dtunit2) < 0) {
MESSAGE("ERROR : paramter p2 creation ...");
SSCRUTE(p2name);
return -1;
}
if (MEDparameterValueWr(fid, p2name, p2numdt1, p2numit1, p2dt1, (unsigned char*) &p2v1) < 0) {
MESSAGE("ERROR : write p2v1 ...");
SSCRUTE(p2name);
return -1;
}
if (MEDparameterValueWr(fid, p2name, p2numdt1, p2numit1, p2dt1, (unsigned char*) &p2v2) < 0) {
MESSAGE("ERROR : write p2v2 on same computation step ...");
SSCRUTE(p2name);
return -1;
}
/* create another MED_INT parameter */
if (MEDparameterCr(fid, p3name, p3type, p3description, dtunit3) < 0) {
MESSAGE("ERROR : paramter p3 creation ...");
SSCRUTE(p3name);
return -1;
}
if (MEDparameterValueWr(fid, p3name, p3numdt1, p3numit1, p3dt1, (unsigned char*) &p3v1) < 0) {
MESSAGE("ERROR : write p3v1 ...");
SSCRUTE(p3name);
return -1;
}
if (MEDparameterValueWr(fid, p3name, p3numdt2, p3numit2, p3dt2, (unsigned char*) &p3v2) < 0) {
MESSAGE("ERROR : write p3v2 ...");
SSCRUTE(p3name);
return -1;
}
/* close file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : file closing ...");
return -1;
}
/* open file in READ ONLY access mode */
fid = MEDfileOpen(filename,MED_ACC_RDONLY);
if (fid < 0) {
MESSAGE("ERROR : open in READ ONLY ACCESS mode ...");
SSCRUTE(filename);
return -1;
}
/* direct access to parameters */
if (MEDparameterInfoByName(fid, p1name, &typeToRead, descriptionToRead,
dtunitToRead, &nstepToRead) < 0) {
MESSAGE("ERROR : read information for parameter p1 ...");
SSCRUTE(p1name);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if ((typeToRead != p1type) || strcmp(descriptionToRead, p1description) ||
strcmp(dtunitToRead,dtunit1) || (nstepToRead != p1ncpst)) {
MESSAGE("ERROR : read information for parameter p1 : attributes ...");
SSCRUTE(p1name);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if (MEDparameterInfoByName(fid, p2name, &typeToRead, descriptionToRead,
dtunitToRead, &nstepToRead) < 0) {
MESSAGE("ERROR : read information for parameter p2 ...");
SSCRUTE(p2name);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if ((typeToRead != p2type) || strcmp(descriptionToRead, p2description) ||
strcmp(dtunitToRead,dtunit2) || (nstepToRead != p2ncpst)) {
MESSAGE("ERROR : read information for parameter p2 : attributes ...");
SSCRUTE(p2name);
ISCRUTE(typeToRead); ISCRUTE(p2type);
SSCRUTE(descriptionToRead); SSCRUTE(p2description);
SSCRUTE(dtunitToRead); SSCRUTE(dtunit2);
ISCRUTE(nstepToRead); ISCRUTE(p2ncpst);
return -1;
}
if (MEDparameterInfoByName(fid, p3name, &typeToRead, descriptionToRead,
dtunitToRead, &nstepToRead) < 0) {
MESSAGE("ERROR : read information for parameter p3 ...");
SSCRUTE(p3name);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if ((typeToRead != p3type) || strcmp(descriptionToRead, p3description) ||
strcmp(dtunitToRead,dtunit3) || (nstepToRead != p3ncpst)) {
MESSAGE("ERROR : read information for parameter p2 : attributes ...");
SSCRUTE(p3name);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
/* how many parameter(s) in the file ? */
if ((np = MEDnParameter(fid)) < 0) {
MESSAGE("ERROR : read number of paremeter ...");
ISCRUTE(np);
return -1;
}
if (np != 3) {
MESSAGE("The number of parameter is 3 !");
ISCRUTE(np);
return -1;
}
/* TODO : A SUPPRIMER */
np=0;
/* read informations for each parameter */
for (i=0;i<np;i++) {
if (MEDparameterInfo(fid, i+1, nameToRead, &typeToRead, descriptionToRead,
dtunitToRead, &nstepToRead) < 0) {
MESSAGE("ERROR : read information for parameter p3 ...");
SSCRUTE(nameToRead);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if (i == 0)
if (strcmp(nameToRead, p1name) || (typeToRead != p1type) ||
strcmp(descriptionToRead, p1description) || strcmp(dtunitToRead,dtunit1)
|| (nstepToRead != p1ncpst)) {
MESSAGE("ERROR : read information for parameter p1 : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if (i == 1)
if ( strcmp(nameToRead, p2name) || (typeToRead != p2type) ||
strcmp(descriptionToRead, p2description) || strcmp(dtunitToRead,dtunit2)
|| (nstepToRead != p2ncpst)) {
MESSAGE("ERROR : read information for parameter p2 : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
if (i == 3)
if (strcmp(nameToRead,p3name) || (typeToRead != p3type) ||
strcmp(descriptionToRead, p3description) || strcmp(dtunitToRead,dtunit3) ||
(nstepToRead != p3ncpst)) {
MESSAGE("ERROR : read information for parameter p2 : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(typeToRead);
SSCRUTE(descriptionToRead);
SSCRUTE(dtunitToRead);
ISCRUTE(nstepToRead);
return -1;
}
/* read informations about each computation step
and then read value for each parameter */
for (j=0; j<nstepToRead; j++) {
if (MEDparameterComputationStepInfo(fid, nameToRead, j+1,
&numdtToRead, &numitToRead, &dtToRead) < 0) {
MESSAGE("ERROR : read information about computation step ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead);
ISCRUTE(numitToRead);
return -1;
}
if (typeToRead == MED_FLOAT64)
if (MEDparameterValueRd(fid, nameToRead, numdtToRead, numitToRead,
(unsigned char *) &fvalueToRead) < 0) {
MESSAGE("ERROR : read parameter value ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead);
ISCRUTE(numitToRead);
return -1;
}
if (typeToRead != MED_FLOAT64)
if (MEDparameterValueRd(fid, nameToRead, numdtToRead, numitToRead,
(unsigned char *) &ivalueToRead) < 0) {
MESSAGE("ERROR : read parameter value ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead);
ISCRUTE(numitToRead);
ISCRUTE(ivalueToRead);
return -1;
}
/* data verifications */
if ((i==0) && (j==0))
if ((numdtToRead != p1numdt1) || (numitToRead != p1numit1) || (dtToRead != p1dt1) ||
(fvalueToRead != p1v1)) {
MESSAGE("ERROR : false informations for computation step : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead); ISCRUTE(p1numdt1);
ISCRUTE(numitToRead); ISCRUTE(p1numit1);
return -1;
}
if ((i==0) && (j==1))
if ((numdtToRead != p1numdt3) || (numitToRead != p1numit3) || (dtToRead != p1dt3) ||
(fvalueToRead != p1v3)) {
MESSAGE("ERROR : false informations for computation step : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead); ISCRUTE(p1numdt3);
ISCRUTE(numitToRead); ISCRUTE(p1numit3);
return -1;
}
if ((i==0) && (j==2))
if ((numdtToRead != p1numdt2) || (numitToRead != p1numit2) || (dtToRead != p1dt2) ||
(fvalueToRead != p1v2)) {
MESSAGE("ERROR : false informations for computation step : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead); ISCRUTE(p1numdt2);
ISCRUTE(numitToRead); ISCRUTE(p1numit2);
return -1;
}
if (i==1)
if ((numdtToRead != p2numdt1) || (numitToRead != p2numit1) || (dtToRead != p2dt1) ||
(ivalueToRead != p2v2)) {
MESSAGE("ERROR : false informations for computation step : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead); ISCRUTE(p2numdt1);
ISCRUTE(numitToRead); ISCRUTE(p2numit1);
return -1;
}
if ((i == 2) && (j == 0))
if ((numdtToRead != p3numdt2) || (numitToRead != p3numit2) || (dtToRead != p3dt2) ||
(ivalueToRead != p3v2)) {
MESSAGE("ERROR : false informations for computation step : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead); ISCRUTE(p3numdt2);
ISCRUTE(numitToRead); ISCRUTE(p3numit2);
return -1;
}
if ((i == 2) && (j == 1))
if ((numdtToRead != p3numdt1) || (numitToRead != p3numit1) || (dtToRead != p3dt1) ||
(ivalueToRead != p3v1)) {
MESSAGE("ERROR : false informations for computation step : attributes ...");
SSCRUTE(nameToRead);
ISCRUTE(j);
ISCRUTE(numdtToRead); ISCRUTE(p3numdt1);
ISCRUTE(numitToRead); ISCRUTE(p3numit1);
return -1;
}
}
}
/* close file */
if (MEDfileClose(fid) < 0) {
MESSAGE("ERROR : close file ...");
return -1;
}
return 0;
}
med_err
MEDfamLire(med_idt fid,char *maa, med_int *fam, med_int n,
med_entite_maillage type_ent,med_geometrie_element type_geo)
{
med_idt root;
med_idt maaid = 0;
med_idt entid = 0;
med_idt geoid = 0;
med_err ret = -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];
med_int i;
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) {
MESSAGE("Impossible d'acceder au maillage");
SSCRUTE(chemin);
goto ERREUR;
}
/*
* On met a jour le nom du Data Group representant
* le type des entites
*/
if (_MEDnomEntite(nom_ent,_type_ent) < 0) {
MESSAGE("L'entité demandée n'est pas une entité <med_entite_maillage> : ");
SSCRUTE(nom_ent);
ISCRUTE(_type_ent);
goto ERREUR;
}
/*
* Si le "Data Group" des entites n'existe pas => erreur
*/
if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0) {
MESSAGE("Impossible d'accéder au groupe des entités : ");
SSCRUTE(nom_ent);
ISCRUTE(_type_ent);
goto ERREUR;
}
/*
* Pour les mailles, les faces et le aretes, on cree
* si le "Data Group" du type geometrique => erreur
*/
if ((_type_ent==MED_MAILLE)||(_type_ent==MED_FACE)||(_type_ent==MED_ARETE))
{
if (_MEDnomGeometrie30(nom_geo,type_geo) < 0) {
MESSAGE("L'entité demandée n'est pas un élément <med_geometrie_element> : ");
SSCRUTE(nom_geo);
ISCRUTE(type_geo);
goto ERREUR;
}
if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0) {
MESSAGE("Impossible d'accéder au groupe des éléments géométriques : ");
SSCRUTE(nom_geo);
ISCRUTE(type_geo);
goto ERREUR;
}
}
else
geoid = -1;
/*
* lecture du Data Set "FAM"
* - En cas d'erreur, pas de message car la presence des
* numeros est optionnelle dans un fichier MED (à partir de la V2.2)
* Dans ce cas de figure, on considère que tous les numéros sont à 0
*/
if (geoid == -1)
root = entid;
else
root = geoid;
#if defined(HAVE_F77INT64)
if (_MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT64,
MED_NO_INTERLACE,1,MED_ALL,
MED_NOPF,MED_NO_PFLMOD,MED_PFL_NON_COMPACT,0,MED_NOPG,0,
(unsigned char *)fam) < 0)
for (i=0; i<n; i++)
*(fam+i) = 0;
#else
if (_MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT32,
MED_NO_INTERLACE,1,MED_ALL,
MED_NOPF,MED_NO_PFLMOD,MED_PFL_NON_COMPACT,0,MED_NOPG,0,
(unsigned char *)fam) < 0)
for (i=0; i<n; i++)
*(fam+i) = 0;
#endif
/*
* Tout s'est bien passé si on est parvenu jusqu'ici
*/
ret = 0;
/*
* On ferme tout
*/
ERREUR:
if (geoid > 0)
if (_MEDdatagroupFermer(geoid) < 0)
return -1;
if (entid > 0)
if (_MEDdatagroupFermer(entid) < 0)
return -1;
if (maaid > 0)
if (_MEDdatagroupFermer(maaid) < 0)
return -1;
/* Code retour :
* - ret == 0 en cas de succès
* - ret == -1 en cas d'échec
*/
return (ret);
}
med_err
MED231champRefInfoEtRenMaa(med_idt fid,char *champ,
med_entite_maillage type_ent, med_geometrie_element type_geo,
int indice, med_int numdt, med_int numo,
char * maa, med_booleen * local, med_int *ngauss)
{
med_err ret=-1;
int num;
med_idt datagroup2=0,datagroup3=0,gid_maa=0,gid_lien=0;
char chemin[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA+1)+(MED_TAILLE_NOM)+1]="";
char chemini[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA+1)+(MED_TAILLE_NOM)+1]="";
char chemin_maa[MED_TAILLE_MAA+MED_TAILLE_NOM+1]="";
char chemin_lien[MED_TAILLE_LIENS+MED_TAILLE_NOM+1]="";
char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2]="";
char nomdatagroup2[2*MED_MAX_PARA+1]="";
char tmp1 [MED_TAILLE_NOM_ENTITE+1]="";
char maai [MED_TAILLE_NOM+1];
char maaf [MED_TAILLE_NOM+1]="";
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On construit le nom du datagroup
*/
strcpy(chemin,MED_CHA);
strcat(chemin,champ);
strcat(chemin,"/");
/*
* Si le Data Group de niveau 1 <type_ent>[.<type_geo>] n'existe pas => erreur
*/
/* modif pour la version 2.3.3 */
if (_MEDnomEntite(nomdatagroup1,type_ent) < 0)
goto ERROR;
if ((type_ent != MED_NOEUD)) {
if (_MEDnomGeometrie(tmp1,type_geo) < 0)
goto ERROR;
strcat(nomdatagroup1,".");
strcat(nomdatagroup1,tmp1);
}
strcat(chemin,nomdatagroup1);
strcat(chemin,"/");
/*
* Si le Data Group de niveau 2 <numdtt>.<numoo> n'existe pas => erreur
*/
sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
strcat(chemin,nomdatagroup2);
/*
* Modifie le nom de la première référence à un maillage
* si besoin est
*/
if ( (datagroup2 = _MEDdatagroupOuvrir(fid,chemin)) < 0 ) {
MESSAGE("Erreur à l'ouverture du datagroup : ");
SSCRUTE(chemin); goto ERROR;
}
if ( _MEDattrStringLire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maai) < 0 ) {
MESSAGE("Erreur de lecture de l'attribut MED_NOM_MAI : ");
SSCRUTE(maai); goto ERROR;
}
if ( MAJ_231_232_chaine(maai,maaf) ) {
fprintf(stdout," >>> Normalisation du nom de maillage par défaut [%s] associé au champ [%s] pour (n°dt,n°it) ("IFORMAT","IFORMAT")\n",maai,champ,numdt,numo);
ret = _MEDattrStringEcrire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maaf);
EXIT_IF(ret < 0,"Renommage du maillage en",maaf);
fprintf(stdout," >>> Normalisation du nom du maillage par défaut [%s] ... OK ... \n",maaf);
}
if (_MEDdatagroupFermer(datagroup2) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup2); goto ERROR;
}
strcat(chemin,"/");
/*
* Cherche le datagroup de niveau 3 <maa> correspondant à l'indice <num>
*/
num = indice - 1;
if (_MEDobjetIdentifier(fid,chemin,num,maa) < 0) {
MESSAGE("Impossible de trouver un groupe à l'indice spécifié : ");
SSCRUTE(chemin); ISCRUTE_int(num); goto ERROR;
};
if ( MAJ_231_232_chaine(maa,maaf) ) {
fprintf(stdout," >>> Normalisation du nom de maillage [%s] associé au champ [%s] pour (n°dt,n°it) ("IFORMAT","IFORMAT")\n",maa,champ,numdt,numo);
/* on accede au maillage */
strcpy(chemini,chemin);
strcat(chemini,maa);
strcat(chemin,maaf);
ret = H5Gmove(fid, chemini, chemin );
EXIT_IF(ret < 0,"Renommage du maillage en",maaf);
fprintf(stdout," >>> Normalisation du nom du maillage [%s] ... OK ... \n",maaf);
} else
strcat(chemin,maa);
/*
* Si le Data Group de niveau 3 <maa> n'existe pas => erreur
*/
if ((datagroup3 = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Erreur d'ouverture du datagroup lien au maillage : ");
SSCRUTE(chemin); goto ERROR;
};
/* Lire le nbre des points de GAUSS*/
if (_MEDattrEntierLire(datagroup3,MED_NOM_NGA,ngauss) < 0) {
MESSAGE("Erreur à la lecture de l'attribut MED_NOM_NGA : ");
ISCRUTE(*ngauss);goto ERROR;
};
/* Maillage local ou distant */
/* Les noms de maillages n'ayant pas encore été mis à jour
on garde l'ancien nom pour le test local/distant */
strcpy(chemin_maa,MED_MAA);
strcat(chemin_maa,maa);
/* Le maillage est il distant */
if ( (gid_maa = _MEDdatagroupOuvrir(fid,chemin_maa)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcpy(chemin_lien,MED_LIENS);
strcat(chemin_lien,maa);
if ((gid_lien = _MEDdatagroupOuvrir(fid,chemin_lien)) < 0) {
/* MESSAGE("Le maillage n'est ni local, ni distant : "); */
/* SSCRUTE(chemin_maa);SSCRUTE(chemin_lien); goto ERROR; */
*local = MED_FAUX;
}
*local = MED_FAUX;
} else
*local = MED_VRAI;
/*On retourne le nouveau nom de maillage*/
if ( strlen(maaf) ) strcpy(maa,maaf);
/*
* On ferme tout
*/
ret = 0;
ERROR:
if (datagroup3>0) if (_MEDdatagroupFermer(datagroup3) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup3); ret = -1;
}
if (gid_maa>0) if (_MEDdatagroupFermer(gid_maa) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid_maa); ret = -1;
}
if (gid_lien>0) if (_MEDdatagroupFermer(gid_lien) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
SSCRUTE(chemin_lien); ret = -1;
}
return ret;
}
void _MEDequivalenceComputingStepInfo30(int dummy, ...) {
med_err _ret=-1,_err=-1;
med_idt _eqid=0,_datagroup1=0;
int _num;
char _cstppath[MED_TAILLE_EQS+2*MED_NAME_SIZE+2+2*MED_MAX_PARA+1]=MED_EQS;
char _cstpname[2*MED_MAX_PARA+1]="";
med_size _ncorrespondence=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, char * , const , equivname );
MED_VARGS_DECL(const, int , , csit );
MED_VARGS_DECL(, med_int *, const , numdt );
MED_VARGS_DECL(, med_int *, const , numit );
MED_VARGS_DECL(, med_int *, const , nocstpncorrespondence );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, char * , const , equivname );
MED_VARGS_DEF(const, int , , csit );
MED_VARGS_DEF(, med_int *, const , numdt );
MED_VARGS_DEF(, med_int *, const , numit );
MED_VARGS_DEF(, med_int *, const , nocstpncorrespondence );
MED_VARGS_DEF(, med_err * ,, fret );
_num = csit -1;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
strcat( _cstppath, meshname);
strcat( _cstppath, "/");
strcat( _cstppath, equivname);
if ((_eqid = _MEDdatagroupOuvrir(fid,_cstppath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_cstppath);
ISCRUTE_id(_eqid);goto ERROR;
}
strcat( _cstppath, "/");
/*
* On recupere le nom de l'~tape de calcul
*/
if ( _MEDobjectGetName(fid, _cstppath ,_num, &_cstppath[strlen(_cstppath)]) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_cstppath);ISCRUTE_int(csit);
goto ERROR;
}
if ( (_datagroup1 = _MEDdatagroupOuvrir(fid,_cstppath)) < 0 ) {
MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_COMPUTINGSTEP,_cstppath);
SSCRUTE(_cstppath);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_NDT pour lecture */
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_NDT,numdt) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(_cstppath);SSCRUTE(MED_NOM_NDT);
ISCRUTE(*numdt);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_PDT pour lecture */
/* if ( _MEDattrFloatLire(_datagroup1,MED_NOM_PDT,dt) < 0) { */
/* MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG); */
/* SSCRUTE(equivname);SSCRUTE(_cstppath);SSCRUTE(MED_NOM_PDT); */
/* RSCRUTE(*dt);goto ERROR; */
/* } */
/*Cree ou ouvre l'attribut MED_NOM_NOR pour lecture */
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_NOR,numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(_cstppath);SSCRUTE(MED_NOM_NOR);
ISCRUTE(*numit); goto ERROR;
}
/*
* Nombre de tableau d'~quivalence
*/
if ((_err=_MEDnObjects(_datagroup1,".",&_ncorrespondence)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,equivname);
goto ERROR;
}
*nocstpncorrespondence = (med_int) _ncorrespondence;
_ret = 0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_cstppath);
ISCRUTE_id(_datagroup1);
}
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_eqid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDmeshnEntity30(int dummy, ...)
{
med_access_mode _MED_ACCESS_MODE;
med_int _ret=-1,_err=-1;
med_idt _meshid=0, _datagroup=0,_datagroupf=0,_datagroup1=0;
med_idt _datagroup2=0,_datagroup3=0,_datagroup4=0,_dataset=0;
char _meshpath [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
char _datagroupname1 [2*MED_MAX_PARA+1] ="";
char _datagroupname2 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname3 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname4 [MAX(MED_TAILLE_VARATR,MED_TAILLE_COOTRF)]="";
char _datasetconame [3 + 1 + 3 + 1 ] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _datasetname [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype = 0;
med_int _intsortingtype = 0;
med_int _profilearraysize = 0;
med_int _changement=0, _changement_s=0, _transformation=0;
med_bool _changement_co = MED_FALSE;
med_size _n=0;
med_int _intn=0;
med_bool _isasupportmesh = MED_FALSE;
med_bool _isasoftlink = MED_FALSE;
med_bool _datasetexist = MED_FALSE;
med_int _ntmpmeddatatype = 1;
med_data_type _tmpmeddatatype[4] = {MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE};
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _intmeshtype = 0;
med_int _meshdim = 0;
int _i = 0;
med_connectivity_mode _cmode ;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_cmode = cmode;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/*
* Ouverture du datagroup de niveau 1 <_meshpath>/<meshname>
*/
NOFINALBLANK(meshname,ERROR);
if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(_meshpath); goto ERROR;
}
/* Lecture de la dimension du maillage */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
/* Lecture du type de maillage (attribut MED_NOM_TYP) */
if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
}
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
/* Lecture de l'attribut MED_NOM_GTY */
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype= (med_grid_type) _intgridtype;
}
/*
* Ouverture du datagroup de niveau 2 <numdt>.<numit>
*/
if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
}
_sortingtype = (med_sorting_type) (_intsortingtype);
_MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
}
/*
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_CGT);goto ERROR;
}
*changement = (med_bool) _changement;
*transformation = MED_FALSE;
/*
* Gestion entitytype == MED_UNDEF_ENTITY_TYPE
*/
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) {
_n=0; goto SORTIE;
}
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
_err=_MEDnObjects(_datagroup1,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
goto SORTIE;
}
/*
* Ouverture du datagroup de niveau 3 <entitytype>
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
}
if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
*changement = (med_bool) MED_FALSE;
_n=0;_datagroup2=0;
goto SORTIE;
}
/* MAJ du changement pour le type d'entité <entitytype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup2,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
/*
* Ouverture du datagroup de niveau 4 <geotype>
*/
/* Pas Utilisation pour MED_NODE */
if ( geotype == MED_GEO_ALL ) {
_err=_MEDnObjects(_datagroup2,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname2);
goto ERROR;
}
/*Par construction du modèle, le tableau de coordonnées preexiste aux autres */
if ( ( entitytype == MED_NODE ) && (_n > 0) ) _n=1;
goto SORTIE;
}
if ( entitytype != MED_NODE ) {
/* Lecture du nom de type géométrique */
/*TODO : Remplacer les deux appels suivants par un seul gérant les geotype dynamiques et statiques*/
if ( entitytype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid, geotype,_datagroupname3) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else
if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);goto ERROR;
}
if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
_n=0;
*changement = MED_FALSE;
goto SORTIE;
}
}
if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
/* MAJ du changement pour le type géométrique d'entité <geotype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
* Prend en charge le cas d'un dataset vide écrit pour un typegeo donné (CHGT==1)
*/
if (_datagroup3) {
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
}
/*
* Lecture du flag de modification sur autre chose que MED_CONNECTIVITY,MED_COORDINATE,MED_COORDINATE_AXIS<i>
*
*/
if ( _MEDattrEntierLire(_datagroup,MED_NOM_CGS,&_changement_s) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGS);goto ERROR;
}
/* 1) Lorsque l'utilisateur interroge un <meddatatype> qui est relatif a des coordonnées (famille,....) il faut mettre
* le flag chgt à jour par rapport à des modifications potentiellement effectuées sur ces coordonnées
* <=>
* Si on interroge autre chose que MED_CONNECTIVITY,MED_COORDINATE
* et qu'un changement est présent sur MED_CONNECTIVITY,MED_COORDINATE
* le flag chgt doit être positionné à vrai
* Une demande entitype==MED_NODE && (meddatatype == MED_COORDINATE_AXIS1)||(meddatatype == MED_COORDINATE_AXIS2)
* ||(meddatatype === MED_COORDINATE_AXIS3) est assimilée à une demande concernant des coordonnées
* <=>
* Y-a-t'il une modification des datasets COO(si NOE)| NOD|DES(si !NOE)
*/
/* 2)
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et que le cmode n'a pas été
* spécifié par l'utilisateur.
* Cette Information est necessaire pour construire le nom du dataset.
*/
if ( (meddatatype != MED_CONNECTIVITY) && ( meddatatype != MED_COORDINATE )
&& (meddatatype != MED_COORDINATE_AXIS1)
&& (meddatatype != MED_COORDINATE_AXIS2)
&& (meddatatype != MED_COORDINATE_AXIS3)
&& (meddatatype != MED_INDEX_FACE)
&& (meddatatype != MED_INDEX_NODE)) {
if (entitytype == MED_NODE) {
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
if ( (_gridtype == MED_CARTESIAN_GRID) ||
(_gridtype == MED_CURVILINEAR_GRID) ) {
_ntmpmeddatatype=_meshdim;
_tmpmeddatatype[0] = MED_COORDINATE_AXIS1;
_tmpmeddatatype[1] = MED_COORDINATE_AXIS2;
_tmpmeddatatype[2] = MED_COORDINATE_AXIS3;
} else if (_gridtype == MED_CURVILINEAR_GRID ) {
/*Les grilles curvilinéaires utilisent MED_COORDINATE_AXISx pour stocker la structure et le tableau MED_COORDINATE pour stocker les coordonnées des noeuds */
++_ntmpmeddatatype;
_tmpmeddatatype[3] = MED_COORDINATE;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
} else
_tmpmeddatatype[0] = MED_COORDINATE;
} else {
switch (geotype) {
case MED_POLYHEDRON:
_ntmpmeddatatype=3;
_tmpmeddatatype[2] = MED_CONNECTIVITY;
_tmpmeddatatype[1] = MED_INDEX_FACE;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
case MED_POLYGON:
_ntmpmeddatatype=2;
_tmpmeddatatype[1] = MED_CONNECTIVITY;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
default:
if ( ( (med_mesh_type) _intmeshtype ) == MED_STRUCTURED_MESH ) {
_ntmpmeddatatype=0;
break;
}
_tmpmeddatatype[0] = MED_CONNECTIVITY;
if ( cmode == MED_NO_CMODE ) {
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_NODAL,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
if ( _datasetexist ) _cmode= MED_NODAL;
else
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_DESCENDING,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
} else
_cmode = MED_DESCENDING;
}
}
}
*changement = MED_FALSE;
for (_i=0; _i < _ntmpmeddatatype ;++_i) {
if ( _MEDgetDatasetChgt( _datagroup, _tmpmeddatatype[_i], _cmode,
&_isasoftlink, &_changement_co ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"getDatasetChgt");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
*changement |= _changement_co;
}
}
/*
* Niveau de datagroup 5 supplémentaire pour les éléments de structure ou les transformations.
*/
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) ) {
if (meddatatype == MED_VARIABLE_ATTRIBUTE)
strcpy(_datagroupname4,MED_VARATR_NOM);
else
strcpy(_datagroupname4,MED_COOTRF_NOM);
if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
_n=0;
goto SORTIE;
}
}
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) )
_datagroupf=_datagroup4;
else
_datagroupf=_datagroup;
/*
* Construction du nom du dataset à lire
*/
if ( _MEDgetDatasetName(_datasetname,meddatatype,cmode) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetName");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
/*
* MAJ du champ transformation pour le (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if (_datagroup4) {
if ( _MEDattrEntierLire(_datagroup4,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
if ( (_dataset = _MEDdatasetOuvrir(_datagroupf,_datasetname)) < 0) {
_n=0;_dataset=0;*transformation = (med_bool) MED_FALSE;
/* if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname); */
/* SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4); */
/* ISCRUTE_size(_n); */
/* goto ERROR; */
/* } */
goto SORTIE;
}
if (!_datagroup4) {
/*
* Lire l'attribut CGT pour savoir si le dataset a changé
* n'a pas de sens si le dataset est en fait un lien vers le dataset précedent.
* En testant si le dataset est un lien on détermine si un changement a eu lieu
* depuis la séquence de calcul précédente.
* Ce traitement ne doit pas être effectué pour le pas de temps initial et pour
* (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if ( _MEDisasoftlink(_datagroupf, _datasetname,MED_TRUE, &_isasoftlink ) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_LINK,_datasetname);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
ISCRUTE_size(_n);goto ERROR;
}
if (_isasoftlink)
_transformation = MED_FALSE;
else {
if ( _MEDattrEntierLire(_dataset,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
}
*transformation = (med_bool) _transformation;
if ( ( meddatatype == MED_CONNECTIVITY) && ( meddatatype == MED_COORDINATE ) ) {
*transformation &= (med_bool) !_changement_s;
}
/*
* Attribut PFL (nombre de noeuds ou d'elements)
* la lecture est faite sur le datagroup _datagroup et non sur _datagroupf
* pour (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
_profilearraysize = 0;
profilename[0]='\0';
if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(profilename,_profilename,MED_NAME_SIZE+1);
profilename[MED_NAME_SIZE]='\0';
if ( ( _profilearraysize = MEDprofileSizeByName( fid,_profilename) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_profilename);SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
*profilesize=(med_int) _profilearraysize;
/*
* Attribut NBR (nombre d'entité)
*/
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_intn) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
SSCRUTE(_datasetname);SSCRUTE(MED_NOM_NBR);ISCRUTE_size(_n);goto ERROR;
}
_n = _intn;
if (_profilearraysize)
switch(storagemode) {
case MED_GLOBAL_PFLMODE :
break;
case MED_COMPACT_PFLMODE :
if ( meddatatype!=MED_COORDINATE_TRSF )
_n=_profilearraysize;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_STORAGEMODE,MED_ERR_VALUE_MSG);
ISCRUTE_int(storagemode);goto ERROR;
break;
}
SORTIE:
_ret = _n;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
ISCRUTE_id(_dataset);
}
if (_datagroup4>0) if (_MEDdatagroupFermer(_datagroup4) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname4);
ISCRUTE_id(_datagroup4);
}
if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
ISCRUTE_id(_datagroup3);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
/* _MEDobjetsOuverts(fid); */
*fret = _ret;
va_end(params);
return;
}
med_err
MEDdimEspaceCr(med_idt fid, char *maillage, med_int dim)
{
med_idt maaid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_int maadim;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un maillage en mode MED_LECTURE.");
goto ERROR;
};
/*
* On regarde si le groupe existe => erreur si non
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Erreur à l'ouverture du maillage : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* On va lire l'attribut dimension du maillage et on controle
* la coherence
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&maadim)) < 0) {
MESSAGE("Erreur à la lecture de la dimension du maillage : ");
ISCRUTE(maadim);
goto ERROR;
}
if (maadim > dim) {
MESSAGE("La dimension de l'espace : ");
ISCRUTE(dim);
MESSAGE("doit être supérieur à la dimension du maillage : ");
ISCRUTE(maadim);
goto ERROR;
}
/*
* On ecrit la dimension de l'espace
*/
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_ESP,&dim)) < 0) {
MESSAGE("Erreur à l'écriture de la dimension de l'espace : ");
ISCRUTE(dim);
goto ERROR;
}
/*
* Fermetures des objets HDF
*/
ret = 0;
ERROR:
if (maaid>0) if (_MEDdatagroupFermer(maaid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(maaid);ret = -1;
}
return ret;
}
void _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;
}
int main (int argc, char **argv)
{
med_err ret,lret;
med_idt fid;
char * fichier = NULL;
char maa[MED_TAILLE_NOM+1]="";
char desc[MED_TAILLE_DESC+1]="";
char pflname[MED_TAILLE_NOM+1]="",nomlien[MED_TAILLE_NOM+1]="";
char locname[MED_TAILLE_NOM+1]="";
char * lien = NULL;
char *comp= NULL, *unit= NULL;
char nomcha [MED_TAILLE_NOM+1]="";
med_int mdim,ncomp,ncha,npro,nln,pflsize,*pflval,nval;
med_int ngauss,nloc;
int t1,t2,t3;
med_type_champ typcha;
med_maillage type;
med_geometrie_element type_geo;
med_float *refcoo, *gscoo, *wg;
int i,j;
if (argc != 2) {
MESSAGE("Aucun nom de fichier precise, fichier test10.med utilise ");
fichier = "test10.med";
} else {
fichier = argv[1];
};
/* Ouverture du fichier med */
if ((fid = MEDouvrir(fichier,MED_LECTURE)) < 0){
MESSAGE("Erreur a l'ouverture du fichier : ");SSCRUTE(fichier);
return -1;
}
ret = 0;
/* infos sur le premier maillage */
if ( MEDmaaInfo(fid,1,maa,&mdim,&type,desc) < 0 ) {
MESSAGE("Erreur a la lecture des informations sur le maillage : ");
SSCRUTE(maa);ISCRUTE(mdim);ISCRUTE(type);SSCRUTE(desc);
return -1;
}
printf("Maillage de nom |%s| et de dimension %d \n",maa,mdim);
/* combien de champs dans le fichier */
if ((ncha = MEDnChamp(fid,0)) < 0) {
MESSAGE("Impossible de lire le nombre de champs : ");ISCRUTE(ncha);
return ncha;
}
printf("Nombre de champs : %d \n",ncha);
/* lecture de tous les champs */
for (i =0;i<ncha;i++) {
lret = 0;
printf("\nChamp numero : %d \n",i+1);
/* Lecture du nombre de composantes */
if ((ncomp = MEDnChamp(fid,i+1)) < 0) {
MESSAGE("Erreur a la lecture du nombre de composantes : "); ISCRUTE(ncomp);
ret = -1; continue;
}
/* Lecture du type du champ, des noms des composantes et du nom de l'unite*/
comp = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
EXIT_IF(comp == NULL,NULL,NULL);
unit = (char*) malloc(ncomp*MED_TAILLE_PNOM+1);
EXIT_IF(unit == NULL,NULL,NULL);
if ( MEDchampInfo(fid,i+1,nomcha,&typcha,comp,unit,ncomp) < 0 ) {
MESSAGE("Erreur a la demande d'information sur les champs : ");
ISCRUTE(i+1);SSCRUTE(nomcha);ISCRUTE(typcha);SSCRUTE(comp);SSCRUTE(unit);
ISCRUTE(ncomp);
ret = -1; continue;
}
printf("Nom du champ : |%s| de type %d\n",nomcha,typcha);
printf("Nom des composantes : |%s|\n",comp);
printf("Unites des composantes : |%s| \n",unit);
free(comp);
free(unit);
lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_NOEUD, USER_INTERLACE );
if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_MAILLE, USER_INTERLACE );
else { MESSAGE("Erreur a la lecture des champs aux noeuds "); ret = -1; continue;}
if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_FACE,USER_INTERLACE);
else { MESSAGE("Erreur a la lecture des champs aux mailles "); ret = -1; continue;}
if (lret == 0) lret = getFieldsOn(fid, nomcha, typcha, ncomp, MED_ARETE,USER_INTERLACE);
else {MESSAGE("Erreur a la lecture des champs aux faces "); ret = -1; continue;}
if (lret != 0) {MESSAGE("Erreur a la lecture des champs aux aretes "); ret = -1;};
}
/* Interrogation des profils */
npro = MEDnProfil(fid);
printf("\nNombre de profils stockes : %i\n\n",npro);
for (i=1 ; i <= npro ; i++ ) {
if ( MEDprofilInfo(fid, i, pflname, &nval) < 0) {
MESSAGE("Erreur a la demande d'information sur le profil n° : "); ISCRUTE(i);
ret = -1;continue;
}
printf("\t- Profil n°%i de nom |%s| et de taille %i\n",i,pflname,nval);
pflval = (med_int*) malloc(sizeof(med_int)*nval);
if ( MEDprofilLire(fid, pflval, pflname) < 0) {
MESSAGE("Erreur a la lecture des valeurs du profil : ");
SSCRUTE(pflname);
ret = -1;
} else {
printf("\t");
for (j=0;j<nval;j++) printf(" %i ",*(pflval+j));
printf("\n\n");
}
free(pflval);
}
/* Interrogation des liens */
nln = MEDnLien(fid);
printf("\nNombre de liens stockes : %i\n\n",nln);
for (i=1 ; i <= nln ; i++ ) {
if ( MEDlienInfo(fid, i, nomlien, &nval) < 0) {
MESSAGE("Erreur a la demande d'information sur le lien n° : "); ISCRUTE(i);
ret = -1;continue;
}
printf("\t- Lien n°%i de nom |%s| et de taille %i\n",i,nomlien,nval);
lien = malloc((nval+1)*sizeof(char));
EXIT_IF(lien == NULL,NULL,NULL);
if ( MEDlienLire(fid, lien, nomlien) < 0 ) {
MESSAGE("Erreur a la lecture du lien : ");
SSCRUTE(nomlien);SSCRUTE(lien);
ret = -1;
} else
printf("\t\t|%s|\n\n",lien);
free(lien);
}
/* Interrogation des localisations des points de GAUSS */
nloc = MEDnGauss(fid);
printf("\nNombre de localisations stockees : %i\n\n",nloc);
for (i=1 ; i <= nloc ; i++ ) {
if ( MEDgaussInfo(fid, i, locname, &type_geo, &ngauss) < 0) {
MESSAGE("Erreur a la demande d'information sur la localisation n° : "); ISCRUTE(i);
ret = -1;continue;
}
printf("\t- Loc. n°%i de nom |%s| et nbr. de pts de GAUSS %i\n",i,locname,ngauss);
t1 = (type_geo%100)*(type_geo/100);
t2 = ngauss*(type_geo/100);
t3 = ngauss;
refcoo = (med_float *) malloc(sizeof(med_float)*t1 );
gscoo = (med_float *) malloc(sizeof(med_float)*t2 );
wg = (med_float *) malloc(sizeof(med_float)*t3 );
if ( MEDgaussLire(fid, refcoo, gscoo, wg, USER_INTERLACE, locname ) < 0) {
MESSAGE("Erreur a la lecture des valeurs de la localisation : ");
SSCRUTE(locname);
ret = -1;
} else {
printf("\t Coordonnees de l'element de reference de type %i :\n\t\t",type_geo);
for (j=0;j<t1;j++) printf(" %f ",*(refcoo+j));
printf("\n");
printf("\t Localisation des points de GAUSS : \n\t\t");
for (j=0;j<t2;j++) printf(" %f ",*(gscoo+j));
printf("\n");
printf("\t Poids associes aux points de GAUSS :\n\t\t");
for (j=0;j<t3;j++) printf(" %f ",*(wg+j));
printf("\n\n");
}
free(refcoo);
free(gscoo);
free(wg);
}
/* fermeture du fichier */
if ( MEDfermer(fid) < 0) return -1;
return ret;
}
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
MEDscalaireCr(med_idt fid,char *scalaire, med_type_champ type, char *desc)
{
med_err ret=-1;
med_idt root=0,gid=0;
char chemin[MED_TAILLE_NUM_DATA+1];
med_int _type = (med_int) type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer une variable scalaire en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Groupe HDF "/NUM_DATA" n'existe pas, on le cree
*/
strncpy(chemin,MED_NUM_DATA,MED_TAILLE_NUM_DATA-1);
chemin[MED_TAILLE_NUM_DATA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0){
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si le groupe HDF "scalaire" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(scalaire,ERROR);
if ((gid = _MEDdatagroupCreer(root,scalaire)) < 0) {
MESSAGE("Erreur à la création de la variable scalaire : ");
SSCRUTE(scalaire);
goto ERROR;
}
/*
* On stocke l'unite, et le type de la valeur scalaire
*/
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type)) < 0) {
MESSAGE("Erreur à l'écriture du type de la varaible scalaire : ");
ISCRUTE(_type);
goto ERROR;
}
if ((ret = _MEDattrStringEcrire(gid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description de la variable scalaire : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* On ferme tout
*/
ret = 0;
ERROR:
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret=-1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret=-1;
}
return ret;
}
void
MEDjointCr231(int dummy,...) {
med_idt fid ;
char * maa_lcl ;
char * jn ;
char * desc ;
med_int dom ;
char * maa_dist ;
med_err * fret ;
med_idt root=0,jntid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_JNT+1];
med_int nbc=0;
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params,med_idt);
maa_lcl = va_arg(params,char *);
jn = va_arg(params,char *);
desc = va_arg(params,char *);
dom = va_arg(params,med_int);
maa_dist = va_arg(params,char*);
fret = va_arg(params,med_err *);
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un joint en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group "JNT" n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
NOFINALBLANK(maa_lcl,ERROR);
strcat(chemin,maa_lcl);
strncpy(tmp,MED_JNT,MED_TAILLE_JNT-1);
tmp[MED_TAILLE_JNT-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si un joint du meme nom existe => erreur
* Sinon on le cree
*/
NOFINALBLANK(jn,ERROR);
if ((jntid = _MEDdatagroupCreer(root,jn)) < 0) {
MESSAGE("Erreur à la création du joint : ");
SSCRUTE(jn);
goto ERROR;
}
/*
* L'attribut "DES"
*/
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description du joint : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* L'attribut "MAI"
*/
/* BUG CORRIGE EN 232 MED_TAILLE_NOM au lieu de MED_TAILLE_MAA */
/* conservé ici pour éviter de reprendre en lib2.3.2 un fichier 2.3.1
en écrivant l'attribut avec une taille plus grande que celle des fichiers 2.3.1 */
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_MAI,MED_TAILLE_MAA,maa_dist)) < 0) {
MESSAGE("Erreur à l'écriture du nom du maillage distant : ");
SSCRUTE(maa_dist);
goto ERROR;
}
/*
* L'attribut "DOM"
*/
if ((ret = _MEDattrEntierEcrire(jntid,MED_NOM_DOM,&dom)) < 0) {
MESSAGE("Erreur à l'écriture du domaine : ");
ISCRUTE(dom);
goto ERROR;
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (jntid>0) if (_MEDdatagroupFermer(jntid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(jntid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
void
_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;
}
int main (int argc, char **argv)
{
med_err _ret=0;
COM_info _cominfo;
_cominfo.comm = MPI_COMM_WORLD;
_cominfo.info = MPI_INFO_NULL;
_cominfo.nentitiesfiltered=0;
_cominfo.filterarray =NULL;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &(_cominfo.mpi_size));
MPI_Comm_rank(MPI_COMM_WORLD, &(_cominfo.mpi_rank));
med_size _nbblocksperproc = 0;
int _nentities = 0;
int _nvaluesperentity = 0;
int _nconstituentpervalue = 0;
if (_cominfo.mpi_rank == 0 ) {
struct tm *_tm ;
time_t _tt=time(0);
_tm = localtime(&_tt);
srandom((*_tm).tm_sec * (*_tm).tm_min );
_nbblocksperproc = 1 + (int) (_cominfo.mpi_size * (random() / (RAND_MAX + 1.0)));
_nentities = 1 + (int) (1000.0 * (random() / (RAND_MAX + 1.0)));
_nvaluesperentity = 1 + (int) (11.0 * (random() / (RAND_MAX + 1.0)));
_nconstituentpervalue = 1 + (int) (7.0 * (random() / (RAND_MAX + 1.0)));
/* _nbblocksperproc = 1 + (int) (mpi_size * (random() / (RAND_MAX + 1.0))); */
/* _nentities = 1 + (int) (5.0 * (random() / (RAND_MAX + 1.0))); */
/* _nvaluesperentity = 1 + (int) (3.0 * (random() / (RAND_MAX + 1.0))); */
/* _nconstituentpervalue = 1 + (int) (3.0 * (random() / (RAND_MAX + 1.0))); */
/* _nbblocksperproc = 2; */
/* _nentities = 4; */
/* _nvaluesperentity = 1; */
/* _nconstituentpervalue = 1; */
}
if ( (sizeof(med_size)%(sizeof(MPI_LONG)))==0 ) {
MPI_Bcast(&_nbblocksperproc , sizeof(med_size)/sizeof(MPI_LONG), MPI_LONG, 0, MPI_COMM_WORLD);
MPI_Bcast(&_nentities , sizeof(med_size)/sizeof(MPI_LONG), MPI_LONG, 0, MPI_COMM_WORLD);
MPI_Bcast(&_nvaluesperentity , sizeof(med_size)/sizeof(MPI_LONG), MPI_LONG, 0, MPI_COMM_WORLD);
MPI_Bcast(&_nconstituentpervalue , sizeof(med_size)/sizeof(MPI_LONG), MPI_LONG, 0, MPI_COMM_WORLD);
} else {
assert(sizeof(med_size) == (sizeof(MPI_LONG)));
}
char _fieldnameprefix[256] = "";
sprintf(_fieldnameprefix,"NENT-%03d_NVAL-%03d_NCST-%03d_NBL-%03llu",_nentities,_nvaluesperentity,
_nconstituentpervalue,_nbblocksperproc);
GenerateDataType generateDatas = 0;
med_switch_mode _switchmode = MED_UNDEF_INTERLACE;
med_storage_mode _storagemode = MED_UNDEF_STMODE;
/*Pour que les 4 fichiers générés soient identiques, on désactive l'utilisation des profils
qui n'est pas utilisable en mode GLOBAL+// */
med_int _profilearraysize=0;
/* med_int _profilearraysize=_nentities/2; */
for (_switchmode = MED_FULL_INTERLACE ; _switchmode <= MED_NO_INTERLACE; ++_switchmode) {
if ( _switchmode == MED_FULL_INTERLACE ) generateDatas = generateFullIDatas;
else generateDatas = generateNoIDatas;
for (_storagemode = MED_GLOBAL_STMODE ; _storagemode <= MED_COMPACT_STMODE; ++_storagemode) {
if ( (_storagemode == MED_GLOBAL_STMODE ) && (_profilearraysize) ) _profilearraysize=0;
if ( generateFieldFile( _nentities, _nvaluesperentity, _nconstituentpervalue,
_switchmode, getCyclicBlocksOfEntities, _nbblocksperproc, generateDatas,
_storagemode, _profilearraysize, _fieldnameprefix, & _cominfo) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_FIELD,_fieldnameprefix);
ISCRUTE(_cominfo.mpi_rank);
goto ERROR;
}
}
}
_ret = 0;
ERROR:
if ( _cominfo.filterarray = NULL ) free( _cominfo.filterarray );
/*pour arch. BLueGene : Sync entre GPFS et LSF : sleep(360) */
/* MPI_Finalize must be called AFTER MEDclose which may use MPI calls */
MPI_Finalize();
/* Catcher l'erreur en retour mpirun et .sh*/
return _ret;
}
void
_MEDlocalizationInfoByName236(int dummy, ...) {
med_idt _lzid=0;
med_err _ret=-1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
med_int _intgeotype = -1;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , localizationname );
MED_VARGS_DECL(, med_geometry_type *, const , geotype );
MED_VARGS_DECL(, med_int *, const , spacedimension );
MED_VARGS_DECL(, med_int *, const , nipoint );
MED_VARGS_DECL(, char *, const , geointerpname );
MED_VARGS_DECL(, char *, const , sectionmeshname );
MED_VARGS_DECL(, med_int *, const , nsectionmeshcell );
MED_VARGS_DECL(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , localizationname );
MED_VARGS_DEF(, med_geometry_type *, const , geotype );
MED_VARGS_DEF(, med_int *, const , spacedimension );
MED_VARGS_DEF(, med_int *, const , nipoint );
MED_VARGS_DEF(, char *, const , geointerpname );
MED_VARGS_DEF(, char *, const , sectionmeshname );
MED_VARGS_DEF(, med_int *, const , nsectionmeshcell );
MED_VARGS_DEF(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* ouverture du groupe /GAUSS/"nom"
*/
strcat(_path,localizationname);
if ((_lzid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_NBR
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_NBR,nipoint) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nipoint);
goto ERROR;
}
/*
* On lit <typgeo> sous forme d'attribut
*/
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long,
du coup sur machines 64 bits _MEDattributeIntWr utilise
le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
un enum.
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_GEO,&_intgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE(_intgeotype);
goto ERROR;
};
*geotype = (med_geometry_type) _intgeotype;
*spacedimension = (_intgeotype/100);
sectionmeshname[0]='\0';
geointerpname[0]='\0';
*nsectionmeshcell=0;
*sectiongeotype=MED_UNDEF_GEOTYPE;
_ret = 0;
ERROR:
if ( _lzid > 0 ) if ( _MEDdatagroupFermer(_lzid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_GAUSS);
ISCRUTE_id(_lzid);
}
va_end(params);
*fret = _ret;
return;
}
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;
}
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
_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
MEDprofileWr(const med_idt fid,
const char* const profilename,
const med_int profilesize,
const med_int* const profilearray)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_pfid=0;
med_err _ret=-1;
char _path[MED_TAILLE_PROFILS+MED_NAME_SIZE+1]=MED_PROFILS;
med_filter _filter = MED_FILTER_INIT;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /PROFILS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(profilename,ERROR);
/*
* Si le DataGroup /PROFILS/<profilename> n'existe pas, on le cree
*/
if ((_pfid = _MEDdatagroupOuvrir(_root,profilename)) < 0)
if ((_pfid = _MEDdatagroupCreer(_root,profilename)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,profilename);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,profilename);
/*
* On stocke "profilesize" sous forme d'attribut
*/
if (_MEDattributeIntWr(_pfid,MED_NOM_NBR,&profilesize) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_PROFILE_MSG);
SSCRUTE(profilename);SSCRUTE(MED_NOM_NBR);ISCRUTE(profilesize);
goto ERROR;
}
/*
* On stocke le profil dans un dataset
*/
if ( MEDfilterEntityCr(fid, profilesize, 1, 1, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_PFLMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
if ( _MEDdatasetWr(_pfid,MED_NOM_PFL,MED_INTERNAL_INT,&_filter, profilearray) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_PFL);SSCRUTE(_path);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_PROFILE_MSG); SSCRUTE(_path);
goto ERROR;
}
_ret = 0;
ERROR:
if (_pfid>0) if (_MEDdatagroupFermer(_pfid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,profilename);
ISCRUTE_id(_pfid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_PROFILS);
ISCRUTE_id(_root);
}
return _ret;
}
void
_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;
}
