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; }