med_err
MEDparameterComputationStepInfo(const med_idt fid,
const char * const paramname,
const int csit,
med_int * const numdt,
med_int * const numit,
med_float * const dt )
{
med_err _ret = -1, _err = -1;
med_idt _cpstidt = 0;
char _path[(MED_TAILLE_NUM_DATA+MED_NAME_SIZE+1)+2*MED_MAX_PARA+1]=MED_NUM_DATA;
int _num=csit-1;
char _cstpname[2*MED_MAX_PARA+1]="";
_MEDmodeErreurVerrouiller();
/* On recupere le nom du pas de temps */
strcat(_path, paramname);
if ( _MEDobjectGetName(fid, _path ,_num, _cstpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
/* on ouvre le groupe HDF correspondant */
strcat(_path,"/");
strcat(_path,_cstpname);
if ((_cpstidt = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/* Lecture des attributs */
if (_MEDattrEntierLire(_cpstidt, MED_NOM_NDT, (med_int*) numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
SSCRUTE(_path);ISCRUTE(*numdt);goto ERROR;
}
if (_MEDattrFloatLire(_cpstidt, MED_NOM_PDT, (med_float*) dt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_PDT);
SSCRUTE(_path);RSCRUTE(*dt);goto ERROR;
}
if (_MEDattrEntierLire(_cpstidt, MED_NOM_NOR, (med_int*) numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
SSCRUTE(_path);ISCRUTE(*numit);goto ERROR;
}
_ret = 0;
ERROR:
/* on ferme tout */
if (_cpstidt > 0)
if (_MEDdatagroupFermer(_cpstidt) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_cpstidt);
}
return _ret;
}
med_err
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
MEDscalairePasdetempsInfo(med_idt fid,char *scalaire,int indice,
med_int * numdt, char * dt_unit, med_float * dt,med_int * numo)
{
med_err ret=0;
med_idt gid;
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1+2*MED_MAX_PARA+1];
int num;
char nomdatagroup[2*MED_MAX_PARA+1];
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On construit le chemine d'acces
*/
strcpy(chemin,MED_NUM_DATA);
strcat(chemin,scalaire);
strcat(chemin,"/");
num = indice - 1;
if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0)
return -1;
strcat(chemin,nomdatagroup);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* La liste des attributs
*/
if ((ret = _MEDattrEntierLire(gid,MED_NOM_NDT,(med_int*) numdt)) < 0)
return -1;
if ((ret = _MEDattrFloatLire(gid,MED_NOM_PDT,(med_float*) dt)) < 0)
return -1;
if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_NOR,(med_int*) numo)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}
med_err
MEDnatureGrilleLire(med_idt fid,char *maillage,med_type_grille *type)
{
med_idt maaid;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_maillage maillage_type;
med_int att;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On regarde si le groupe existe => erreur si non
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Si le maillage est de type MED_NON_STRUCTURE => erreur
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_TYP,&att)) < 0)
return -1;
maillage_type = (med_maillage) att;
if (maillage_type == MED_NON_STRUCTURE)
return -1;
/*
* On lit le type de la grille
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_GTY,&att)) < 0)
return -1;
*type = (med_type_grille) att;
/*
* Fermeture des objets HDF
*/
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return ret;
}
med_err
MEDversionConforme(const char *nom) {
med_int majeur, mineur;
med_idt fid, gid;
med_err ret;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
/*
* On ouvre le fichier MED en mode MED_LECT
*/
if ((fid = _MEDfichierOuvrir((char *)nom,MED_LECTURE)) < 0)
return -1;
/*
* Lecture du numero de version
*/
if ((gid = _MEDdatagroupOuvrir(fid,MED_INFOS)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,&majeur)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,&mineur)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
if ((ret = _MEDfichierFermer(fid)) < 0)
return -1;
/* On autorise les versions 2.2.x et 2.3.x , ce qui est le cas depuis med2.3.1 */
if ((majeur == 2) && (mineur >1) && (mineur<4) )
return 0;
else
return -1;
}
med_err
MEDscalaireFlottantLire(med_idt fid,char *scalaire, med_float *val,med_int numdt, med_int numo)
{
med_err ret = 0;
med_idt gid, datagroup;
med_int type, i;
char nomdatagroup[2*MED_MAX_PARA+1];
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1];
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le groupe HDF "scalaire" n'existe pas => erreur
*/
strcpy(chemin,MED_NUM_DATA);
strcat(chemin,scalaire);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Si le groupe HDF <numdtt>.<numoo> n'existe pas => erreur
*/
sprintf(nomdatagroup,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
datagroup = 0;
if ( (datagroup = _MEDdatagroupOuvrir(gid,nomdatagroup)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,&type)) < 0)
return -1;
switch(type)
{
case MED_FLOAT64 :
if ((ret = _MEDattrFloatLire(datagroup,MED_NOM_VAL,val)) < 0)
return -1;
break;
default :
return -1;
}
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}
med_err
MEDscalaireInfo(med_idt fid,int indice,char *scalaire,
med_type_champ *type,char *desc)
{
med_err ret=0;
med_idt gid;
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1];
int num;
med_int typechamp;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On recupere le nom du scalaire
*/
num = indice - 1;
strcpy(chemin,MED_NUM_DATA);
if ((ret = _MEDobjetIdentifier(fid,chemin,num,scalaire)) < 0)
return -1;
/*
* Si le Groupe HDF "scalaire" n'existe pas => erreur
*/
strcat(chemin,scalaire);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* La liste des attributs
*/
if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP, & typechamp)) < 0)
return -1;
*type = (med_type_champ) typechamp;
if ((ret = _MEDattrStringLire(gid,MED_NOM_DES,MED_TAILLE_DESC,
desc)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}
med_err
MEDprofilInfo(med_idt fid, int indice, char *profilname, med_int *n)
{
int numero=0;
med_idt proid=0;
med_err ret=-1;
char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]="";
/*
* 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_PROFILS,numero,profilname) < 0)
goto ERROR;
/*
* On va chercher l'attribut taille du profil
*/
strcpy(chemin,MED_PROFILS);
strcat(chemin,profilname);
if ((proid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
goto ERROR;
if (_MEDattrEntierLire(proid,MED_NOM_NBR,n) < 0)
goto ERROR;
ret = 0;
ERROR:
if ( proid > 0 ) if (_MEDdatagroupFermer(proid) < 0)
goto ERROR;
return 0;
}
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;
}
med_int
MEDnbnomaLire(med_idt fid,char *nom_maillage)
{
med_idt maaid;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
med_int n;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On regarde si le maillage existe => erreur si non
*/
strcpy(chemin,MED_MAA);
strcat(chemin,nom_maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* On va lire l'attribut "NNM"
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNM,&n)) < 0)
return -1;
/*
* Fermetures des objets HDF
*/
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return n;
}
med_err
MEDcoordLire(med_idt fid, char *maa, med_int mdim, med_float *coo,
med_mode_switch mode_coo,med_int numco,
med_int * pfltabtmp, med_size psize, med_repere *type_rep, char *nom, char *unit)
{
med_idt maaid, noeid, dataset;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
int i,j;
med_float *new_coo;
med_int type_rep_int;
med_size * pfltab;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
* Sinon on recupere sa dimension au passage
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Si le Data Group "NOE" n'existe pas => erreur
*/
if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
return -1;
/*
* Convertion de med_int en med_size
*/
if ( psize != MED_NOPF ) {
pfltab = (med_size *) malloc (sizeof(med_size)*psize);
for (i=0;i<psize;i++)
pfltab[i] = (med_size) pfltabtmp[i];
}
/*
* Lecture du Data Set "COO"
*/
if ((ret = _MEDdatasetNumLire(noeid,MED_NOM_COO,MED_FLOAT64,
mode_coo,mdim,numco,
psize,MED_COMPACT,MED_PFL_NON_COMPACT,pfltab,MED_NOPG,0,
(unsigned char*) coo)) < 0)
return -1;
/*
* On re-ouvre le Data Set "COO" pour y lire des attributs
*/
if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0)
return -1;
/*
* L'attribut "REP"
*/
if ((ret = _MEDattrEntierLire(dataset,MED_NOM_REP,&type_rep_int)) < 0)
return -1;
else
*type_rep = (med_repere) type_rep_int;
/*
* Attribut "NOM"
*/
if ((ret = _MEDattrStringLire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,
nom)) < 0)
return -1;
/*
* Attribut "UNI"
*/
if ((ret = _MEDattrStringLire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,
unit)) < 0)
return -1;
/*
* On ferme tout
*/
if ( psize != MED_NOPF ) free(pfltab);
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(noeid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
void
_MEDfield23ComputingStepMeshInfo236(int dummy,...)
{
med_err _ret=-1,_err=0;
med_size _num,_nmesh=0;
med_idt _datagroup1=0,_meshgid=0,_linkgid=0;
char _datagroupname1[2*MED_MAX_PARA+1] ="";
char _ent_geo [2*MED_TAILLE_NOM_ENTITE+2]="";
char _path [(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+
(2*MED_TAILLE_NOM_ENTITE+1)+1+(2*MED_MAX_PARA)+1]=MED_CHA;
char _meshpath [MED_TAILLE_MAA+MED_TAILLE_NOM+1]=MED_MAA;
char _linkpath [MED_TAILLE_LIENS+MED_TAILLE_NOM+1]=MED_LIENS;
med_size _ncpst=0;
med_bool _checkmultiplemesh=MED_TRUE, _multiplemesh =MED_FALSE;
med_bool _checkmeshname =MED_TRUE, _samedefaultmeshname=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, int , , csit );
MED_VARGS_DECL(, med_int *, const , numdt );
MED_VARGS_DECL(, med_int *, const , numit );
MED_VARGS_DECL(, med_float *, const , dt );
MED_VARGS_DECL(, med_int *, const , nmesh );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_int *, const , meshnumdt );
MED_VARGS_DECL(, med_int *, const , meshnumit );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, int , , csit );
MED_VARGS_DEF(, med_int *, const , numdt );
MED_VARGS_DEF(, med_int *, const , numit );
MED_VARGS_DEF(, med_float *, const , dt );
MED_VARGS_DEF(, med_int *, const , nmesh );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_int *, const , meshnumdt );
MED_VARGS_DEF(, med_int *, const , meshnumit );
MED_VARGS_DEF(, med_err * ,, fret );
_num=csit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On construit le nom du datagroup
*/
strcat(_path,fieldname);
/* if ( _MEDfieldComputingStepCheck236(fid, fieldname, */
/* &_ncpst, */
/* _checkmultiplemesh, &_multiplemesh, */
/* _checkmeshname, &_samedefaultmeshname) < 0) { */
/* MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FIELD,fieldname); */
/* goto ERROR; */
/* } */
/*
* On suppose que le modèle 2.3.6 est respecté :
* Il y a les mêmes séquences de calcul pour tous les couples
* (typent,typegeo). Autrement dit selon l'utilisation de l'API 2.3.6 :
* A chaque séquence de calcul, on utilise le même ensemble de (typent,typegeo).
* En conséquence si l'on fixe le (typeent,typegeo) les séquences
* de calcul que l'on va trouver seront représentatives de celles
* présentent dans tous les (typent,typegeo) utilisés.
*/
if ( _MEDobjectGetName(fid, _path ,0, _ent_geo) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); SSCRUTE(_ent_geo); goto ERROR;
}
strcat(_path,"/");
strcat(_path,_ent_geo);
if ( _MEDobjectGetName(fid, _path ,_num, _datagroupname1) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); SSCRUTE(_ent_geo); goto ERROR;
}
strcat(_path,"/");
strcat(_path,_datagroupname1);
if ((_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Lecture des attributs
*/
if (_MEDattrEntierLire(_datagroup1,MED_NOM_NDT,(med_int*) numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
SSCRUTE(_path);ISCRUTE(*numdt);goto ERROR;
}
if (_MEDattrFloatLire(_datagroup1,MED_NOM_PDT,(med_float*) dt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_PDT);
SSCRUTE(_path);RSCRUTE(*dt);goto ERROR;
}
if (_MEDattrEntierLire(_datagroup1,MED_NOM_NOR,(med_int*) numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
SSCRUTE(_path);ISCRUTE(*numit);goto ERROR;
}
if (_MEDattrStringLire(_datagroup1,MED_NOM_MAI,MED_TAILLE_NOM,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_MAI);
SSCRUTE(_path);SSCRUTE(meshname);goto ERROR;
}
/* Nombre de maillages
* La gestion d'une incohérence sur le nombre de séquences de calcul par couple (entitytype,geotype)
* se fait à partir des appels :
* MEDfieldnProfile,MEDfieldnValue*
* La vérification complémentaire que l'ensemble des maillages utilisés sont les mêmes pour toutes les séquences
* de calcul identiques est effectué dans MEDfield23nValue
*/
if ( (_err=_MEDnObjects(_datagroup1,".",&_nmesh)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
*nmesh = (med_int) _nmesh;
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
*meshnumdt=MED_NO_DT;
*meshnumit=MED_NO_IT;
_ret = 0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_datagroup1);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
void MAJ_21_22_elements_maillage(med_idt mid, med_int dimension)
{
med_idt eid,gid,did,tid;
med_err ret;
int i,j;
med_geometrie_element typmai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2,
MED_SEG3,MED_TRIA3,
MED_TRIA6,MED_QUAD4,
MED_QUAD8,MED_TETRA4,
MED_TETRA10,MED_HEXA8,
MED_HEXA20,MED_PENTA6,
MED_PENTA15,MED_PYRA5,
MED_PYRA13};
int taille, edim;
char *nom, *nouvelle_chaine;
char nomgroup[MED_TAILLE_NOM_ENTITE+1];
med_int n;
med_size dimd[1];
med_int *old_conn,*conn;
/* On ne regarde que les mailles et la connectivité nodale */
eid = _MEDdatagroupOuvrir(mid,(char *)(MED_NOM_MAI));
EXIT_IF(eid < 0,"Ouverture du groupe HDF MED_NOM_MAI",NULL);
/* On normalise selon tous les types geometriques */
for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++) {
/* On recupere le nom du groupe HDF */
_MEDnomGeometrie(nomgroup,typmai[i]);
/* On accède au type s'il existe dans le fichier */
gid = _MEDdatagroupOuvrir(eid,nomgroup);
if (gid < 0)
continue;
/* Nombre d'element ? */
did = _MEDdatasetOuvrir(gid,(char *)(MED_NOM_NOD));
EXIT_IF(did < 0,"Ouverture du dataset HDF MED_NOM_NOD",NULL);
ret = _MEDattrEntierLire(did,(char *)(MED_NOM_NBR),&n);
EXIT_IF(ret < 0,"Lecture du nombre d'elements",NULL);
ret = _MEDdatasetFermer(did);
EXIT_IF(ret < 0,"Fermeture du dataset HDF MED_NOM_NOD",NULL);
/* on normalise la connectivité si edim < dimension */
edim = typmai[i] / 100;
if (edim < dimension) {
taille = typmai[i]%100 + 1;
old_conn = (med_int *) malloc(sizeof(med_int)*taille*n);
EXIT_IF(old_conn == NULL,NULL,NULL);
#if defined(HAVE_F77INT64)
ret = _MED21datasetNumLire(gid,(char *)(MED_NOM_NOD),MED_INT64,
MED_NO_INTERLACE,(med_size)taille,MED_ALL,
0,NULL,MED_NOPG,
(unsigned char*) old_conn,H5T_NATIVE_INT);
#else
ret = _MED21datasetNumLire(gid,(char *)(MED_NOM_NOD),MED_INT32,
MED_NO_INTERLACE,(med_size) taille,MED_ALL,
0,NULL,MED_NOPG,
(unsigned char*) old_conn,H5T_NATIVE_INT);
#endif
/* On recopie dans le bon tableau */
taille --;
conn = (med_int *) malloc(sizeof(med_int)*taille*n);
EXIT_IF(conn == NULL,NULL,NULL);
for (j=0;j<n*taille;j++)
*(conn+j) = *(old_conn+j);
dimd[0] = n*taille;
#if defined(HAVE_F77INT64)
ret = _MED231datasetNumEcrire(gid,(char *) "TMP",MED_INT64,MED_NO_INTERLACE,
taille,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
(unsigned char*) conn);
#else
ret = _MED231datasetNumEcrire(gid,(char *) "TMP",MED_INT32,MED_NO_INTERLACE,
taille,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,MED_NOPG,dimd,
(unsigned char*) conn);
#endif
EXIT_IF(ret < 0,"Ecriture de la nouvelle connectivité des mailles",NULL);
/* Ecriture du nombre de mailles dans le dataset HDF TMP */
tid = _MEDdatasetOuvrir(gid,"TMP");
EXIT_IF(tid < 0,"Ouverture du dataset HDF TMP",NULL);
ret = _MEDattrEntierEcrire(tid,(char *)(MED_NOM_NBR),&n);
EXIT_IF(ret < 0,"Ecriture du nombre de noeuds dans le dataset HDF TMP",NULL);
ret = _MEDdatasetFermer(tid);
EXIT_IF(ret < 0,"Fermeture du dataset HDF TMP",NULL);
/* Fermeture de l'accès aux connectivites */
ret = H5Gunlink(gid,(char *)(MED_NOM_NOD));
EXIT_IF(ret < 0,"Suppression des anciennes connectivités",NULL);
ret = H5Gmove(gid,"TMP",(char *)(MED_NOM_NOD));
EXIT_IF(ret < 0,"Mise en place des nouvelles connectivités",NULL);
/* on libere la memoire */
free(old_conn);
free(conn);
}
/* Mise a niveau des noms */
nom = (char *) malloc(n*ANCIEN_MED_TAILLE_PNOM+1);
EXIT_IF(nom == NULL,NULL,NULL);
nouvelle_chaine = (char *) malloc(n*MED_TAILLE_PNOM+1);
EXIT_IF(nouvelle_chaine == NULL,NULL,NULL);
ret = _MEDdatasetStringLire(gid,(char *)(MED_NOM_NOM),nom);
if (ret == 0) {
_MED23v30stringConvert(nouvelle_chaine, MED_TAILLE_PNOM,
nom, ANCIEN_MED_TAILLE_PNOM, n );
/* MAJ_21_22_chaine(nom,nouvelle_chaine,n); */
H5Gunlink(gid,(char *)(MED_NOM_NOM));
dimd[0] = n*MED_TAILLE_PNOM+1;
ret = _MEDdatasetStringEcrire(gid,(char *)(MED_NOM_NOM),dimd,nouvelle_chaine);
EXIT_IF(ret < 0,"Ecriture des nouveaux noms des éléments",NULL);
did = _MEDdatasetOuvrir(gid,(char *)(MED_NOM_NOM));
ret = _MEDattrEntierEcrire(did,(char *)(MED_NOM_NBR),&n);
ret = _MEDdatasetFermer(did);
}
free(nom);
free(nouvelle_chaine);
/* on ferme avant de passer au type geometrique suivant */
ret = _MEDdatagroupFermer(gid);
EXIT_IF(ret < 0,"Fermeture de l'accès aux mailles",NULL);
}
/* On ferme tout */
ret = _MEDdatagroupFermer(eid);
EXIT_IF(ret < 0,"Fermeture de l'accès aux mailles",NULL);
}
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 _MEDsubdomainCorrespondenceSizeInfo30(int dummy, ...) {
med_err _ret=-1;
med_idt _datagroup1=0,_dataset=0;
int _num;
char _path[MED_TAILLE_JNT+2*MED_NAME_SIZE+2+2*MED_MAX_PARA+1+4*MED_TAILLE_NOM_ENTITE+4]=MED_JNT;
char _datagroupname1[2*MED_TAILLE_NOM_ENTITE+2]="";
char _cstpname[2*MED_MAX_PARA+1]="";
med_sorting_type _sortingtype=0;
med_int _intlocalentitype;
med_int _intlocalgeotype;
med_int _intremoteentitype;
med_int _intremotegeotype;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, char * , const , jointname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, int , , corit );
MED_VARGS_DECL(, med_entity_type *, const , localentitype );
MED_VARGS_DECL(, med_geometry_type *, const , localgeotype );
MED_VARGS_DECL(, med_entity_type *, const , remoteentitype );
MED_VARGS_DECL(, med_geometry_type *, const , remotegeotype );
MED_VARGS_DECL(, med_int *, const , nentitycor );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, char * , const , jointname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, int , , corit );
MED_VARGS_DEF(, med_entity_type *, const , localentitype );
MED_VARGS_DEF(, med_geometry_type *, const , localgeotype );
MED_VARGS_DEF(, med_entity_type *, const , remoteentitype );
MED_VARGS_DEF(, med_geometry_type *, const , remotegeotype );
MED_VARGS_DEF(, med_int *, const , nentitycor );
MED_VARGS_DEF(, med_err * ,, fret );
_num = corit -1;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if ( MEDmeshSortingTypeRd(fid,meshname,&_sortingtype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API," MEDmeshSortingTypeRd");
SSCRUTE(meshname);ISCRUTE_int(_sortingtype);goto ERROR;
}
strcat( _path, meshname);
strcat( _path, "/");
strcat( _path, jointname);
strcat( _path, "/");
_MEDgetComputationStepName(_sortingtype,numdt,numit,&_path[strlen(_path)]);
strcat( _path, "/");
/*
* On recupere le nom de <localentitype>[.<localgeotype>].<remoteentitype>[.<remotegeotype>]
*/
if ( _MEDobjectGetName(fid, _path ,_num, &_path[strlen(_path)]) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(corit);
goto ERROR;
}
if ( (_datagroup1 = _MEDdatagroupOuvrir(fid,_path)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*lecture localentitype et localgeotype */
if (_MEDattrEntierLire(_datagroup1,MED_NOM_ENT,&_intlocalentitype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_ENT);
ISCRUTE(_intlocalentitype);goto ERROR;
}
*localentitype = (med_entity_type) _intlocalentitype;
if (_MEDattrEntierLire(_datagroup1,MED_NOM_GEO,&_intlocalgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
ISCRUTE(_intlocalgeotype);goto ERROR;
}
*localgeotype = (med_geometry_type) _intlocalgeotype;
/*lecture remoteentitype et remotegeotype */
if (_MEDattrEntierLire(_datagroup1,MED_NOM_END,&_intremoteentitype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_ENT);
ISCRUTE(_intremoteentitype);goto ERROR;
}
*remoteentitype = (med_entity_type) _intremoteentitype;
if (_MEDattrEntierLire(_datagroup1,MED_NOM_GED,&_intremotegeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
ISCRUTE(_intremotegeotype);goto ERROR;
}
*remotegeotype = (med_geometry_type) _intremotegeotype;
if ((_dataset = _MEDdatasetOuvrir(_datagroup1,MED_NOM_COR)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);
goto ERROR;
}
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,nentitycor) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nentitycor);
goto ERROR;
}
_ret = 0;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COR);
ISCRUTE_id(_dataset);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_datagroup1);
}
va_end(params);
*fret = _ret;
return;
}
med_int
MEDnChamp(med_idt fid, int indice)
{
int n1;
med_int n2;
med_idt datagroup;
med_err ret;
char nomdatagroup[MED_TAILLE_NOM+1];
int num;
char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
if (indice < 0)
return -1;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le Data Group cha n'existe pas et indice == 0 => 0
* sinon erreur => erreur
*/
strcpy(chemin,MED_CHA);
/*
* Si indice == 0 => nombre de champs
*/
if (indice == 0)
{
n1 = 0;
_MEDnObjets(fid,chemin,&n1);
n2 = n1;
}
/*
* Si indice > 0 => nbre de composants
*/
if (indice > 0)
{
/*
* On recupere le nom du champ
*/
num = indice-1;
if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0)
return -1;
strcat(chemin,nomdatagroup);
/*
* On recupere le nombre de composants
*/
if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NCO,&n2)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
return -1;
}
return n2;
}
void
_MEDmeshnEntity30(int dummy, ...)
{
med_access_mode _MED_ACCESS_MODE;
med_int _ret=-1,_err=-1;
med_idt _meshid=0, _datagroup=0,_datagroupf=0,_datagroup1=0;
med_idt _datagroup2=0,_datagroup3=0,_datagroup4=0,_dataset=0;
char _meshpath [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
char _datagroupname1 [2*MED_MAX_PARA+1] ="";
char _datagroupname2 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname3 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname4 [MAX(MED_TAILLE_VARATR,MED_TAILLE_COOTRF)]="";
char _datasetconame [3 + 1 + 3 + 1 ] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _datasetname [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype = 0;
med_int _intsortingtype = 0;
med_int _profilearraysize = 0;
med_int _changement=0, _changement_s=0, _transformation=0;
med_bool _changement_co = MED_FALSE;
med_size _n=0;
med_int _intn=0;
med_bool _isasupportmesh = MED_FALSE;
med_bool _isasoftlink = MED_FALSE;
med_bool _datasetexist = MED_FALSE;
med_int _ntmpmeddatatype = 1;
med_data_type _tmpmeddatatype[4] = {MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE};
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _intmeshtype = 0;
med_int _meshdim = 0;
int _i = 0;
med_connectivity_mode _cmode ;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_cmode = cmode;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/*
* Ouverture du datagroup de niveau 1 <_meshpath>/<meshname>
*/
NOFINALBLANK(meshname,ERROR);
if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(_meshpath); goto ERROR;
}
/* Lecture de la dimension du maillage */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
/* Lecture du type de maillage (attribut MED_NOM_TYP) */
if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
}
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
/* Lecture de l'attribut MED_NOM_GTY */
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype= (med_grid_type) _intgridtype;
}
/*
* Ouverture du datagroup de niveau 2 <numdt>.<numit>
*/
if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
}
_sortingtype = (med_sorting_type) (_intsortingtype);
_MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
}
/*
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_CGT);goto ERROR;
}
*changement = (med_bool) _changement;
*transformation = MED_FALSE;
/*
* Gestion entitytype == MED_UNDEF_ENTITY_TYPE
*/
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) {
_n=0; goto SORTIE;
}
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
_err=_MEDnObjects(_datagroup1,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
goto SORTIE;
}
/*
* Ouverture du datagroup de niveau 3 <entitytype>
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
}
if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
*changement = (med_bool) MED_FALSE;
_n=0;_datagroup2=0;
goto SORTIE;
}
/* MAJ du changement pour le type d'entité <entitytype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup2,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
/*
* Ouverture du datagroup de niveau 4 <geotype>
*/
/* Pas Utilisation pour MED_NODE */
if ( geotype == MED_GEO_ALL ) {
_err=_MEDnObjects(_datagroup2,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname2);
goto ERROR;
}
/*Par construction du modèle, le tableau de coordonnées preexiste aux autres */
if ( ( entitytype == MED_NODE ) && (_n > 0) ) _n=1;
goto SORTIE;
}
if ( entitytype != MED_NODE ) {
/* Lecture du nom de type géométrique */
/*TODO : Remplacer les deux appels suivants par un seul gérant les geotype dynamiques et statiques*/
if ( entitytype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid, geotype,_datagroupname3) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else
if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);goto ERROR;
}
if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
_n=0;
*changement = MED_FALSE;
goto SORTIE;
}
}
if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
/* MAJ du changement pour le type géométrique d'entité <geotype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
* Prend en charge le cas d'un dataset vide écrit pour un typegeo donné (CHGT==1)
*/
if (_datagroup3) {
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
}
/*
* Lecture du flag de modification sur autre chose que MED_CONNECTIVITY,MED_COORDINATE,MED_COORDINATE_AXIS<i>
*
*/
if ( _MEDattrEntierLire(_datagroup,MED_NOM_CGS,&_changement_s) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGS);goto ERROR;
}
/* 1) Lorsque l'utilisateur interroge un <meddatatype> qui est relatif a des coordonnées (famille,....) il faut mettre
* le flag chgt à jour par rapport à des modifications potentiellement effectuées sur ces coordonnées
* <=>
* Si on interroge autre chose que MED_CONNECTIVITY,MED_COORDINATE
* et qu'un changement est présent sur MED_CONNECTIVITY,MED_COORDINATE
* le flag chgt doit être positionné à vrai
* Une demande entitype==MED_NODE && (meddatatype == MED_COORDINATE_AXIS1)||(meddatatype == MED_COORDINATE_AXIS2)
* ||(meddatatype === MED_COORDINATE_AXIS3) est assimilée à une demande concernant des coordonnées
* <=>
* Y-a-t'il une modification des datasets COO(si NOE)| NOD|DES(si !NOE)
*/
/* 2)
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et que le cmode n'a pas été
* spécifié par l'utilisateur.
* Cette Information est necessaire pour construire le nom du dataset.
*/
if ( (meddatatype != MED_CONNECTIVITY) && ( meddatatype != MED_COORDINATE )
&& (meddatatype != MED_COORDINATE_AXIS1)
&& (meddatatype != MED_COORDINATE_AXIS2)
&& (meddatatype != MED_COORDINATE_AXIS3)
&& (meddatatype != MED_INDEX_FACE)
&& (meddatatype != MED_INDEX_NODE)) {
if (entitytype == MED_NODE) {
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
if ( (_gridtype == MED_CARTESIAN_GRID) ||
(_gridtype == MED_CURVILINEAR_GRID) ) {
_ntmpmeddatatype=_meshdim;
_tmpmeddatatype[0] = MED_COORDINATE_AXIS1;
_tmpmeddatatype[1] = MED_COORDINATE_AXIS2;
_tmpmeddatatype[2] = MED_COORDINATE_AXIS3;
} else if (_gridtype == MED_CURVILINEAR_GRID ) {
/*Les grilles curvilinéaires utilisent MED_COORDINATE_AXISx pour stocker la structure et le tableau MED_COORDINATE pour stocker les coordonnées des noeuds */
++_ntmpmeddatatype;
_tmpmeddatatype[3] = MED_COORDINATE;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
} else
_tmpmeddatatype[0] = MED_COORDINATE;
} else {
switch (geotype) {
case MED_POLYHEDRON:
_ntmpmeddatatype=3;
_tmpmeddatatype[2] = MED_CONNECTIVITY;
_tmpmeddatatype[1] = MED_INDEX_FACE;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
case MED_POLYGON:
_ntmpmeddatatype=2;
_tmpmeddatatype[1] = MED_CONNECTIVITY;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
default:
if ( ( (med_mesh_type) _intmeshtype ) == MED_STRUCTURED_MESH ) {
_ntmpmeddatatype=0;
break;
}
_tmpmeddatatype[0] = MED_CONNECTIVITY;
if ( cmode == MED_NO_CMODE ) {
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_NODAL,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
if ( _datasetexist ) _cmode= MED_NODAL;
else
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_DESCENDING,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
} else
_cmode = MED_DESCENDING;
}
}
}
*changement = MED_FALSE;
for (_i=0; _i < _ntmpmeddatatype ;++_i) {
if ( _MEDgetDatasetChgt( _datagroup, _tmpmeddatatype[_i], _cmode,
&_isasoftlink, &_changement_co ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"getDatasetChgt");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
*changement |= _changement_co;
}
}
/*
* Niveau de datagroup 5 supplémentaire pour les éléments de structure ou les transformations.
*/
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) ) {
if (meddatatype == MED_VARIABLE_ATTRIBUTE)
strcpy(_datagroupname4,MED_VARATR_NOM);
else
strcpy(_datagroupname4,MED_COOTRF_NOM);
if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
_n=0;
goto SORTIE;
}
}
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) )
_datagroupf=_datagroup4;
else
_datagroupf=_datagroup;
/*
* Construction du nom du dataset à lire
*/
if ( _MEDgetDatasetName(_datasetname,meddatatype,cmode) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetName");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
/*
* MAJ du champ transformation pour le (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if (_datagroup4) {
if ( _MEDattrEntierLire(_datagroup4,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
if ( (_dataset = _MEDdatasetOuvrir(_datagroupf,_datasetname)) < 0) {
_n=0;_dataset=0;*transformation = (med_bool) MED_FALSE;
/* if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname); */
/* SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4); */
/* ISCRUTE_size(_n); */
/* goto ERROR; */
/* } */
goto SORTIE;
}
if (!_datagroup4) {
/*
* Lire l'attribut CGT pour savoir si le dataset a changé
* n'a pas de sens si le dataset est en fait un lien vers le dataset précedent.
* En testant si le dataset est un lien on détermine si un changement a eu lieu
* depuis la séquence de calcul précédente.
* Ce traitement ne doit pas être effectué pour le pas de temps initial et pour
* (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if ( _MEDisasoftlink(_datagroupf, _datasetname,MED_TRUE, &_isasoftlink ) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_LINK,_datasetname);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
ISCRUTE_size(_n);goto ERROR;
}
if (_isasoftlink)
_transformation = MED_FALSE;
else {
if ( _MEDattrEntierLire(_dataset,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
}
*transformation = (med_bool) _transformation;
if ( ( meddatatype == MED_CONNECTIVITY) && ( meddatatype == MED_COORDINATE ) ) {
*transformation &= (med_bool) !_changement_s;
}
/*
* Attribut PFL (nombre de noeuds ou d'elements)
* la lecture est faite sur le datagroup _datagroup et non sur _datagroupf
* pour (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
_profilearraysize = 0;
profilename[0]='\0';
if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(profilename,_profilename,MED_NAME_SIZE+1);
profilename[MED_NAME_SIZE]='\0';
if ( ( _profilearraysize = MEDprofileSizeByName( fid,_profilename) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_profilename);SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
*profilesize=(med_int) _profilearraysize;
/*
* Attribut NBR (nombre d'entité)
*/
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_intn) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
SSCRUTE(_datasetname);SSCRUTE(MED_NOM_NBR);ISCRUTE_size(_n);goto ERROR;
}
_n = _intn;
if (_profilearraysize)
switch(storagemode) {
case MED_GLOBAL_PFLMODE :
break;
case MED_COMPACT_PFLMODE :
if ( meddatatype!=MED_COORDINATE_TRSF )
_n=_profilearraysize;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_STORAGEMODE,MED_ERR_VALUE_MSG);
ISCRUTE_int(storagemode);goto ERROR;
break;
}
SORTIE:
_ret = _n;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
ISCRUTE_id(_dataset);
}
if (_datagroup4>0) if (_MEDdatagroupFermer(_datagroup4) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname4);
ISCRUTE_id(_datagroup4);
}
if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
ISCRUTE_id(_datagroup3);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
/* _MEDobjetsOuverts(fid); */
*fret = _ret;
va_end(params);
return;
}
void
_MEDfieldInfoByName30(int dummy, ...) {
med_err _ret=-1,_err=-1;
med_idt _fieldgid=0,_meshgid=0,_linkgid=0;
char _fieldpath[MED_TAILLE_CHA+MED_NAME_SIZE+1]=MED_CHA;
char _meshpath [MED_TAILLE_MAA+MED_NAME_SIZE+1]=MED_MAA;
char _linkpath [MED_TAILLE_LIENS+MED_NAME_SIZE+1]=MED_LIENS;
med_size _ncstp=0;
med_int _n=0;
med_int _intfieldtype=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_field_type *, const , fieldtype );
MED_VARGS_DECL(, char *, const , componentname );
MED_VARGS_DECL(, char *, const , componentunit );
MED_VARGS_DECL(, char *, const , dtunit );
MED_VARGS_DECL(, med_int *, const , ncstp );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_field_type *, const , fieldtype );
MED_VARGS_DEF(, char *, const , componentname );
MED_VARGS_DEF(, char *, const , componentunit );
MED_VARGS_DEF(, char *, const , dtunit );
MED_VARGS_DEF(, med_int *, const , ncstp );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
strcat(_fieldpath,fieldname);
/*
* On recupere le nombre de composants
*/
if ((_fieldgid = _MEDdatagroupOuvrir(fid,_fieldpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_fieldpath);
goto ERROR;
}
if ( _MEDattrEntierLire(_fieldgid,MED_NOM_NCO,&_n) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NCO);
SSCRUTE(_fieldpath);goto ERROR;
}
/*
* La liste des attributs
*/
/* Lecture de l'attribut MED_NOM_TYP */
if ( _MEDattrEntierLire(_fieldgid,MED_NOM_TYP,&_intfieldtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(MED_NOM_TYP);
goto ERROR;
}
*fieldtype = (med_field_type) (_intfieldtype);
/*
* Les infos sur les composantes du champ
*/
if (_MEDattrStringLire(_fieldgid,MED_NOM_NOM,_n*MED_SNAME_SIZE,
componentname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_NOM);
SSCRUTE(componentname);goto ERROR;
}
if (_MEDattrStringLire(_fieldgid,MED_NOM_UNI,_n*MED_SNAME_SIZE,
componentunit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_UNI);
SSCRUTE(componentunit);goto ERROR;
}
/*MODEL : MED_NOM_UNI vient du niveau en dessous
Cree ou ouvre l'attribut MED_NOM_UNI pour écriture
*/
if ( _MEDattrStringLire(_fieldgid,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_fieldpath);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_MAI */
if ( _MEDattrStringLire(_fieldgid,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(MED_NOM_MAI);SSCRUTE(meshname);
goto ERROR;
}
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
/* Nombre d'étapes de calcul*/
if ( (_err=_MEDnObjects(_fieldgid,".",&_ncstp)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_fieldpath);
goto ERROR;
}
*ncstp = (med_int) _ncstp;
_ret = 0;
ERROR:
if (_fieldgid>0) if (_MEDdatagroupFermer(_fieldgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_fieldpath);
ISCRUTE_id(_fieldgid);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
void
_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 _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;
}
med_int
MEDnEntMaa(med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent,
med_geometrie_element type_geo, med_connectivite type_conn)
{
med_idt root=0, maaid=0, entid=0,geoid=0, dataset=0;
med_int 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];
char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
med_int res = 0;
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)
goto ERROR;
/*
* On met a jour le nom du Data Group representant
* le type des entites
*/
if ( _MEDnomEntite(nom_ent,_type_ent) < 0)
goto ERROR;
/*
* Si le Data Group des entites n'existe pas => res = 0
*/
entid = _MEDdatagroupOuvrir(maaid,nom_ent);
/*
* Pour les mailles, les faces et le aretes
* si le Data Group du type geometrique n'existe pas => res = 0
*/
if ((_type_ent==MED_MAILLE)||(_type_ent==MED_FACE)||(_type_ent==MED_ARETE))
{
if ( _MEDnomGeometrie30(nom_geo,type_geo) < 0)
goto ERROR;
geoid = _MEDdatagroupOuvrir(entid,nom_geo);
}
else
geoid = -1;
/*
* Ouverture du Data Set renvoye par _MEDnomDataset()
* S'il n'existe pas => erreur
* Sinon lecture de l'attribut NBR
*/
if (geoid == -1)
root = entid;
else
root = geoid;
if ( _MEDnomDataset(nom_dataset,quoi,type_conn) < 0)
goto ERROR;
dataset = _MEDdatasetOuvrir(root,nom_dataset);
if (dataset > 0)
if ( _MEDattrEntierLire(dataset,MED_NOM_NBR,&res) < 0)
goto ERROR;
/*
* On ferme tout
*/
ret=res;
ERROR :
if (dataset > 0)
if ( _MEDdatasetFermer(dataset) < 0)
ret=-1;
if (geoid > 0)
if ( _MEDdatagroupFermer(geoid) < 0)
ret=-1;
if (entid > 0)
if ( _MEDdatagroupFermer(entid) < 0)
ret=-1;
if (maaid > 0)
if ( _MEDdatagroupFermer(maaid) < 0)
ret=-1;
/*ICI;_MEDobjetsOuverts(fid);*/
return ret;
}
med_err
MEDindicesCoordEcr(med_idt fid,char *maillage,med_int mdim,med_float *indices,
med_int n,med_int axe,char *comp,char *unit)
{
med_idt maaid, noeid, dataset;
med_err ret;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
med_int att;
med_maillage maillage_type;
med_type_grille type;
/*
* Si axe > mdim => erreur
*/
if (axe > mdim)
return -1;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le maillage n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maillage);
if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/*
* Si le maillage est de type MED_NON_STRUCTURE => erreur
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_TYP,&att)) < 0)
return -1;
maillage_type = (med_maillage) att;
if (maillage_type == MED_NON_STRUCTURE)
return -1;
/*
* Si la grille n'est pas de type MED_GRILLE_CARTESIENNE ou
* MED_GRILLE_POLAIRE => erreur
*/
if ((ret = _MEDattrEntierLire(maaid,MED_NOM_GTY,&att)) < 0)
return -1;
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long (normalement 64bits),
du coup sur machines 64 bits _MEDattrEntierLire utilise
le type hdf NATIVE_LONG, ce genere parfois un warning
*/
type = (med_type_grille) att;
if ((type != MED_GRILLE_CARTESIENNE) && (type != MED_GRILLE_POLAIRE))
return -1;
/*
* Si le groupe HDF "NOE" n'existe pas => erreur
*/
if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
if ((noeid = _MEDdatagroupCreer(maaid,MED_NOM_NOE)) < 0)
return -1;
/*
* On ecrit le tableau d'indice dans un dataset HDF
*/
switch(axe) {
case 1 :
strcpy(nom_dataset,MED_NOM_IN1);
break;
case 2 :
strcpy(nom_dataset,MED_NOM_IN2);
break;
case 3 :
strcpy(nom_dataset,MED_NOM_IN3);
break;
default :
return -1;
}
dimd[0] = n;
if ((ret = _MEDdatasetNumEcrire(noeid,nom_dataset,MED_FLOAT64,MED_FULL_INTERLACE,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,
MED_NOPG,dimd,(unsigned char*) indices)) < 0)
return -1;
/*
* On re-ouvre le dataset HDF pour y placer des attributs
*/
if ((dataset = _MEDdatasetOuvrir(noeid,nom_dataset)) < 0)
return -1;
/*
* Attribut NBR (taille du tableau d'indices)
*/
if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n)) < 0)
return -1;
/*
* Attribut "NOM" (nom de la composante)
*/
if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_NOM,MED_TAILLE_PNOM,comp)) < 0)
return -1;
/*
* Attribut "UNI" (unite de la composante)
*/
if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_UNI,MED_TAILLE_PNOM,unit)) < 0)
return -1;
/*
* On ferme tout
*/
if ((ret = _MEDdatasetFermer(dataset)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(noeid)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(maaid)) < 0)
return -1;
return 0;
}
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
_MEDlocalizationInfoByName236(int dummy, ...) {
med_idt _lzid=0;
med_err _ret=-1;
char _path[MED_TAILLE_GAUSS+MED_NAME_SIZE+1]=MED_GAUSS;
med_int _intgeotype = -1;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , localizationname );
MED_VARGS_DECL(, med_geometry_type *, const , geotype );
MED_VARGS_DECL(, med_int *, const , spacedimension );
MED_VARGS_DECL(, med_int *, const , nipoint );
MED_VARGS_DECL(, char *, const , geointerpname );
MED_VARGS_DECL(, char *, const , sectionmeshname );
MED_VARGS_DECL(, med_int *, const , nsectionmeshcell );
MED_VARGS_DECL(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , localizationname );
MED_VARGS_DEF(, med_geometry_type *, const , geotype );
MED_VARGS_DEF(, med_int *, const , spacedimension );
MED_VARGS_DEF(, med_int *, const , nipoint );
MED_VARGS_DEF(, char *, const , geointerpname );
MED_VARGS_DEF(, char *, const , sectionmeshname );
MED_VARGS_DEF(, med_int *, const , nsectionmeshcell );
MED_VARGS_DEF(, med_geometry_type *, const , sectiongeotype );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* ouverture du groupe /GAUSS/"nom"
*/
strcat(_path,localizationname);
if ((_lzid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);
goto ERROR;
}
/*
* Lecture de l'attribut MED_NOM_NBR
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_NBR,nipoint) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(*nipoint);
goto ERROR;
}
/*
* On lit <typgeo> sous forme d'attribut
*/
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long,
du coup sur machines 64 bits _MEDattributeIntWr utilise
le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
un enum.
*/
if (_MEDattrEntierLire(_lzid,MED_NOM_GEO,&_intgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE(_intgeotype);
goto ERROR;
};
*geotype = (med_geometry_type) _intgeotype;
*spacedimension = (_intgeotype/100);
sectionmeshname[0]='\0';
geointerpname[0]='\0';
*nsectionmeshcell=0;
*sectiongeotype=MED_UNDEF_GEOTYPE;
_ret = 0;
ERROR:
if ( _lzid > 0 ) if ( _MEDdatagroupFermer(_lzid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_GAUSS);
ISCRUTE_id(_lzid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDfield23ComputingStepMeshInfo30(int dummy,...)
{
med_err _ret=-1;
med_idt _gid=0,_datagroup1=0,_meshgid=0,_linkgid=0;
int _num;
char _datagroupname1[2*MED_MAX_PARA+1]="";
char _path [(MED_FIELD_GRP_SIZE+MED_NAME_SIZE+1)+2*MED_MAX_PARA+1]=MED_FIELD_GRP;
char _meshpath [MED_MESH_GRP_SIZE+MED_NAME_SIZE+1]=MED_MESH_GRP;
char _linkpath [MED_TAILLE_LIENS+MED_NAME_SIZE+1]=MED_LIENS;
char _cstpname[2*MED_MAX_PARA+1]="";
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, int , , csit );
MED_VARGS_DECL(, med_int *, const , numdt );
MED_VARGS_DECL(, med_int *, const , numit );
MED_VARGS_DECL(, med_float *, const , dt );
MED_VARGS_DECL(, med_int *, const , nmesh );
MED_VARGS_DECL(, char *, const , meshname );
MED_VARGS_DECL(, med_bool *, const , localmesh );
MED_VARGS_DECL(, med_int *, const , meshnumdt );
MED_VARGS_DECL(, med_int *, const , meshnumit );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, int , , csit );
MED_VARGS_DEF(, med_int *, const , numdt );
MED_VARGS_DEF(, med_int *, const , numit );
MED_VARGS_DEF(, med_float *, const , dt );
MED_VARGS_DEF(, med_int *, const , nmesh );
MED_VARGS_DEF(, char *, const , meshname );
MED_VARGS_DEF(, med_bool *, const , localmesh );
MED_VARGS_DEF(, med_int *, const , meshnumdt );
MED_VARGS_DEF(, med_int *, const , meshnumit );
MED_VARGS_DEF(, med_err * ,, fret );
_num=csit-1;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
/*
* On construit le nom du datagroup
*/
strcat(_path,fieldname);
/* Lecture de l'attribut MED_NOM_MAI */
if ( _MEDattributeStringRdByName(fid,_path,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_MAI);SSCRUTE(meshname);
goto ERROR;
}
/*
* On recupere le nom de la séquence de calcul
*/
if ( _MEDobjectGetName(fid, _path ,_num, _cstpname) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);ISCRUTE_int(_num);
goto ERROR;
}
strcat(_path,"/");
strcat(_path,_cstpname);
if ((_gid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Lecture des attributs
*/
if (_MEDattrEntierLire(_gid,MED_NOM_NDT,(med_int*) numdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NDT);
SSCRUTE(_path);ISCRUTE(*numdt);goto ERROR;
}
if (_MEDattrFloatLire(_gid,MED_NOM_PDT,(med_float*) dt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_PDT);
SSCRUTE(_path);RSCRUTE(*dt);goto ERROR;
}
if (_MEDattrEntierLire(_gid,MED_NOM_NOR,(med_int*) numit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_NOR);
SSCRUTE(_path);ISCRUTE(*numit);goto ERROR;
}
if (_MEDattrEntierLire(_gid,MED_NOM_RDT,(med_int*) meshnumdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_RDT);
SSCRUTE(_path);ISCRUTE(*meshnumdt);goto ERROR;
}
if (_MEDattrEntierLire(_gid,MED_NOM_ROR,(med_int*) meshnumit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_NOM_ROR);
SSCRUTE(_path);ISCRUTE(*meshnumit);goto ERROR;
}
/* Maillage local ou distant */
strcat(_meshpath,meshname);
/* Le maillage est il distant */
if ( (_meshgid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
/* Verifie que le maillage est bien référencé comme distant */
strcat(_linkpath,meshname);
if ((_linkgid = _MEDdatagroupOuvrir(fid,_linkpath)) < 0) {
/* MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_MESH,MED_ERR_FIELD_MSG); */
/* SSCRUTE(fieldname);SSCRUTE(_meshpath);SSCRUTE(_linkpath); */
/* goto ERROR; */
*localmesh = MED_FALSE;
}
*localmesh = MED_FALSE;
} else
*localmesh = MED_TRUE;
*nmesh = 1;
_ret = 0;
ERROR:
if (_gid>0) if (_MEDdatagroupFermer(_gid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_gid);
}
if (_meshgid>0) if (_MEDdatagroupFermer(_meshgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshgid);
}
if (_linkgid>0) if (_MEDdatagroupFermer(_linkgid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_linkpath);
ISCRUTE_id(_linkgid);
}
va_end(params);
*fret = _ret;
return;
}
void _MEDmeshGridIndexCoordinateRd30(int dummy, ...) {
med_idt _meshid=0;
med_err _ret = -1;
med_data_type _datatype = MED_UNDEF_DATATYPE;
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _meshdim = 0;
char _meshpath[MED_TAILLE_MAA+MED_NAME_SIZE+1]=MED_MAA;
med_int _intaxistype=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char* , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_int , , axis );
MED_VARGS_DECL(, med_float *, const , gridindex );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char* , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_int , , axis );
MED_VARGS_DEF(, med_float *, const , gridindex );
MED_VARGS_DEF(, med_err * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
strcat(_meshpath,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_meshpath); goto ERROR;
}
/*
* Lecture du type de grille (attribut MED_NOM_GTY)
*/
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype=(med_grid_type) _intgridtype;
if ((_gridtype != MED_CARTESIAN_GRID) && (_gridtype != MED_POLAR_GRID)) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_REP */
if ( _MEDattrEntierLire(_meshid,MED_NOM_REP,&_intaxistype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_REP);
ISCRUTE(_intaxistype);goto ERROR;
}
if ((med_mesh_type)( _intaxistype) != MED_CARTESIAN ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_AXISTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(_intaxistype);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_DIM */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
if (axis > _meshdim ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(_meshdim);ISCRUTE(axis);goto ERROR;
}
/*
* On ecrit le tableau d'indice dans un dataset HDF
*/
switch(axis)
{
case 1 :
_datatype = MED_COORDINATE_AXIS1;
break;
case 2 :
_datatype = MED_COORDINATE_AXIS2;
break;
case 3 :
_datatype = MED_COORDINATE_AXIS3;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
if (_MEDmeshAdvancedRd(fid,
meshname,
_datatype,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
MED_NODE,
MED_NONE,
MED_NO_CMODE,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
(unsigned char *) gridindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedRd");
goto ERROR;
}
_ret = 0;
ERROR:
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
va_end(params);
*fret = _ret;
return;
}
void
_MEDequivalenceCorrespondenceRd30(int dummy, ...) {
med_idt _root=0,_eqid=0,_meshid=0,_cstpid=0,_datagroup2=0;
med_idt _dataset=0;
med_err _ret=-1;
char _path[MED_TAILLE_EQS+2*MED_NAME_SIZE+2]=MED_EQS;
char _computationstepname[2*MED_MAX_PARA+1]="";
char _datagroupname2[2*MED_TAILLE_NOM_ENTITE+2]="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype=0;
med_filter _filter = MED_FILTER_INIT;
med_geometry_type _geotype=MED_NONE;
med_int _nentity=0;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, char * , const , equivname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(, med_int *, const , correspondence );
MED_VARGS_DECL(, med_err * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, char * , const , equivname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(, med_int *, const , correspondence );
MED_VARGS_DEF(, med_err * ,, fret );
if ( entitype == MED_NODE_ELEMENT ) _geotype=MED_NODE ;
if ( (geotype / 100 ) > 2 ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);ISCRUTE_int(geotype);
goto ERROR;
}
if ( entitype != MED_NODE ) _geotype=geotype ;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
/*
* Ouverture du dataGroup /EQS/
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
/*
* Ouverture du dataGroup <meshname>
*/
if ((_meshid = _MEDdatagroupOuvrir(_root,meshname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,meshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,meshname);
/*
* Si le Data Group "/EQS/<meshname>/<equivname>" n'existe pas, on le cree
*/
if ((_eqid = _MEDdatagroupOuvrir(_meshid,equivname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,equivname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,"/");
strcat(_path,equivname);
if ( MEDmeshSortingTypeRd(fid,meshname,&_sortingtype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API," MEDmeshSortingTypeRd");
SSCRUTE(meshname);ISCRUTE_int(_sortingtype);goto ERROR;
}
_MEDgetComputationStepName(_sortingtype,numdt,numit,_computationstepname);
if ((_cstpid = _MEDdatagroupOuvrir(_eqid,_computationstepname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_computationstepname);
SSCRUTE(_path);goto ERROR;
}
/*
* Ouverture du datagroup de niveau <entitype>[.<geotype>]
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitype);SSCRUTE(equivname);goto ERROR;
}
if ( entitype != MED_NODE ) {
if ( _MEDgetInternalGeometryTypeName(_geotypename,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(equivname);goto ERROR;
}
strcat(_datagroupname2,".");
strcat(_datagroupname2,_geotypename);
}
if ( (_datagroup2 = _MEDdatagroupOuvrir(_cstpid,_datagroupname2)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_datagroupname2);
SSCRUTE(_path);SSCRUTE(equivname);goto ERROR;
}
if ((_dataset = _MEDdatasetOuvrir(_datagroup2,MED_NOM_COR)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);SSCRUTE(_datagroupname2);
goto ERROR;
}
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_nentity) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);SSCRUTE(_datagroupname2);
SSCRUTE(MED_NOM_NBR);ISCRUTE(_nentity);goto ERROR;
}
if ( MEDfilterEntityCr(fid, _nentity, 1, 2, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_PFLMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
if ( _MEDdatasetRd(_datagroup2,MED_NOM_COR,MED_INTERNAL_INT,&_filter, (unsigned char *) correspondence) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_COR);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
_ret=0;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COR);
ISCRUTE_id(_dataset);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
}
if (_cstpid>0) if (_MEDdatagroupFermer(_cstpid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_computationstepname);
ISCRUTE_id(_cstpid);SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
}
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,equivname);
ISCRUTE_id(_eqid);SSCRUTE(_path);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_eqid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_EQS);
ISCRUTE_id(_eqid);
}
va_end(params);
*fret = _ret;
return;
}
med_int
MEDjointnCorres (med_idt fid, char *maa, char *jn,
med_entite_maillage type_ent_local, med_geometrie_element typ_geo_local,
med_entite_maillage type_ent_distant, med_geometrie_element typ_geo_distant)
{
med_entite_maillage _type_ent_local = (med_entite_maillage) ( (int)(type_ent_local) % 10 );
med_entite_maillage _type_ent_distant = (med_entite_maillage) ( (int)(type_ent_distant) % 10 );
med_idt datagroup1=0,datagroup2=0;
med_int n=0, ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+2*MED_TAILLE_NOM+1];
char nomdatagroup[MED_TAILLE_NOM_ENTITE*4+3+1];
char tmp[MED_TAILLE_NOM_ENTITE+1];
med_size dimd[1];
/* if (typ_geo_local == MED_TETRA4 || typ_geo_local == MED_TETRA10 || */
/* typ_geo_local == MED_HEXA8 || typ_geo_local == MED_HEXA20 || */
/* typ_geo_local == MED_PENTA6 || typ_geo_local == MED_PENTA15 || */
/* typ_geo_local == MED_PYRA5 || typ_geo_local == MED_PYRA13 || */
/* typ_geo_distant == MED_TETRA4 || typ_geo_distant == MED_TETRA10 || */
/* typ_geo_distant == MED_HEXA8 || typ_geo_distant == MED_HEXA20 || */
/* typ_geo_distant == MED_PENTA6 || typ_geo_distant == MED_PENTA15 || */
/* typ_geo_distant == MED_PYRA5 || typ_geo_distant == MED_PYRA13) */
/* return -1; */
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* Si le Data Group de "JNT/Corres" n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
strcat(chemin,MED_JNT);
strcat(chemin,jn);
if ((datagroup1 = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE("Impossible d'ouvrir le datagroup : ");
SSCRUTE(chemin);
goto ERREUR;
}
/*
* Ecriture de la correspondance
* construction du tag HDF "reperant" la correspondance
*
*/
if ( _MEDnomEntite(nomdatagroup,_type_ent_local) < 0)
goto ERREUR;
if ((_type_ent_local != MED_NOEUD)) {
if ( _MEDnomGeometrie30(tmp,typ_geo_local) < 0) goto ERREUR;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
}
if ( _MEDnomEntite(tmp,_type_ent_distant) < 0) goto ERREUR;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
if ((_type_ent_distant != MED_NOEUD)) {
if ( _MEDnomGeometrie30(tmp,typ_geo_distant) < 0) goto ERREUR;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
}
/* le couple d'entite n'existe pas, on renvoie 0 */
if ((datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup)) < 0 ) goto SORTIE;
/* erreur : le couple d'entite existe mais on
ne peut lire l'attribut NBR */
if ( _MEDattrEntierLire(datagroup2,MED_NOM_NBR,&n) < 0) {
MESSAGE("Impossible de lire l'attribut NBR : ");
SSCRUTE(chemin);SSCRUTE(MED_NOM_NBR); goto ERREUR;
}
/*
* On ferme tout
*/
SORTIE:
ret= n;
ERREUR:
if (datagroup2 > 0 ) if ( _MEDdatagroupFermer(datagroup2) < 0) {
MESSAGE("Impossible de fermer le groupe : ");
SSCRUTE(chemin);SSCRUTE(nomdatagroup);ret=-1;
}
if (datagroup1 > 0 ) if ( _MEDdatagroupFermer(datagroup1) < 0) {
MESSAGE("Impossible de fermer le groupe : ");
SSCRUTE(chemin);ret= -1;
}
return (med_int) ret;
}
med_err
MEDscalaireEntierEcr(med_idt fid, char *scalaire,med_int val, med_int numdt, char *dt_unit, med_float dt, med_int numo)
{
med_err ret = 0;
med_idt gid,datagroup;
char nomdatagroup[2*MED_MAX_PARA+1];
char chemin[MED_TAILLE_NUM_DATA+MED_TAILLE_NOM+1];
med_int type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_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 ");
return -1;
}
/*
* Si le groupe HDF "scalaire" n'existe pas => erreur
*/
strcpy(chemin,MED_NUM_DATA);
strcat(chemin,scalaire);
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
return -1;
/* Creation du groupe HDF correspondant au couple <numdt>.<numoo> */
sprintf(nomdatagroup,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
/* Cree ou ouvre le datagroup nomdatagroup */
datagroup = 0;
if (((datagroup = _MEDdatagroupOuvrir(gid,nomdatagroup)) > 0)
&& ( MED_MODE_ACCES == MED_LECTURE_AJOUT ))
return -1;
else
if (datagroup < 0)
if ((datagroup = _MEDdatagroupCreer(gid,nomdatagroup)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_NDT */
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NDT,&numdt)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_PDT */
if ((ret = _MEDattrFloatEcrire(datagroup,MED_NOM_PDT,&dt)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_NOR */
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NOR,&numo)) < 0)
return -1;
/* Cree ou ouvre l'attribut MED_NOM_UNI */
if ( numdt == MED_NOPDT ) {
if ((ret = _MEDattrStringEcrire(datagroup,MED_NOM_UNI,MED_TAILLE_PNOM,MED_PNOM_BLANC)) < 0)
return -1;
} else
if ((ret = _MEDattrStringEcrire(datagroup,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0)
return -1;
/*
* Ecriture de la valeur scalaire
*/
if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,&type)) < 0)
return -1;
switch(type)
{
case MED_INT :
case MED_INT32 :
case MED_INT64 :
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_VAL,&val)) < 0)
return -1;
break;
default :
return -1;
}
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(gid)) < 0)
return -1;
return ret;
}