/*
* - Nom de la fonction : _MEDdatasetStringEcrire
* - Description : ecriture d'un dataset tableau de caracteres
* - Parametres :
* - pere (IN) : l'ID de l'objet HDF pere ou placer l'attribut
* - nom (IN) : le nom de l'attribut
* - dimd (IN) : profil du tableau
* - val (IN) : valeurs du tableau
* - Resultat : 0 en cas de succes, -1 sinon
*/
med_err _MEDdatasetStringEcrire(med_idt pere, char *nom, med_size *dimd, char *val)
{
med_idt dataset;
med_idt datatype = 0;
med_idt dataspace = 0;
med_err ret;
med_mode_acces MED_MODE_ACCES;
if ( (MED_MODE_ACCES = _MEDmodeAcces(pere) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier ");
return -1;
}
if ((dataset = H5Dopen(pere,nom)) < 0)
{
if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0)
return -1;
if((datatype = H5Tcopy(H5T_C_S1)) < 0)
return -1;
if((ret = H5Tset_size(datatype,1)) < 0)
return -1;
if ((dataset = H5Dcreate(pere,nom,datatype,dataspace,
H5P_DEFAULT)) < 0)
return -1;
}
else
if ( MED_MODE_ACCES == MED_LECTURE_AJOUT)
{
H5Dclose(dataset);
return -1;
}
else
{
if ((dataspace = H5Screate_simple(1,dimd,NULL)) < 0)
return -1;
if((datatype = H5Tcopy(H5T_C_S1)) < 0)
return -1;
if((ret = H5Tset_size(datatype,1)) < 0)
return -1;
}
if ((ret = H5Dwrite(dataset,datatype,H5S_ALL,H5S_ALL,
H5P_DEFAULT, val)) < 0)
return -1;
if (dataspace)
if((ret = H5Sclose(dataspace)) < 0)
return -1;
if (datatype)
if ((ret = H5Tclose(datatype)) < 0)
return -1;
if ((ret = H5Dclose(dataset)) < 0)
return -1;
return 0;
}
med_geometry_type
MEDstructElementCr(const med_idt fid,
const char* const modelname,
const med_int modeldim,
const char* const supportmeshname,
const med_entity_type sentitytype,
const med_geometry_type sgeotype
)
{
med_access_mode _MED_ACCESS_MODE;
med_err _err=-1;
med_idt _root=0,_elemid=0;
med_int _ret=-1;
char _path[MED_TAILLE_STRCT+MED_NAME_SIZE+1]=MED_STRCT;
med_size _tmpn=0;
med_geometry_type _stgeotype=0;
med_int _medintstgeotype = 0;
med_int _medintsgeotype = sgeotype;
med_int _intentitytype = sentitytype;
med_int _nnode=0,_ncell=0;
med_bool _chgt=MED_FALSE,_trsf=MED_FALSE;
/* char _entitytypename[MED_TAILLE_NOM_ENTITE+1]=""; */
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /STRUCT/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOpen(fid,_path)) < 0)
if ((_root = _MEDdatagroupCrOrderCr(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(modelname,ERROR);
/*
* Si le DataGroup /STRUCT/<modelname> n'existe pas, on le cree
*/
if ((_elemid = _MEDdatagroupOpen(_root,modelname)) < 0) {
if ((_elemid = _MEDdatagroupCreer(_root,modelname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,modelname);
SSCRUTE(_path);goto ERROR;
}
} else {
/*
* Lecture de l'attribut MED_NOM_NEO (num�ro de type g�om�trique associ� � un �l�ment de structure)
*/
if ( _MEDattrEntierLire(_elemid,MED_NOM_NEO,&_medintstgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NEO);ISCRUTE(_medintstgeotype);
goto ERROR;
}
_stgeotype = _medintstgeotype;
}
strcat(_path,modelname);
/*
* Creation/Ecriture de l'attribut MED_NOM_DIM (dimension de l'�l�ment)
*/
if ( _MEDattributeIntWr(_elemid,MED_NOM_DIM,&modeldim) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_DIM);ISCRUTE(modeldim);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_NOM (nom du maillage support)
*/
if ( _MEDattributeStringWr(_elemid,MED_NOM_NOM,MED_NAME_SIZE,supportmeshname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NOM);SSCRUTE(supportmeshname);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_ENT (type d'entit� support)
*/
/* if (_MEDgetEntityTypeName(_entitytypename,sentitytype) < 0) { */
/* MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG); */
/* ISCRUTE_int(sentitytype);SSCRUTE(_entitytypename);SSCRUTE(_path); */
/* goto ERROR; */
/* } */
if ( _MEDattributeIntWr(_elemid,MED_NOM_ENT,&_intentitytype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_ENT);ISCRUTE(_intentitytype);
goto ERROR;
}
/*
Lecture dans le maillages support du nombre de noeuds
S'il n'y a pas de maillage support : 1
*/
if (strlen(supportmeshname)) {
if ( (_nnode = MEDmeshnEntity(fid,supportmeshname,MED_NO_DT,MED_NO_IT,
MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE,
&_chgt,&_trsf) ) <= 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDmeshnEntity");
ISCRUTE(_nnode);goto ERROR;
}
} else {
_nnode=1;
}
if (strlen(supportmeshname)) {
if ( (_ncell = MEDmeshnEntity(fid,supportmeshname,MED_NO_DT,MED_NO_IT,
MED_CELL,sgeotype,MED_CONNECTIVITY,MED_NODAL,
&_chgt,&_trsf) ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDmeshnEntity");
ISCRUTE(_ncell);goto ERROR;
}
} else {
_ncell=0;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_GEO (type g�om�trique des mailles support)
*/
_medintsgeotype = sgeotype;
if ( _MEDattributeIntWr(_elemid,MED_NOM_GEO,&_medintsgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_GEO);ISCRUTE(_medintsgeotype);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_NAV (nombre d'attributs variables associ�s � un �l�ment de structure)
*/
/* if ( _MEDattributeIntWr(_elemid,MED_NOM_NAV,&nvariableattribute) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path); */
/* SSCRUTE(MED_NOM_NAV);ISCRUTE(nvariableattribute); */
/* goto ERROR; */
/* } */
/*
* Creation/Ecriture de l'attribut MED_NOM_NAC (nombre d'attributs constant associ�s � un �l�ment de structure)
*/
/* if ( _MEDattributeIntWr(_elemid,MED_NOM_NAC,&nconstattribute) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path); */
/* SSCRUTE(MED_NOM_NAC);ISCRUTE(nconstattribute); */
/* goto ERROR; */
/* } */
/*
* Nombre d'�l�ments de structure
*/
if ( !_stgeotype ) {
/*Si l'�l�ment de struture ne pr�-existait pas,
il a �t� cr�e en d�but de proc�dure (il y a au moins 1 �l�ment dans le groupe) */
if ((_err=_MEDnObjects(fid,MED_STRCT,&_tmpn)) <0) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_STRUCT,MED_STRCT);
goto ERROR;
}
_stgeotype=_tmpn+MED_STRUCT_GEO_INTERNAL;
_medintstgeotype=_stgeotype;
/*
* Ecriture de l'attribut MED_NOM_NEO (num�ro de type g�om�trique associ� � un �l�ment de structure)
*/
if ( _MEDattributeIntWr(_elemid,MED_NOM_NEO,&_medintstgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NEO);ISCRUTE(_medintstgeotype);
goto ERROR;
}
}
_ret = _stgeotype;
ERROR:
if (_elemid>0) if (_MEDdatagroupFermer(_elemid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_elemid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_STRCT);
ISCRUTE_id(_root);
}
return _ret;
}
med_err
MEDmeshPolygon2Rd(const med_idt fid,
const char* const meshname,
const med_int numdt,
const med_int numit,
const med_entity_type entitype,
const med_geometry_type polytype,
const med_connectivity_mode cmode,
med_int * const polyindex,
med_int * const connectivity )
{
med_access_mode _MED_ACCESS_MODE;
med_idt _meshid=0;
med_err _ret = -1;
med_data_type _datatype = MED_UNDEF_DATATYPE;
med_entity_type _entitytype=entitype;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/* Tester le type d'entité ?
* MAILLE Ok
* FACE OK
* ARETE ?
* NOEUD KO
* NOEUD_MAILLE ?
*/
if (entitype == MED_NODE_ELEMENT ) _entitytype=MED_NODE ;
switch(polytype)
{
case MED_POLYGON:
case MED_POLYGON2:
break;
default:
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(polytype);
goto ERROR;
}
if (_MEDmeshAdvancedRd(fid,
meshname,
MED_CONNECTIVITY,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
_entitytype,
polytype,
cmode,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
(unsigned char * const)connectivity) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedRd (MED_CONNECTIVITY) ");
goto ERROR;
}
if (_MEDmeshAdvancedRd(fid,
meshname,
MED_INDEX_NODE,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
_entitytype,
polytype,
cmode,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
(unsigned char * const)polyindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedRd (MED_INDEX_NODE) ");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err
MEDscalaireCr(med_idt fid,char *scalaire, med_type_champ type, char *desc)
{
med_err ret=-1;
med_idt root=0,gid=0;
char chemin[MED_TAILLE_NUM_DATA+1];
med_int _type = (med_int) type;
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer une variable scalaire en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Groupe HDF "/NUM_DATA" n'existe pas, on le cree
*/
strncpy(chemin,MED_NUM_DATA,MED_TAILLE_NUM_DATA-1);
chemin[MED_TAILLE_NUM_DATA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0){
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si le groupe HDF "scalaire" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(scalaire,ERROR);
if ((gid = _MEDdatagroupCreer(root,scalaire)) < 0) {
MESSAGE("Erreur à la création de la variable scalaire : ");
SSCRUTE(scalaire);
goto ERROR;
}
/*
* On stocke l'unite, et le type de la valeur scalaire
*/
if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type)) < 0) {
MESSAGE("Erreur à l'écriture du type de la varaible scalaire : ");
ISCRUTE(_type);
goto ERROR;
}
if ((ret = _MEDattrStringEcrire(gid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description de la variable scalaire : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* On ferme tout
*/
ret = 0;
ERROR:
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret=-1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret=-1;
}
return ret;
}
void
_MEDmeshnEntity30(int dummy, ...)
{
med_access_mode _MED_ACCESS_MODE;
med_int _ret=-1,_err=-1;
med_idt _meshid=0, _datagroup=0,_datagroupf=0,_datagroup1=0;
med_idt _datagroup2=0,_datagroup3=0,_datagroup4=0,_dataset=0;
char _meshpath [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
char _datagroupname1 [2*MED_MAX_PARA+1] ="";
char _datagroupname2 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname3 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname4 [MAX(MED_TAILLE_VARATR,MED_TAILLE_COOTRF)]="";
char _datasetconame [3 + 1 + 3 + 1 ] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _datasetname [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype = 0;
med_int _intsortingtype = 0;
med_int _profilearraysize = 0;
med_int _changement=0, _changement_s=0, _transformation=0;
med_bool _changement_co = MED_FALSE;
med_size _n=0;
med_int _intn=0;
med_bool _isasupportmesh = MED_FALSE;
med_bool _isasoftlink = MED_FALSE;
med_bool _datasetexist = MED_FALSE;
med_int _ntmpmeddatatype = 1;
med_data_type _tmpmeddatatype[4] = {MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE};
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _intmeshtype = 0;
med_int _meshdim = 0;
int _i = 0;
med_connectivity_mode _cmode ;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_cmode = cmode;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/*
* Ouverture du datagroup de niveau 1 <_meshpath>/<meshname>
*/
NOFINALBLANK(meshname,ERROR);
if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(_meshpath); goto ERROR;
}
/* Lecture de la dimension du maillage */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
/* Lecture du type de maillage (attribut MED_NOM_TYP) */
if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
}
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
/* Lecture de l'attribut MED_NOM_GTY */
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype= (med_grid_type) _intgridtype;
}
/*
* Ouverture du datagroup de niveau 2 <numdt>.<numit>
*/
if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
}
_sortingtype = (med_sorting_type) (_intsortingtype);
_MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
}
/*
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_CGT);goto ERROR;
}
*changement = (med_bool) _changement;
*transformation = MED_FALSE;
/*
* Gestion entitytype == MED_UNDEF_ENTITY_TYPE
*/
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) {
_n=0; goto SORTIE;
}
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
_err=_MEDnObjects(_datagroup1,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
goto SORTIE;
}
/*
* Ouverture du datagroup de niveau 3 <entitytype>
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
}
if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
*changement = (med_bool) MED_FALSE;
_n=0;_datagroup2=0;
goto SORTIE;
}
/* MAJ du changement pour le type d'entité <entitytype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup2,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
/*
* Ouverture du datagroup de niveau 4 <geotype>
*/
/* Pas Utilisation pour MED_NODE */
if ( geotype == MED_GEO_ALL ) {
_err=_MEDnObjects(_datagroup2,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname2);
goto ERROR;
}
/*Par construction du modèle, le tableau de coordonnées preexiste aux autres */
if ( ( entitytype == MED_NODE ) && (_n > 0) ) _n=1;
goto SORTIE;
}
if ( entitytype != MED_NODE ) {
/* Lecture du nom de type géométrique */
/*TODO : Remplacer les deux appels suivants par un seul gérant les geotype dynamiques et statiques*/
if ( entitytype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid, geotype,_datagroupname3) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else
if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);goto ERROR;
}
if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
_n=0;
*changement = MED_FALSE;
goto SORTIE;
}
}
if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
/* MAJ du changement pour le type géométrique d'entité <geotype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
* Prend en charge le cas d'un dataset vide écrit pour un typegeo donné (CHGT==1)
*/
if (_datagroup3) {
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
}
/*
* Lecture du flag de modification sur autre chose que MED_CONNECTIVITY,MED_COORDINATE,MED_COORDINATE_AXIS<i>
*
*/
if ( _MEDattrEntierLire(_datagroup,MED_NOM_CGS,&_changement_s) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGS);goto ERROR;
}
/* 1) Lorsque l'utilisateur interroge un <meddatatype> qui est relatif a des coordonnées (famille,....) il faut mettre
* le flag chgt à jour par rapport à des modifications potentiellement effectuées sur ces coordonnées
* <=>
* Si on interroge autre chose que MED_CONNECTIVITY,MED_COORDINATE
* et qu'un changement est présent sur MED_CONNECTIVITY,MED_COORDINATE
* le flag chgt doit être positionné à vrai
* Une demande entitype==MED_NODE && (meddatatype == MED_COORDINATE_AXIS1)||(meddatatype == MED_COORDINATE_AXIS2)
* ||(meddatatype === MED_COORDINATE_AXIS3) est assimilée à une demande concernant des coordonnées
* <=>
* Y-a-t'il une modification des datasets COO(si NOE)| NOD|DES(si !NOE)
*/
/* 2)
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et que le cmode n'a pas été
* spécifié par l'utilisateur.
* Cette Information est necessaire pour construire le nom du dataset.
*/
if ( (meddatatype != MED_CONNECTIVITY) && ( meddatatype != MED_COORDINATE )
&& (meddatatype != MED_COORDINATE_AXIS1)
&& (meddatatype != MED_COORDINATE_AXIS2)
&& (meddatatype != MED_COORDINATE_AXIS3)
&& (meddatatype != MED_INDEX_FACE)
&& (meddatatype != MED_INDEX_NODE)) {
if (entitytype == MED_NODE) {
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
if ( (_gridtype == MED_CARTESIAN_GRID) ||
(_gridtype == MED_CURVILINEAR_GRID) ) {
_ntmpmeddatatype=_meshdim;
_tmpmeddatatype[0] = MED_COORDINATE_AXIS1;
_tmpmeddatatype[1] = MED_COORDINATE_AXIS2;
_tmpmeddatatype[2] = MED_COORDINATE_AXIS3;
} else if (_gridtype == MED_CURVILINEAR_GRID ) {
/*Les grilles curvilinéaires utilisent MED_COORDINATE_AXISx pour stocker la structure et le tableau MED_COORDINATE pour stocker les coordonnées des noeuds */
++_ntmpmeddatatype;
_tmpmeddatatype[3] = MED_COORDINATE;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
} else
_tmpmeddatatype[0] = MED_COORDINATE;
} else {
switch (geotype) {
case MED_POLYHEDRON:
_ntmpmeddatatype=3;
_tmpmeddatatype[2] = MED_CONNECTIVITY;
_tmpmeddatatype[1] = MED_INDEX_FACE;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
case MED_POLYGON:
_ntmpmeddatatype=2;
_tmpmeddatatype[1] = MED_CONNECTIVITY;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
default:
if ( ( (med_mesh_type) _intmeshtype ) == MED_STRUCTURED_MESH ) {
_ntmpmeddatatype=0;
break;
}
_tmpmeddatatype[0] = MED_CONNECTIVITY;
if ( cmode == MED_NO_CMODE ) {
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_NODAL,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
if ( _datasetexist ) _cmode= MED_NODAL;
else
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_DESCENDING,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
} else
_cmode = MED_DESCENDING;
}
}
}
*changement = MED_FALSE;
for (_i=0; _i < _ntmpmeddatatype ;++_i) {
if ( _MEDgetDatasetChgt( _datagroup, _tmpmeddatatype[_i], _cmode,
&_isasoftlink, &_changement_co ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"getDatasetChgt");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
*changement |= _changement_co;
}
}
/*
* Niveau de datagroup 5 supplémentaire pour les éléments de structure ou les transformations.
*/
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) ) {
if (meddatatype == MED_VARIABLE_ATTRIBUTE)
strcpy(_datagroupname4,MED_VARATR_NOM);
else
strcpy(_datagroupname4,MED_COOTRF_NOM);
if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
_n=0;
goto SORTIE;
}
}
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) )
_datagroupf=_datagroup4;
else
_datagroupf=_datagroup;
/*
* Construction du nom du dataset à lire
*/
if ( _MEDgetDatasetName(_datasetname,meddatatype,cmode) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetName");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
/*
* MAJ du champ transformation pour le (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if (_datagroup4) {
if ( _MEDattrEntierLire(_datagroup4,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
if ( (_dataset = _MEDdatasetOuvrir(_datagroupf,_datasetname)) < 0) {
_n=0;_dataset=0;*transformation = (med_bool) MED_FALSE;
/* if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname); */
/* SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4); */
/* ISCRUTE_size(_n); */
/* goto ERROR; */
/* } */
goto SORTIE;
}
if (!_datagroup4) {
/*
* Lire l'attribut CGT pour savoir si le dataset a changé
* n'a pas de sens si le dataset est en fait un lien vers le dataset précedent.
* En testant si le dataset est un lien on détermine si un changement a eu lieu
* depuis la séquence de calcul précédente.
* Ce traitement ne doit pas être effectué pour le pas de temps initial et pour
* (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if ( _MEDisasoftlink(_datagroupf, _datasetname,MED_TRUE, &_isasoftlink ) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_LINK,_datasetname);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
ISCRUTE_size(_n);goto ERROR;
}
if (_isasoftlink)
_transformation = MED_FALSE;
else {
if ( _MEDattrEntierLire(_dataset,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
}
*transformation = (med_bool) _transformation;
if ( ( meddatatype == MED_CONNECTIVITY) && ( meddatatype == MED_COORDINATE ) ) {
*transformation &= (med_bool) !_changement_s;
}
/*
* Attribut PFL (nombre de noeuds ou d'elements)
* la lecture est faite sur le datagroup _datagroup et non sur _datagroupf
* pour (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
_profilearraysize = 0;
profilename[0]='\0';
if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(profilename,_profilename,MED_NAME_SIZE+1);
profilename[MED_NAME_SIZE]='\0';
if ( ( _profilearraysize = MEDprofileSizeByName( fid,_profilename) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_profilename);SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
*profilesize=(med_int) _profilearraysize;
/*
* Attribut NBR (nombre d'entité)
*/
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_intn) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
SSCRUTE(_datasetname);SSCRUTE(MED_NOM_NBR);ISCRUTE_size(_n);goto ERROR;
}
_n = _intn;
if (_profilearraysize)
switch(storagemode) {
case MED_GLOBAL_PFLMODE :
break;
case MED_COMPACT_PFLMODE :
if ( meddatatype!=MED_COORDINATE_TRSF )
_n=_profilearraysize;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_STORAGEMODE,MED_ERR_VALUE_MSG);
ISCRUTE_int(storagemode);goto ERROR;
break;
}
SORTIE:
_ret = _n;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
ISCRUTE_id(_dataset);
}
if (_datagroup4>0) if (_MEDdatagroupFermer(_datagroup4) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname4);
ISCRUTE_id(_datagroup4);
}
if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
ISCRUTE_id(_datagroup3);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
/* _MEDobjetsOuverts(fid); */
*fret = _ret;
va_end(params);
return;
}
med_err
MEDmeshPolyhedronWr(const med_idt fid,
const char* const meshname,
const med_int numdt,
const med_int numit,
const med_float dt,
const med_entity_type entitype,
const med_connectivity_mode cmode,
const med_int faceindexsize,
const med_int * const faceindex,
const med_int nodeindexsize,
const med_int * const nodeindex,
const med_int * const connectivity )
{
med_access_mode _MED_ACCESS_MODE;
med_idt _meshid=0;
med_err _ret = -1;
med_data_type _datatype = MED_UNDEF_DATATYPE;
med_int _connectivitysize = 0;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/* Tester le type d'entité ?
* MAILLE Ok
* FACE OK
* ARETE ?
* NOEUD KO
* NOEUD_MAILLE ?
*/
switch(cmode)
{
case MED_NODAL :
_connectivitysize = nodeindex[nodeindexsize-1] - nodeindex[0];
break;
case MED_DESCENDING :
_connectivitysize = nodeindexsize;
break;
default :
return -1;
}
if (_MEDmeshAdvancedWr(fid,
meshname,
MED_CONNECTIVITY,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
dt,
entitype,
MED_POLYHEDRON,
cmode,
MED_UNDEF_PFLMODE,
MED_NO_PROFILE,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
_connectivitysize,
connectivity) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedWr (MED_CONNECTIVITY) ");
goto ERROR;
}
if (_MEDmeshAdvancedWr(fid,
meshname,
MED_INDEX_NODE,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
dt,
entitype,
MED_POLYHEDRON,
cmode,
MED_UNDEF_PFLMODE,
MED_SAME_PROFILE_INTERNAL,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
nodeindexsize,
nodeindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedWr (MED_INDEX_NODE) ");
goto ERROR;
}
if (_MEDmeshAdvancedWr(fid,
meshname,
MED_INDEX_FACE,
MED_NO_NAME,
MED_INTERNAL_UNDEF,
numdt,
numit,
dt,
entitype,
MED_POLYHEDRON,
cmode,
MED_UNDEF_PFLMODE,
MED_SAME_PROFILE_INTERNAL,
MED_FULL_INTERLACE,
MED_ALL_CONSTITUENT,
NULL,
faceindexsize,
faceindex) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAdvancedWr (MED_INDEX_FACE) ");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
void _MEDfileObjectsMount236(int dummy,...) {
med_idt _ret = -1;
med_idt _id, _rootId=0;
char _mountPath[2*MED_NAME_SIZE+1];
char _link[MED_NAME_SIZE+1];
med_access_mode _accessMode;
med_int majeur=0, mineur=0, release=0;
med_int rfileversionMMR,rfileversionMM,rfileversionM;
med_int lfileversionMMR,lfileversionMM,lfileversionM;
med_bool _datagroupexist=MED_FALSE,_isasoftlink=MED_FALSE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, med_idt , , gid );
MED_VARGS_DECL(const, char* , const , mountfilename );
MED_VARGS_DECL(const, med_class , , medclass );
MED_VARGS_DECL(, med_idt * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, med_idt , , gid );
MED_VARGS_DEF(const, char* , const , mountfilename );
MED_VARGS_DEF(const, med_class , , medclass );
MED_VARGS_DEF(, med_idt * ,, fret );
_MEDmodeErreurVerrouiller();
if ( MEDfileNumVersionRd(fid, &majeur, &mineur, &release) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDfileNumVersionRd");
ISCRUTE(majeur);ISCRUTE(mineur);ISCRUTE(release);
goto ERROR;
}
lfileversionM = 100*majeur;
lfileversionMM = 100*majeur+10*mineur;
lfileversionMMR = lfileversionMM+release;
/*
* does the file exist ?
*/
if (access(mountfilename,F_OK)) {
MED_ERR_(_ret,MED_ERR_EXIST,MED_ERR_FILE,mountfilename);
goto ERROR;
}
if ( (_accessMode = (med_access_mode)_MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_FILE,"");
ISCRUTE_int(_accessMode);
goto ERROR;
}
/*
* Open the file "mountfilename".
*/
if ((_id = _MEDfileOpen(mountfilename,_accessMode)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_FILE,mountfilename);
goto ERROR;
}
if ( MEDfileNumVersionRd(_id, &majeur, &mineur, &release) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDfileNumVersionRd");
SSCRUTE(mountfilename);ISCRUTE(majeur);ISCRUTE(mineur); ISCRUTE(release);
goto ERROR;
}
rfileversionM = 100*majeur;
rfileversionMM = 100*majeur+10*mineur;
rfileversionMMR = rfileversionMM+release;
if ( !( ( (rfileversionMM >= 220) && (lfileversionMM >= 220)
&& (rfileversionMMR <= 236) && (lfileversionMMR <= 236) ) ) ){
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_FILE,mountfilename);
ISCRUTE(rfileversionMMR);ISCRUTE(lfileversionMMR);
goto ERROR;
}
/*
* Mount point creation in the local file
*/
_rootId = _MEDdatagroupOuvrir(fid,MED_MNT);
if (_rootId < 0)
if ((_rootId = _MEDdatagroupCreer(fid,MED_MNT)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_FILE,MED_MNT);
goto ERROR;
}
/*
* The file "mountfilename" is mounted in the local file
*/
strncpy(_mountPath,MED_MNT,strlen(MED_MNT)-1);
_mountPath[strlen(MED_MNT)-1] = '\0';
if (_MEDfichierMonter(fid,_mountPath,_id) < 0) {
MED_ERR_(_ret,MED_ERR_MOUNT,MED_ERR_FILE,mountfilename);
goto ERROR;
}
/*
* Give access to the class object in the local file
*/
switch(medclass) {
case MED_MESH :
strcpy(_link,MED_MAA);
break;
case MED_FIELD :
strcpy(_link,MED_CHA);
break;
default :
goto ERROR;
}
strcat(_mountPath,_link);
_mountPath[strlen(_mountPath)-1] = '\0';
_link[strlen(_link)-1] = '\0';
if (_MEDdatagroupLienCreer(fid,_mountPath,_link) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_LINK,_link);
SSCRUTE(_mountPath);
goto ERROR;
}
_ret = _id;
ERROR:
if (_rootId > 0)
if (_MEDdatagroupFermer(_rootId) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILE,MED_MNT);
}
va_end(params);
*fret = _ret;
return;
}
med_err
MEDjointEcr (med_idt fid, char *maa, char *jn, med_int *corrtab, med_int n,
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 corrid, datagroup;
med_err ret;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+2*MED_TAILLE_NOM+1];
char nomdatagroup[MED_TAILLE_NOM+1+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_NOM_ENTITE+1];
med_size dimd[1];
med_mode_acces MED_MODE_ACCES;
/* 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;
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 Data Group de "JNT" n'existe pas => erreur
*/
strcpy(chemin,MED_MAA);
strcat(chemin,maa);
strcat(chemin,MED_JNT);
strcat(chemin,jn);
if ((corrid = _MEDdatagroupOuvrir(fid,chemin)) < 0) {
MESSAGE(chemin);
return -1;
}
/*
* Ecriture de la correspondance
* construction du tag HDF "reperant" la correspondance
*
*/
if ((ret = _MEDnomEntite(nomdatagroup,_type_ent_local)) < 0)
return -1;
if ((_type_ent_local != MED_NOEUD))
{
if ((ret = _MEDnomGeometrie(tmp,typ_geo_local)) < 0)
return -1;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
}
if ((ret = _MEDnomEntite(tmp,_type_ent_distant)) < 0)
return -1;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
if ((_type_ent_distant != MED_NOEUD))
{
if ((ret = _MEDnomGeometrie(tmp,typ_geo_distant)) < 0)
return -1;
strcat(nomdatagroup,".");
strcat(nomdatagroup,tmp);
}
datagroup = 0;
/*
* Si la correspondance existe, on passe en mode
* ajout ?????????
*/
if (((datagroup = _MEDdatagroupOuvrir(corrid,nomdatagroup)) > 0) &&
( MED_MODE_ACCES == MED_LECTURE_AJOUT))
return -1;
else
if (datagroup > 0)
_MEDdatagroupFermer(datagroup);
if ((datagroup = _MEDdatagroupCreer(corrid,nomdatagroup)) < 0)
return -1;
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n)) < 0)
return -1;
dimd[0] = 2*n;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) corrtab)) < 0)
return -1;
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) corrtab)) < 0)
return -1;
#endif
/*
* On ferme tout
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(corrid)) < 0)
return -1;
return 0;
}
med_err
MEDparameterCr(const med_idt fid,
const char * const paramname,
const med_parameter_type paramtype,
const char* const description,
const char * const dtunit
)
{
med_err _ret=-1;
med_idt _root=0,_datagroup1=0;
med_access_mode _MED_ACCESS_MODE;
char _datagroupname1 [MED_NAME_SIZE+1]="";
med_int _paramtype = (med_int) paramtype;
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup MED_NUM_DATA n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,MED_NUM_DATA)) < 0)
if ((_root = _MEDdatagroupCreer(fid,MED_NUM_DATA)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_NUM_DATA);
goto ERROR;
}
NOFINALBLANK(paramname,ERROR);
/*
* Si le Data Group "/NUM_DATA/<paramname>" n'existe pas, on le cree
*/
if ((_datagroup1 = _MEDdatagroupOuvrir(_root,paramname)) < 0)
if ((_datagroup1 = _MEDdatagroupCreer(_root,paramname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_NUM_DATA);
SSCRUTE(paramname);goto ERROR;
}
/*
* Ecriture des infos relatives au parametre : type, dtunit, description
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_TYP,&_paramtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_PARAM_MSG);
SSCRUTE(paramname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_TYP);
ISCRUTE(_paramtype);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_DES,MED_COMMENT_SIZE,description) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_PARAM_MSG);
SSCRUTE(paramname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_DES);
SSCRUTE(description);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_PARAM_MSG);
SSCRUTE(paramname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
_ret = 0;
ERROR :
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_NUM_DATA);
ISCRUTE_id(_root);
}
return _ret;
}
med_idt
MEDmonter(med_idt fid, const char *acces,med_type_donnee type)
{
med_err ret;
med_idt root,id, did;
char chemin[MED_TAILLE_NOM+1];
char acces_montage[2*MED_TAILLE_NOM+1];
med_mode_acces MED_MODE_ACCES;
/*
* On inhibe le gestionnaire d'erreur HDF
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) return -1;
/*
* On regarde si le fichier de nom "acces" existe
* Si ce n'est pas le cas => erreur
*/
if (access(acces,F_OK))
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;
}
/*
* On ouvre le fichier "acces" selon le mode d'acces MED_MODE_ACCES
*/
if ((id = _MEDfichierOuvrir((char *)acces,MED_MODE_ACCES)) < 0)
return -1;
/*
* Si le point de montage n'existe pas dans le fichier local, on le cree
*/
root = _MEDdatagroupOuvrir(fid,MED_MNT);
if (root < 0)
if ((root = _MEDdatagroupCreer(fid,MED_MNT)) < 0)
return -1;
if ((ret = _MEDdatagroupFermer(root)) < 0)
return -1;
/*
* Montage du fichier (id) sur le point de montage local (fid)
*/
strncpy(acces_montage,MED_MNT,strlen(MED_MNT)-1);
acces_montage[strlen(MED_MNT)-1] = '\0';
if ((ret = _MEDfichierMonter(fid,acces_montage,id)) < 0)
return -1;
/*
* On cree un lien vers le point de montage
* selon qu'on l'on veuille acceder aux champs
* ou aux maillages du fichier "acces" que l'on vient
* de monter sur le fichier local "fid"
*/
switch(type) {
case MED_MAILLAGE :
strcpy(chemin,MED_MAA);
break;
case MED_CHAMP :
strcpy(chemin,MED_CHA);
break;
default :
return -1;
}
/*
* Creation du lien HDF vers le(s) champ(s) ou le(s) maillage(s)
* dans le fichier local :
* - Si ce type de donnee existe deja en local => erreur
* - Sinon on le cree le lien vers le point de montage
*/
strcat(acces_montage,chemin);
acces_montage[strlen(acces_montage)-1] = '\0';
chemin[strlen(chemin)-1] = '\0';
if ((ret = _MEDdatagroupLienCreer(fid,acces_montage,chemin)) < 0)
return -1;
/*
* On renvoie l'ID du fichier "acces" que l'on vient de monter
*/
return id;
}
med_err
MEDmeshComputationStepCr(const med_idt fid,
const char * const meshname,
const med_int numdt1,
const med_int numit1,
const med_int numdt2,
const med_int numit2,
const med_float dt2 )
{
med_access_mode _MED_ACCESS_MODE;
med_err _ret=-1;
med_idt _meshid=0,_datagroup1=0,_datagroup2=0,_datagroup3=0;
char _meshpath [MED_MESH_SUPPORT_GRP_SIZE+MED_NAME_SIZE+1]="";
char _datagroupname [2*MED_MAX_PARA+1]="";
char _datagroupname2[2*MED_MAX_PARA+1]="";
char _datagroupname1bis[2*MED_MAX_PARA+1]="";
char _latestcpstname[2*MED_MAX_PARA+1]="";
char* _datagroupname1=_datagroupname;
char _datagroupname3[2*MED_MAX_PARA+1]="";
char _prevcpstname[2*MED_MAX_PARA+1]="";
char _pathsrc[MED_MESH_SUPPORT_GRP_SIZE+MED_NAME_SIZE+1+2*MED_MAX_PARA+1+1]="";
char _pathdst[MED_MESH_SUPPORT_GRP_SIZE+MED_NAME_SIZE+1+2*MED_MAX_PARA+1+1]="";
med_bool _datagroup1exist = MED_TRUE;
med_bool _isasupportmesh = MED_FALSE;
med_int _nextdt=MED_NO_DT, _nextit=MED_NO_IT,_pvdt=MED_NO_DT, _pvit=MED_NO_IT;
med_int _lastnumdt=MED_NO_DT, _lastnumit=MED_NO_IT;
med_int _numdt1=numdt1,_numit1=numit1;
med_int _false = 0;
med_sorting_type _sortingtype;
med_int _intsortingtype;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/* strcat( _meshpath, meshname); */
/* strcat( _pathsrc , meshname);strcat( _pathsrc , "/"); */
/* strcat( _pathdst , meshname);strcat( _pathdst , "/"); */
/* if ((_meshid = _MEDdatagroupOuvrir(fid,_meshpath)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_meshpath); */
/* SSCRUTE(_meshid);goto 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;
}
strcat( _pathsrc , _meshpath);strcat( _pathsrc , "/");
strcat( _pathdst , _meshpath);strcat( _pathdst , "/");
if ( _MEDattrEntierLire(_meshid,MED_NOM_NXT,&_lastnumdt) < 0) {
/* MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG); */
/* SSCRUTE(meshname);SSCRUTE(_meshpath);SSCRUTE(MED_NOM_NXT); */
/* goto ERROR; */
_lastnumdt = MED_NO_DT;
}
if ( _MEDattrEntierLire(_meshid,MED_NOM_NXI,&_lastnumit) < 0) {
/* MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG); */
/* SSCRUTE(meshname);SSCRUTE(_meshpath);SSCRUTE(MED_NOM_NXI); */
/* goto ERROR; */
_lastnumit = MED_NO_IT;
}
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,numdt1,numit1,_datagroupname);
_MEDgetComputationStepName(_sortingtype,numdt2,numit2,_datagroupname2);
_MEDgetComputationStepName(_sortingtype,_lastnumdt,_lastnumit,_latestcpstname);
/*
L'utilisateur peut demander la création d'une nouvelle étape de calcul postérieure
à toutes les autres en indiquant (numdt1 == numdt2) && (numit1 == numit2)
Celà fonctionne aussi pour MED_NO_DT, NED_NO_IT
*/
if ( (numdt1 == numdt2) && (numit1 == numit2) ) {
_numdt1 = _lastnumdt;
_numit1 = _lastnumit;
_datagroupname1 = _latestcpstname;
}
/*Vérifie que le _datagroupname2 est bien postérieur ou égal au _datagroupname1
REM: _datagroupname1 peut être la première/dernière séquence de calcul
ou une séquence intermédiaire */
if ( strncmp(_datagroupname2,_datagroupname1,2*MED_MAX_PARA+2) < 0) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,_datagroupname2);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);goto ERROR;
}
strcat( _pathsrc , _datagroupname1 );strcat( _pathsrc , "/");
strcat( _pathdst , _datagroupname2 );strcat( _pathdst , "/");
/* On accepte l'absence de _datagroupname1 uniquement si
numdt2 == MED_NO_DT && numit2 == MED_NO_IT */
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
if ( (numdt2 != MED_NO_DT ) || (numit2 != MED_NO_IT) ) {
MED_ERR_(_ret,MED_ERR_DOESNTEXIST,MED_ERR_COMPUTINGSTEP,_datagroupname1);
SSCRUTE(meshname);goto ERROR;
}
}
/*L'étape de calcul à créer ne doit pas déjà exister*/
if ( (_datagroup2 = _MEDdatagroupOuvrir(_meshid,_datagroupname2)) >= 0 ) {
MED_ERR_(_ret,MED_ERR_EXIST,MED_ERR_COMPUTINGSTEP,_datagroupname2);
SSCRUTE(meshname);goto ERROR;
}
if ( _datagroup1 > 0 ) {
/*Lecture NEXT et PREV du datagroup1 */
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_NXT,&_nextdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NXT);
goto ERROR;
}
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_NXI,&_nextit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NXI);
goto ERROR;
}
/* On vérifie que la nouvelle étape de calcul s'insère correctement :
< au next du datagroup1 */
/* if ( !((_nextdt == MED_NO_DT) && (_nextit == MED_NO_IT) )) { */
if ( (_nextdt != MED_NO_DT) || (_nextit != MED_NO_IT) ) {
_MEDgetComputationStepName(_sortingtype,_nextdt,_nextit,_datagroupname3);
if ( strncmp(_datagroupname3,_datagroupname2,2*MED_MAX_PARA+2) <= 0) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,_datagroupname2);
SSCRUTE(meshname);SSCRUTE(_datagroupname3);goto ERROR;
}
}
/*On crée la nouvelle étape de calcul (au plus tard, après vérifs...)*/
if ((_datagroup2 = _MEDdatagroupCreer(_meshid,_datagroupname2)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_datagroupname2);
SSCRUTE(meshname);goto ERROR;
}
/*On crée les datagroups, attributs et liens sur les datatsets et les liens symboliques
pour avoir une image de l'étape de calcul précedente.*/
if ( _MEDvisit(fid,_pathsrc,_pathdst,(medvisitorfunc) _MEDlinkobjs ) < 0 ) {
MED_ERR_(_ret,MED_ERR_VISIT,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_pathsrc);SSCRUTE(_pathdst);
goto ERROR;
}
/*Ecriture NEXT et PREV du nouveau datagroup2 */
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_NXT,&_nextdt) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NXT);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_NXI,&_nextit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NXI);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_PVT,&_numdt1) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_PVT);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_PVI,&_numit1) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_PVI);
goto ERROR;
}
/*Modification du NEXT du datagroup1 */
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NXT,&numdt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NXT);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NXI,&numit2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NXI);
goto ERROR;
}
/*Modification de PREV du ( NEXT de datagroup1 ) s'il existe*/
if (strlen(_datagroupname3) ) {
if ( (_datagroup3 = _MEDdatagroupOuvrir(_meshid,_datagroupname3)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_COMPUTINGSTEP,_datagroupname3);
SSCRUTE(meshname);goto ERROR;
}
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_PVT,&_pvdt) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_PVT);
goto ERROR;
}
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_PVI,&_pvit) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_PVI);
goto ERROR;
}
_MEDgetComputationStepName(_sortingtype,_pvdt,_pvit,_datagroupname1bis);
if ( strncmp(_datagroupname1,_datagroupname1bis,2*MED_MAX_PARA+2) != 0) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_COMPUTINGSTEP,_datagroupname1);
SSCRUTE(meshname);SSCRUTE(_datagroupname1bis);goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup3,MED_NOM_PVT,&numdt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_PVT);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup3,MED_NOM_PVI,&numit2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_PVI);
goto ERROR;
}
}
} else { /* Création de la première étape de calcul */
/*On crée la nouvelle étape de calcul (au plus tard, après vérifs...) */
if ((_datagroup2 = _MEDdatagroupCreer(_meshid,_datagroupname2)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_datagroupname2);
SSCRUTE(meshname);goto ERROR;
}
/* Ecriture de MED_NO_IT, MED_NO_DT pour NEXT et PREV de la première
étape de calcul */
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_NXT,&numdt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NXT);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_NXI,&numit2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NXI);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_PVT,&numdt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_PVT);
goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_PVI,&numit2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_PVI);
goto ERROR;
}
}
/*Cree ou ouvre l'attribut MED_NOM_NDT pour écriture */
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_NDT,&numdt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NDT);
ISCRUTE(numdt2);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_PDT pour écriture */
if ( _MEDattrFloatEcrire(_datagroup2,MED_NOM_PDT,&dt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_PDT);
RSCRUTE(dt2);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_NOR pour écriture */
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_NOR,&numit2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NOR);
ISCRUTE(numit2); goto ERROR;
}
/* Une nouvelle étape de calcul est vierge de toute modifiation*/
if ( _MEDattributeIntWr(_datagroup2,MED_NOM_CGT,&_false) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
/* Ecriture de NEXT et PREV au niveau meshid (dernière étape de calcul créée */
if ( strncmp(_datagroupname2,_latestcpstname,2*MED_MAX_PARA+2) >= 0) {
if ( _MEDattributeIntWr(_meshid,MED_NOM_NXT,&numdt2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NXT);
goto ERROR;
}
if ( _MEDattributeIntWr(_meshid,MED_NOM_NXI,&numit2) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_NXI);
goto ERROR;
}
}
_ret = 0;
ERROR:
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);
}
return _ret;
}
med_err
MEDmaaCr(med_idt fid, char *maillage, med_int dim, med_maillage type,char *desc)
{
med_idt maaid=0, root=0, entid=0, geoid=0 ;
char chemin[MED_TAILLE_MAA+1];
char nom_ent[MED_TAILLE_NOM_ENTITE+1];
char nom_geo[MED_TAILLE_NOM_ENTITE+1];
med_err ret=-1;
med_int tmp;
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;
};
/*
* Si la racine n'existe pas on la cree
*/
strncpy(chemin,MED_MAA,strlen(MED_MAA)-1);
chemin[MED_TAILLE_MAA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Création du maillage
*/
NOFINALBLANK(maillage,ERROR);
if ( (maaid = _MEDdatagroupCreer(root,maillage)) < 0) {
MESSAGE("Erreur à la création du maillage : ");
SSCRUTE(maillage);
goto ERROR;
}
/*
* Creation de l'attribut dimension
*/
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_DIM,&dim)) < 0) {
MESSAGE("Erreur à l'écriture de la dimension du maillage : ");
ISCRUTE(dim);
goto ERROR;
}
/*
* La description associee au maillage
*/
if ((ret = _MEDattrStringEcrire(maaid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description du maillage : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* Creation de l'attribut correspondant au type du maillage (MED_STRUCTURE, MED_NON_STRUCTURE)
*/
tmp = (med_int) type;
if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_TYP,&tmp)) < 0) {
MESSAGE("Erreur à l'écriture du type de maillage : ");
ISCRUTE(tmp);
goto ERROR;
}
if ( type == MED_STRUCTURE ) {
strcpy(nom_ent,MED_NOM_MAI);
if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0) {
MESSAGE("Impossible de Cr\351er le datagroup :");
SSCRUTE(nom_ent);
MESSAGE("pour le maillage structur\351 :");
SSCRUTE(maillage);
goto ERROR;
}
switch ( dim ) {
case 1 : strcpy(nom_geo,MED_NOM_SE2);
break;
case 2 : strcpy(nom_geo,MED_NOM_QU4);
break;
case 3 : strcpy(nom_geo,MED_NOM_HE8);
break;
case 0 : strcpy(nom_geo,MED_NOM_PO1);
break;
default :
MESSAGE("La dimension doit être comprise entre 0 et 3");
goto ERROR;
}
if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0) {
MESSAGE("Impossible de Créer le datagroup :");
SSCRUTE(nom_geo);
MESSAGE("pour le maillage structuré :");
SSCRUTE(maillage);
goto ERROR;
}
}
/*
* Nettoyages divers
*/
ret = 0;
ERROR:
if (geoid>0) if (_MEDdatagroupFermer(geoid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(geoid);ret = -1;
}
if (entid>0) if (_MEDdatagroupFermer(entid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(entid);ret = -1;
}
if (maaid>0) if (_MEDdatagroupFermer(maaid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(maaid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
return ret;
}
void
_MEDfieldCr30(int dummy, ...) {
med_err _ret=-1;
med_idt _root=0,_datagroup1=0;
med_int _fieldtype;
char _datagroupname1[MED_NAME_SIZE+1]="";
med_access_mode _MED_ACCESS_MODE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_field_type , , fieldtype );
MED_VARGS_DECL(const, med_int , , ncomponent );
MED_VARGS_DECL(const, char *, const , componentname );
MED_VARGS_DECL(const, char *, const , componentunit );
MED_VARGS_DECL(const, char *, const , dtunit );
MED_VARGS_DECL(const, char *, const , meshname );
MED_VARGS_DECL(, med_err * , , fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, med_field_type, , fieldtype );
MED_VARGS_DEF(const, med_int , , ncomponent );
MED_VARGS_DEF(const, char *, const , componentname );
MED_VARGS_DEF(const, char *, const , componentunit );
MED_VARGS_DEF(const, char *, const , dtunit );
MED_VARGS_DEF(const, char *, const , meshname );
MED_VARGS_DEF(, med_err * , , fret );
_MEDmodeErreurVerrouiller();
_fieldtype = (med_int) fieldtype;
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup MED_FIELD_GRP n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,MED_FIELD_GRP)) < 0)
if ((_root = _MEDdatagroupCreer(fid,MED_FIELD_GRP)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
goto ERROR;
}
NOFINALBLANK(fieldname,ERROR);
/*
* Si le Data Group "/CHA/<fieldname>" n'existe pas, on le cree
*/
if ((_datagroup1 = _MEDdatagroupOuvrir(_root,fieldname)) < 0)
if ((_datagroup1 = _MEDdatagroupCreer(_root,fieldname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
SSCRUTE(fieldname);goto ERROR;
}
/*
* Les infos sur les composantes du champ
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NCO,&ncomponent) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NCO);
ISCRUTE(ncomponent);goto ERROR;
}
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_TYP,&_fieldtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_TYP);
ISCRUTE(_fieldtype);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_NOM,
MED_SNAME_SIZE*ncomponent,componentname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NOM);
SSCRUTE(componentname);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNI,
MED_SNAME_SIZE*ncomponent,componentunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNI);
SSCRUTE(componentunit);goto ERROR;
}
/*MODEL : MED_NOM_UNI vient du niveau en dessous
Cree ou ouvre l'attribut MED_NOM_UNI pour écriture
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/*MODEL : MED_NOM_MAI est écrit dans l'API de création de champ
* Si c'est la première référence à un maillage, initialise l'attribut MED_MAI à ce maillage
*/
NOFINALBLANK(meshname,ERROR);
if (_MEDattributeStringWr(_datagroup1,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_MAI);
SSCRUTE(meshname);
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,meshname);
goto ERROR;
}
/*
* On ferme tout
*/
_ret=0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
ISCRUTE_id(_root);
}
va_end(params);
*fret = _ret;
return;
}
med_err
MEDmeshAttributeWr(const med_idt fid,
const char * const meshname,
const med_int isolatednodes,
const med_int verticesnodes,
const med_int cellmaxnodes)
{
med_access_mode _MED_ACCESS_MODE;
med_err _ret=-1;
med_idt _meshid=0;
char _path [MED_TAILLE_MAA+MED_NAME_SIZE+1]=MED_MAA;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le maillage n'existe pas => erreur
*/
strcat(_path,meshname);
if ((_meshid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_meshid);goto ERROR;
}
/*
* Creation de l'attribut "Nombre de Noeuds Isoles"
*/
if ( _MEDattributeIntWr(_meshid,MED_NOM_NNI,&isolatednodes) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_NNI);ISCRUTE(isolatednodes);goto ERROR;
}
/*
* Creation de l'attribut "Nombre de Noeuds Sommets"
*/
if ( _MEDattributeIntWr(_meshid,MED_NOM_NNS,&verticesnodes) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_NNS);ISCRUTE(verticesnodes);goto ERROR;
}
/*
* Creation de l'attribut "Nombre de Noeuds Max par maille"
*/
if ( _MEDattributeIntWr(_meshid,MED_NOM_NNM,&cellmaxnodes) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_NNM);ISCRUTE(cellmaxnodes);goto ERROR;
}
_ret = 0;
ERROR:
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_meshid);
}
return _ret;
}
/**\ingroup MEDinterp
\brief \MEDinterpCrBrief
\param fid \fid
\param interpname \interpname
\param geotype \geotype
\param cellnode \cellnode
\param nvariable \nvariable
\param maxdegree \maxdegree
\param nmaxcoef \nmaxcoef
\return \error
\details \MEDinterpCrDetails
\see MEDinterpBaseFunctionWr
\remarks
\li \MEDinterpCrcellnodeCm1
\li \MEDinterpCrcellnodeCm2
*/
med_err
MEDinterpCr(const med_idt fid,
const char* const interpname,
const med_geometry_type geotype,
const med_bool cellnode,
const med_int nvariable,
const med_int maxdegree,
const med_int nmaxcoef
)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_interpid=0;
med_int _ret=-1;
char _path[MED_INTERPOLATION_GRP_SIZE+MED_NAME_SIZE+1]=MED_INTERPOLATION_GRP;
med_int _cellnodes = cellnode;
med_int _geotype = geotype;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /INTERP/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOpen(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(interpname,ERROR);
/*
* Si le DataGroup /INTERP/<interpname> n'existe pas, on le cree
*/
if ((_interpid = _MEDdatagroupOpen(_root,interpname)) < 0)
if ((_interpid = _MEDdatagroupCreer(_root,interpname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,interpname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,interpname);
/*
* Creation/Ecriture de l'attribut MED_NOM_GEO
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_GEO,&_geotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_GEO);ISCRUTE(_geotype);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_NBB
*/
/* if ( _MEDattributeIntWr(_interpid,MED_NOM_NBB,&nbasisfunc) < 0 ) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path); */
/* SSCRUTE(MED_NOM_NBB);ISCRUTE(nbasisfunc); */
/* goto ERROR; */
/* } */
/*
* Creation/Ecriture de l'attribut MED_NOM_NBV
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_NBV,&nvariable) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_NBV);ISCRUTE(nvariable);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_MDG
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_MDG,&maxdegree) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_MDG);ISCRUTE(maxdegree);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_MCF
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_MCF,&nmaxcoef) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_MCF);ISCRUTE(nmaxcoef);
goto ERROR;
}
/*
* Creation/Ecriture de l'attribut MED_NOM_FCN
*/
if ( _MEDattributeIntWr(_interpid,MED_NOM_FCN,&_cellnodes) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,_path);
SSCRUTE(MED_NOM_FCN);ISCRUTE(_cellnodes);
goto ERROR;
}
_ret = 0;
ERROR:
if (_interpid>0) if (_MEDdatagroupFermer(_interpid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_interpid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_INTERPOLATION_GRP);
ISCRUTE_id(_root);
}
return _ret;
}
med_err
MEDlinkWr(const med_idt fid,
const char * const meshname,
const char * const link)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _lid=0, _root=0;
med_err _ret=-1;
char _path[MED_TAILLE_LIENS+MED_NAME_SIZE+1]=MED_LIENS;
med_int _n=0;
med_filter _filter = MED_FILTER_INIT;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /LIENS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(link,ERROR);
/*
* Si le DataGroup /LIENS/<meshname> n'existe pas, on le cree
*/
if ((_lid = _MEDdatagroupOuvrir(_root,meshname)) < 0)
if ((_lid = _MEDdatagroupCreer(_root,meshname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,meshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,meshname);
/*
* On stocke <n> sous forme d'attribut
*/
_n = strlen(link);
if (_MEDattributeIntWr(_lid,MED_NOM_NBR,&_n) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_LINK_MSG);
SSCRUTE(_path);SSCRUTE(MED_NOM_NBR);ISCRUTE(_n);
goto ERROR;
}
/*
* On stocke le link dans un dataset
*/
if ( MEDfilterEntityCr(fid,_n, 1, 1, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_STMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
/* SSCRUTE(link); */
if ( _MEDdatasetWr(_lid,MED_NOM_LIE,MED_INTERNAL_CHAR,&_filter, link) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_LIE);SSCRUTE(_path);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_LINK_MSG); SSCRUTE(_path);
goto ERROR;
}
_ret = 0;
ERROR:
if (_lid>0) if (_MEDdatagroupFermer(_lid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_lid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_LIENS);
ISCRUTE_id(_root);
}
return _ret;
}
med_err MEDchampCr( med_idt fid, char * champ, med_type_champ type, char * comp,
char * unit, med_int ncomp)
{
med_err ret=-1;
med_idt root=0,gid=0;
char chemin[MED_TAILLE_CHA+1];
med_size dimd[1];
med_int _type = (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.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un champ en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group "/CHA/" n'existe pas, on le cree
*/
strncpy(chemin,MED_CHA,MED_TAILLE_CHA-1);
chemin[MED_TAILLE_CHA-1] = '\0';
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si le Data Group cha n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(champ,ERROR);
if ((gid = _MEDdatagroupCreer(root,champ)) < 0) {
MESSAGE("Erreur à la création du champ : ");
SSCRUTE(champ);
goto ERROR;
}
/*
* Les infos sur les composants du champ
*/
if ( _MEDattrEntierEcrire(gid,MED_NOM_NCO,&ncomp) < 0 ) {
MESSAGE("Erreur à l'écriture du nombre de composantes : ");
ISCRUTE(ncomp);
goto ERROR;
}
if ( _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type) < 0) {
MESSAGE("Erreur à l'écriture du type du champ : ");
ISCRUTE(_type);
goto ERROR;
}
if ( _MEDattrStringEcrire(gid,MED_NOM_NOM,MED_TAILLE_PNOM*ncomp,comp) < 0) {
MESSAGE("Erreur à l'écriture des noms des composantes : ");
SSCRUTE(comp);
goto ERROR;
}
if ( _MEDattrStringEcrire(gid,MED_NOM_UNI,MED_TAILLE_PNOM*ncomp,unit) < 0) {
MESSAGE("Erreur à l'écriture des unités : ");
SSCRUTE(unit);
goto ERROR;
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
return ret;
}
med_err
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;
}
med_err
MEDgaussEcr(med_idt fid, med_geometrie_element type_geo, med_float *refcoo, med_mode_switch mode_coo,
med_int ngauss, med_float *gscoo, med_float * wg, char * locname )
{
med_idt gid=0, chid=0;
med_size dimd[1];
med_err ret = -1;
med_int typegeo = -1;
char chemin[MED_TAILLE_GAUSS+1]="";
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 ");
goto ERROR;
}
/*
* MED_GAUSS_ELNO est un mot cle reserve
*/
if (! strcmp(locname,MED_GAUSS_ELNO)) {
MESSAGE("MED_GAUSS_ELNO est un mot cle reserve : points Gauss sur les noeuds de l'element");
goto ERROR;
}
/*
* Si le groupe "GAUSS" n'existe pas, on le cree
*/
strncpy(chemin,MED_GAUSS,MED_TAILLE_GAUSS-1);
chemin[MED_TAILLE_GAUSS-1] = '\0';
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Impossible de creer le groupe MED_GAUSS : ");
SSCRUTE(chemin); goto ERROR;
}
/*
* Si le groupe <locname> n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(locname,ERROR);
if ((chid = _MEDdatagroupOuvrir(gid,locname)) >= 0) {
if ( MED_MODE_ACCES != MED_LECTURE_ECRITURE ) {
MESSAGE("Le nom de localisation existe déjà : ");
SSCRUTE(locname); goto ERROR;
}
} else
if ((chid = _MEDdatagroupCreer(gid,locname)) < 0)
goto ERROR;
/*
* On stocke <ngauss> sous forme d'attribut
*/
if (_MEDattrEntierEcrire(chid,MED_NOM_NBR,&ngauss) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
ISCRUTE(ngauss);goto ERROR;
};
/*
* On stocke <type_geo> sous forme d'attribut
*/
typegeo = (med_int) type_geo;
/* sizeof(enum) tjrs = sizeof(int) en C, or
sur machines 64 bits par défaut med_int==long,
du coup sur machines 64 bits _MEDattrEntierEcrire utilise
le type hdf NATIVE_LONG, ce qui pose un problème qd on passe
un enum.
*/
if (_MEDattrEntierEcrire(chid,MED_NOM_GEO,&typegeo) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_GEO : ");
ISCRUTE(type_geo);goto ERROR;
};
/*
* On stocke les coordonnées de référence dans un dataset
*/
dimd[0] = (type_geo%100)*(type_geo/100);
if ( _MEDdatasetNumEcrire(chid,MED_NOM_COO,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) refcoo) < 0 ) {
MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_COO);
ISCRUTE_size(dimd[0]); goto ERROR;
}
/*
* On stocke les points d'intégration dans un dataset
*/
dimd[0] = ngauss*(type_geo/100);
if ( _MEDdatasetNumEcrire(chid,MED_NOM_GAU,MED_FLOAT64,mode_coo,(type_geo/100),MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) gscoo) < 0 ) {
MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_GAU);
ISCRUTE_size(dimd[0]); goto ERROR;
}
/*
* On stocke les poids dans un dataset
*/
dimd[0] = ngauss;
if ( _MEDdatasetNumEcrire(chid,MED_NOM_VAL,MED_FLOAT64,mode_coo,1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) wg) < 0 ) {
MESSAGE("Impossible d'ecrire le dataset : ");SSCRUTE(MED_NOM_VAL);
ISCRUTE_size(dimd[0]); goto ERROR;
}
ret = 0;
ERROR:
/*
* On ferme tout
*/
if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(chid); ret = -1;
}
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid); ret = -1;
}
return ret;
}
void
MEDjointCr231(int dummy,...) {
med_idt fid ;
char * maa_lcl ;
char * jn ;
char * desc ;
med_int dom ;
char * maa_dist ;
med_err * fret ;
med_idt root=0,jntid=0;
med_err ret=-1;
char chemin[MED_TAILLE_MAA+MED_TAILLE_JNT+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_JNT+1];
med_int nbc=0;
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params,med_idt);
maa_lcl = va_arg(params,char *);
jn = va_arg(params,char *);
desc = va_arg(params,char *);
dom = va_arg(params,med_int);
maa_dist = va_arg(params,char*);
fret = va_arg(params,med_err *);
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE ) {
MESSAGE("Impossible de créer un joint en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group "JNT" n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
NOFINALBLANK(maa_lcl,ERROR);
strcat(chemin,maa_lcl);
strncpy(tmp,MED_JNT,MED_TAILLE_JNT-1);
tmp[MED_TAILLE_JNT-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Si un joint du meme nom existe => erreur
* Sinon on le cree
*/
NOFINALBLANK(jn,ERROR);
if ((jntid = _MEDdatagroupCreer(root,jn)) < 0) {
MESSAGE("Erreur à la création du joint : ");
SSCRUTE(jn);
goto ERROR;
}
/*
* L'attribut "DES"
*/
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_DES,MED_TAILLE_DESC,desc)) < 0) {
MESSAGE("Erreur à l'écriture de la description du joint : ");
SSCRUTE(desc);
goto ERROR;
}
/*
* L'attribut "MAI"
*/
/* BUG CORRIGE EN 232 MED_TAILLE_NOM au lieu de MED_TAILLE_MAA */
/* conservé ici pour éviter de reprendre en lib2.3.2 un fichier 2.3.1
en écrivant l'attribut avec une taille plus grande que celle des fichiers 2.3.1 */
if ((ret = _MEDattrStringEcrire(jntid,MED_NOM_MAI,MED_TAILLE_MAA,maa_dist)) < 0) {
MESSAGE("Erreur à l'écriture du nom du maillage distant : ");
SSCRUTE(maa_dist);
goto ERROR;
}
/*
* L'attribut "DOM"
*/
if ((ret = _MEDattrEntierEcrire(jntid,MED_NOM_DOM,&dom)) < 0) {
MESSAGE("Erreur à l'écriture du domaine : ");
ISCRUTE(dom);
goto ERROR;
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (jntid>0) if (_MEDdatagroupFermer(jntid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(jntid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
med_err _MEDattributeStringWr(med_idt pid,
const char * const attname,
const med_size attsize,
const char * const val)
{
med_access_mode MED_ACCESS_MODE;
med_idt _attid=0,aid=0;
med_err _ret=-1;
int type_hdf=0;
med_bool _attmustbecreated= MED_FALSE;
hsize_t _attsize=0;
med_size _valsize=0;
if ( (MED_ACCESS_MODE = _MEDmodeAcces(pid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE, "MED_ACC_UNDEF" );
SSCRUTE(attname); goto ERROR;
}
_valsize=strlen(val);
if (_valsize > attsize) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ATTRIBUTE, attname );
ISCRUTE_size(_valsize);ISCRUTE_size(attsize);goto ERROR;
}
if ((aid = H5Screate(H5S_SCALAR)) < 0){
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATASPACE, attname );
ISCRUTE_id(aid);
}
if ( (type_hdf = H5Tcopy(H5T_C_S1)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_HDFTYPE, MED_ERR_NAME_MSG );
SSCRUTE("H5T_C_S1"); goto ERROR;
}
if ( H5Tset_size(type_hdf,_valsize+1) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_HDFTYPE, MED_ERR_NAME_MSG );
SSCRUTE("H5T_C_S1"); goto ERROR;
}
if ( (_attid=H5Aopen( pid, attname,H5P_DEFAULT )) >= 0 )
if ( MED_ACCESS_MODE == MED_ACC_RDEXT ) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE, "MED_ACC_RDEXT" );
SSCRUTE(attname); goto ERROR;
}
if ( _attid > 0 ) {
if ( (_attsize=H5Aget_storage_size(_attid) ) < 0 ) goto ERROR;
if ( (_valsize+1) > _attsize ) {
if (H5Aclose(_attid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_ATTRIBUTE,"");
ISCRUTE_id(_attid);
goto ERROR;
}
if ( H5Adelete(pid,attname) < 0 ) goto ERROR;
_attmustbecreated=MED_TRUE;
}
}
if ( (_attid < 0) || _attmustbecreated )
if ( (_attid=H5Acreate( pid, attname, type_hdf, aid, H5P_DEFAULT )) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_ATTRIBUTE, attname );
goto ERROR;
}
if ( H5Awrite(_attid,type_hdf,val) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE, attname );
goto ERROR;
}
_ret=0;
ERROR:
if (type_hdf > 0 ) if ( H5Tclose(type_hdf) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_HDFTYPE, MED_ERR_ID_MSG );
ISCRUTE_int(type_hdf);
}
if (aid > 0 ) if ( H5Sclose(aid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASPACE, MED_ERR_ID_MSG );
ISCRUTE_id(aid);
}
if (_attid >0) if ( H5Aclose(_attid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_ATTRIBUTE, MED_ERR_ID_MSG );
ISCRUTE_id(_attid);
}
return _ret;
}
med_err
MEDprofilEcr(med_idt fid,med_int *pflval,med_int n,char *profilname)
{
med_idt gid, chid;
med_size dimd[1];
med_err ret=-1;
char chemin[MED_TAILLE_PROFILS+1];
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 ");
goto ERROR;
}
/*
* Si le groupe "PROFILS" n'existe pas, on le cree
*/
strncpy(chemin,MED_PROFILS,MED_TAILLE_PROFILS-1);
chemin[MED_TAILLE_PROFILS-1] = '\0';
if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((gid = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Impossible de creer le groupe MED_PROFILS : ");
SSCRUTE(chemin); goto ERROR;
}
/*
* Si le groupe "profilname" n'existe pas, on le cree
* Sinon => erreur
*/
NOFINALBLANK(profilname,ERROR);
if ((chid = _MEDdatagroupOuvrir(gid,profilname)) >= 0) {
if ( MED_MODE_ACCES != MED_LECTURE_ECRITURE ) {
MESSAGE("Le profil existe déjà : ");
SSCRUTE(profilname); goto ERROR;
}
} else
if ((chid = _MEDdatagroupCreer(gid,profilname)) < 0)
goto ERROR;
/*
* On stocke "n" sous forme d'attribut
*/
if ((ret = _MEDattrEntierEcrire(chid,MED_NOM_NBR,&n)) < 0) {
MESSAGE("Erreur à l'écriture de l'attribut MED_NOM_NBR : ");
ISCRUTE(n); goto ERROR;
};
/*
* On stocke le profil dans un dataset
*/
dimd[0] = n;
#if defined(HAVE_F77INT64)
ret = _MEDdatasetNumEcrire(chid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) pflval);
#else
ret = _MEDdatasetNumEcrire(chid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*) pflval);
#endif
if (ret < 0 ) {
MESSAGE("Impossible d'ecrire le dataset pflval de taille : ");
ISCRUTE(n); goto ERROR;
}
ret = 0;
ERROR:
/*
* On ferme tout
*/
if (chid>0) if (_MEDdatagroupFermer(chid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(chid); ret = -1;
}
if (gid>0) if (_MEDdatagroupFermer(gid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(gid); ret = -1;
}
return ret;
}
med_err
MEDsubdomainCorrespondenceWr(const med_idt fid,
const char * const localmeshname,
const char * const jointname,
const med_int numdt,
const med_int numit,
const med_entity_type localentitype,
const med_geometry_type localgeotype,
const med_entity_type remoteentitype,
const med_geometry_type remotegeotype,
const med_int nentity,
const med_int * const correspondence) {
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_jntid=0,_meshid=0,_cstpid=0,_datagroup2=0;
med_idt _dataset=0;
med_err _ret=-1;
char _path[MED_TAILLE_JNT+2*MED_NAME_SIZE+2]=MED_JNT;
char _computationstepname[2*MED_MAX_PARA+1]="";
char _datagroupname2[4*MED_TAILLE_NOM_ENTITE+4]="";
char _localgeotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _remotegeotypename [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype=0;
med_filter _filter = MED_FILTER_INIT;
med_int _localgeotype = MED_NONE;
med_int _localentitype = localentitype;
med_int _remotegeotype = MED_NONE;
med_int _remoteentitype = remoteentitype;
if ( localentitype == MED_NODE_ELEMENT ) _localgeotype=MED_NODE ;
if ( localentitype != MED_NODE ) _localgeotype = localgeotype ;
if ( remoteentitype != MED_NODE ) _remotegeotype = remotegeotype ;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Ouverture du dataGroup /JNT/
*/
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,localmeshname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,localmeshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,localmeshname);
/*
* Ouverture du data Group "/JNT/<localmeshname>/<jointname>"
*/
if ((_jntid = _MEDdatagroupOuvrir(_meshid,jointname)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,jointname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,"/");
strcat(_path,jointname);
if ( MEDmeshSortingTypeRd(fid,localmeshname,&_sortingtype) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API," MEDmeshSortingTypeRd");
SSCRUTE(localmeshname);ISCRUTE_int(_sortingtype);goto ERROR;
}
_MEDgetComputationStepName(_sortingtype,numdt,numit,_computationstepname);
if ((_cstpid = _MEDdatagroupOuvrir(_jntid,_computationstepname)) < 0)
if ((_cstpid = _MEDdatagroupCreer(_jntid,_computationstepname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_computationstepname);
SSCRUTE(_path);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_NDT pour �criture */
if ( _MEDattributeIntWr(_cstpid,MED_NOM_NDT,&numdt) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_NOR pour �criture */
if ( _MEDattributeIntWr(_cstpid,MED_NOM_NOR,&numit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
goto ERROR;
}
/*
* Creation/Ouverture du datagroup de niveau
* <localentitype>[.<localgeotype>].<remoteentitype>[.<remotegeotype>]
*/
if (_MEDgetEntityTypeName(_datagroupname2,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(_localgeotypename,localgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(localgeotype);SSCRUTE(jointname);goto ERROR;
}
strcat(_datagroupname2,".");
strcat(_datagroupname2,_localgeotypename);
}
strcat(_datagroupname2,".");
if (_MEDgetEntityTypeName(&_datagroupname2[strlen(_datagroupname2)],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(_remotegeotypename,remotegeotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(remotegeotype);SSCRUTE(jointname);goto ERROR;
}
strcat(_datagroupname2,".");
strcat(_datagroupname2,_remotegeotypename);
}
if ( (_datagroup2 = _MEDdatagroupOuvrir(_cstpid,_datagroupname2)) < 0)
if ((_datagroup2 = _MEDdatagroupCreer(_cstpid,_datagroupname2)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_datagroupname2);
SSCRUTE(_path);SSCRUTE(jointname);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_ENT pour �criture */
if (_MEDattributeIntWr(_datagroup2,MED_NOM_ENT,&_localentitype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_ENT);
ISCRUTE(_localentitype);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_GEO pour �criture */
if (_MEDattributeIntWr(_datagroup2,MED_NOM_GEO,&_localgeotype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_GEO);
ISCRUTE(_localgeotype);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_END pour �criture */
if (_MEDattributeIntWr(_datagroup2,MED_NOM_END,&_remoteentitype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_END);
ISCRUTE(_remoteentitype);goto ERROR;
}
/*Cree ou ouvre l'attribut MED_NOM_GED pour �criture */
if (_MEDattributeIntWr(_datagroup2,MED_NOM_GED,&_remotegeotype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_NOM_GED);
ISCRUTE(_remotegeotype);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 ( _MEDdatasetWr(_datagroup2,MED_NOM_COR,MED_INTERNAL_INT,&_filter, 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_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);
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 ( _MEDattributeIntWr(_dataset,MED_NOM_NBR,&nentity) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_SUBDOMAINJOINT_MSG);
SSCRUTE(_path);ISCRUTE(numdt);ISCRUTE(numit);SSCRUTE(_datagroupname2);
SSCRUTE(MED_NOM_NBR);ISCRUTE(nentity);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 (_jntid>0) if (_MEDdatagroupFermer(_jntid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,jointname);
ISCRUTE_id(_jntid);SSCRUTE(_path);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,localmeshname);
ISCRUTE_id(_meshid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_JNT);
ISCRUTE_id(_root);
}
return _ret;
}
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;
}
med_err
MEDequivalenceCr(const med_idt fid,
const char * const meshname,
const char * const equivname,
const char * const description)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_eqid=0,_meshid=0;
med_err _ret=-1;
char _path[MED_TAILLE_EQS+MED_NAME_SIZE+1]=MED_EQS;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /EQS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(meshname,ERROR);
/*
* Si le DataGroup /EQS/<meshname> n'existe pas, on le cree
*/
if ((_meshid = _MEDdatagroupOuvrir(_root,meshname)) < 0)
if ((_meshid = _MEDdatagroupCreer(_root,meshname)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,meshname);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,meshname);
NOFINALBLANK(equivname,ERROR);
/*
* Si le Data Group "/EQS/<meshname>/<equivname>" n'existe pas, on le cree
*/
if ((_eqid = _MEDdatagroupOuvrir(_meshid,equivname)) < 0)
if ((_eqid = _MEDdatagroupCreer(_meshid,equivname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,equivname);
SSCRUTE(_path);goto ERROR;
}
/* if ( (_eqid = _MEDmeshAssociatedGroupCr(fid, */
/* MED_EQS_NOM, */
/* meshname, */
/* numdt, */
/* numit, */
/* -1, */
/* MED_FALSE, */
/* equivalencename ) ) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDmeshAssociatedGroupCr"); */
/* SSCRUTE(MED_EQS_NOM);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(equivalencename); */
/* goto ERROR; */
/* } */
/*
* L'attribut "DES"
*/
if ((_ret = _MEDattributeStringWr(_eqid,MED_NOM_DES,MED_COMMENT_SIZE,
description)) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_EQUIVALENCE_MSG);
SSCRUTE(equivname);SSCRUTE(description);
goto ERROR;
}
_ret=0;
ERROR:
if (_eqid>0) if (_MEDdatagroupFermer(_eqid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,equivname);
ISCRUTE_id(_eqid);SSCRUTE(_path);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_eqid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_EQS);
ISCRUTE_id(_eqid);
}
return _ret;
}
void
_MEDfieldCr31(int dummy, ...) {
med_err _ret=-1;
med_idt _root=0,_datagroup1=0;
med_int _fieldtype ;
char _datagroupname1[MED_NAME_SIZE+1]="";
med_access_mode _MED_ACCESS_MODE;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_field_type , , fieldtype );
MED_VARGS_DECL(const, med_int , , ncomponent );
MED_VARGS_DECL(const, char *, const , componentname );
MED_VARGS_DECL(const, char *, const , componentunit );
MED_VARGS_DECL(const, char *, const , dtunit );
MED_VARGS_DECL(const, char *, const , meshname );
MED_VARGS_DECL(, med_err * , , fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, med_field_type, , fieldtype );
MED_VARGS_DEF(const, med_int , , ncomponent );
MED_VARGS_DEF(const, char *, const , componentname );
MED_VARGS_DEF(const, char *, const , componentunit );
MED_VARGS_DEF(const, char *, const , dtunit );
MED_VARGS_DEF(const, char *, const , meshname );
MED_VARGS_DEF(, med_err * , , fret );
_MEDmodeErreurVerrouiller();
_fieldtype = (med_int) fieldtype;
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup MED_FIELD_GRP n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,MED_FIELD_GRP)) < 0)
if ((_root = _MEDdatagroupCreer(fid,MED_FIELD_GRP)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
goto ERROR;
}
NOFINALBLANK(fieldname,ERROR);
/*
* Si le Data Group "/CHA/<fieldname>" n'existe pas, on le cree
*/
if ((_datagroup1 = _MEDdatagroupOuvrir(_root,fieldname)) < 0)
if ((_datagroup1 = _MEDdatagroupCrOrderCr(_root,fieldname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
SSCRUTE(fieldname);goto ERROR;
}
/*
* Les infos sur les composantes du champ
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NCO,&ncomponent) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NCO);
ISCRUTE(ncomponent);goto ERROR;
}
/* Tous les types med_field_type sont autorisés dans MEDfieldCr mais :
Avant la 3.3.0 seuls les types : MED_FLOAT64,MED_INT32 et MED_INT64 étaient autorisés dans MEDfieldValueAdvancedWr
et seul le type med_int et med_float64 pouvaient être utilisés en C.
A l'écriture, si med_int=int les champs MED_INT32 étaient stockés en interne en HDFINT32bits
A l'écriture, si med_int=long les champs MED_INT32 étaient stockés en interne en HDFINT64bits
A la lecture : - si med_int=int le champ MED_INT32 est relu en en HDFINT32bit avec conversion 64->32 si necessaire
- si med_int=long le champ MED_INT32 est relu en en HDFINT64bit avec conversion 32->64 si necessaire
A l'écriture, si med_int=int les champs MED_INT64 étaient interdits
A l'écriture, si med_int=long les champs MED_INT64 étaient stockés en interne en HDFINT64bits
A la lecture : - si med_int=int le champ MED_INT64 ne pouvait pas être relu (pour prevenir la perte d'information)
- si med_int=long le champ MED_INT64 est relu sans conversion
Depuis la 3.3.0 en plus des types MED_FLOAT64,MED_INT32 et MED_INT64 les types MED_FLOAT32 et MED_INT sont autorisés dans MEDfieldValueAdvancedWr et aux types med_int et med_float64 utilisés en C sont ajoutés les types med_float32, med_int32 et med_int64.
MED_INT32 :
A l'écriture : si med_int=int les champs MED_INT32 sont toujours stockés en interne en HDFINT32bits (utiliser med_int32 ou med_int(!))
si med_int=long les champs MED_INT32 sont désormais stockés en interne en HDFINT32bits (utiliser le type med_int64) et désormais
A la lecture : si med_int=int les champs MED_INT32 sont toujours relus en HDFINT32bits sans conversion (utiliser med_int32 ou med_int(!))
si med_int=long les champs MED_INT32 sont désormais relus en HDFINT32bits sans conversion (utiliser le type med_int32)
MED_INT64 :
A l'écriture : si med_int=int les champs MED_INT64 sont désormais autorisés et stockés en interne en HDFINT64bits (utiliser le type med_int64)
si med_int=long les champs MED_INT64 sont toujours autorisés et stockés en interne en HDFINT64bits (utiliser le type med_int64 ou med_int(!))
A la lecture : si med_int=int les champs MED_INT64 sont désormais relus en HDFINT64bits sans conversion (utiliser le type med_int64)
si med_int=long les champs MED_INT64 sont toujours relus en HDFINT64bits sans conversion (utiliser le type med_int64 ou med_int(!))
MED_INT :
A l'écriture : si med_int=int les champs MED_INT sont désormais acceptés et stockés en interne en HDFINT32bits (utiliser med_int ou med_int32(!))
si med_int=long les champs MED_INT sont désormais acceptés et stockés en interne en HDFINT64bits (utiliser med_int ou med_int64(!))
A la lecture : si med_int=int les champs MED_INT sont désormais acceptés et relus en HDFINT32bits avec conversion/maxint si necessaire (utiliser med_int ou med_int32(!))
si med_int=long les champs MED_INT sont désormais acceptés et relus en HDFINT64bits avec conversion si necessaire (utiliser le type med_int32)
Plateforme 32 bits : TODO si la plateforme est 32 bits, il faut .... ?
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_TYP,&_fieldtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_TYP);
ISCRUTE(_fieldtype);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_NOM,
MED_SNAME_SIZE*ncomponent,componentname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NOM);
SSCRUTE(componentname);goto ERROR;
}
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNI,
MED_SNAME_SIZE*ncomponent,componentunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNI);
SSCRUTE(componentunit);goto ERROR;
}
/*MODEL : MED_NOM_UNI vient du niveau en dessous
Cree ou ouvre l'attribut MED_NOM_UNI pour écriture
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/*MODEL : MED_NOM_MAI est écrit dans l'API de création de champ
* Si c'est la première référence à un maillage, initialise l'attribut MED_MAI à ce maillage
*/
NOFINALBLANK(meshname,ERROR);
if (_MEDattributeStringWr(_datagroup1,MED_NOM_MAI,MED_NAME_SIZE,meshname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_MAI);
SSCRUTE(meshname);
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,meshname);
goto ERROR;
}
/*
* On ferme tout
*/
_ret=0;
ERROR:
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_FIELD_GRP);
ISCRUTE_id(_root);
}
va_end(params);
*fret = _ret;
return;
}
void
MEDfamCr231(int dummy,...)
{
med_idt fid;
char *maa;
char *famille;
med_int numero;
med_int *attr_ident;
med_int *attr_val;
char *attr_desc;
med_int n_attr;
char *groupe;
med_int n_groupe;
med_err *fret ;
med_idt root=0, datagroup=0, famid=0;
med_err ret=-1;
med_size dimd[1];
char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_FAS_ENTITE+MED_TAILLE_NOM+1];
char tmp[MED_TAILLE_FAS+1];
char stockage[MED_TAILLE_FAS_ENTITE+1] = "NONE";
med_mode_acces MED_MODE_ACCES;
va_list params;
va_start(params,dummy);
fid = va_arg(params, med_idt );
maa = va_arg(params, char* );
famille = va_arg(params, char* );
numero = va_arg(params, med_int );
attr_ident = va_arg(params, med_int*);
attr_val = va_arg(params, med_int*);
attr_desc = va_arg(params, char* );
n_attr = va_arg(params, med_int );
groupe = va_arg(params, char* );
n_groupe = va_arg(params, med_int );
fret = va_arg(params, med_err*);
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if (MEDcheckVersion(fid) < 0) {*fret=-1;return;}
if ( (MED_MODE_ACCES = _MEDmodeAcces(fid) ) == MED_UNDEF_MODE_ACCES ) {
MESSAGE("Impossible de déterminer le mode d'acces au fichier.");
goto ERROR;
}
if ( MED_MODE_ACCES == MED_LECTURE) {
MESSAGE("Impossible de créer une famille en mode MED_LECTURE.");
goto ERROR;
};
/*
* Si le Data Group FAS n'existe pas, on le cree
*/
strcpy(chemin,MED_MAA);
/* BUG NON CORRIGE en 2.3.1 à cause
des noms de familles crées en F77
NOFINALBLANK(maa,ERROR);*/
strcat(chemin,maa);
strncpy(tmp,MED_FAS,MED_TAILLE_FAS-1);
tmp[MED_TAILLE_FAS-1] = '\0';
strcat(chemin,tmp);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
/*
* Le lieu de stockage varie selon le signe du "numero"
* de famille
* = 0 => FAMILLE NEUTRE
* > 0 => FAMILLE DE NOEUD
* < 0 => FAMILLE DE MAILLE/FACE/ARETE
*/
if (numero != 0) {
if ((ret = _MEDdatagroupFermer(root)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root);ret = -1;
goto ERROR;
}
if (numero > 0)
strncpy(stockage,MED_FAS_NOEUD,MED_TAILLE_FAS_ENTITE-1);
if (numero < 0)
strncpy(stockage,MED_FAS_ELEME,MED_TAILLE_FAS_ENTITE-1);
stockage[MED_TAILLE_FAS_ENTITE-1] = '\0';
strcat(chemin,stockage);
if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
if ((root = _MEDdatagroupCreer(fid,chemin)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(chemin);
goto ERROR;
}
}
/*
* Si le Data Group de meme nom que famille existe => erreur
* Sinon on le cree
*/
/*
* POUR LA FAMILLE DE NUMERO 0, ON FORCE LE NOM
*/
if (numero == 0)
strcpy(famille,FAMILLE_ZERO);
/*
* Création de la famille
*/
if ((famid = _MEDdatagroupCreer(root,famille)) < 0) {
MESSAGE("Erreur à la création du famille : ");
SSCRUTE(famille);
goto ERROR;
}
/*
* L'attribut NUM
*/
if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero)) < 0) {
MESSAGE("Erreur à l'écriture du numéro de famille : ");
ISCRUTE(numero);
goto ERROR;
}
/*
* Le Data Group "GRO"
*/
if (n_groupe > 0) {
/*
* On cree le Data Group
*/
if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(MED_NOM_GRO);
goto ERROR;
}
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe)) < 0) {
MESSAGE("Erreur à l'écriture du nombre de groupe : ");
ISCRUTE(n_groupe);
goto ERROR;
}
/*
* Data Set des noms des groupes "NOM"
*/
dimd[0] = n_groupe*MED_TAILLE_LNOM+1;
if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe))<0) {
MESSAGE("Erreur à l'écriture des noms des groupes : ");
SSCRUTE(groupe);
goto ERROR;
}
/*
* On ferme le Data Group
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup);
goto ERROR;
}
}
/*
* Le Data Group "ATT"
*/
if (n_attr > 0) {
if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0) {
MESSAGE("Erreur à la création du datagroup : ");
SSCRUTE(MED_NOM_ATT);
goto ERROR;
}
/*
* L'attribut "NBR"
*/
if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr)) < 0) {
MESSAGE("Erreur à l'écriture du nombre d'attributs : ");
ISCRUTE(n_attr);
goto ERROR;
}
/*
* Le Data Set "IDE"
*/
dimd[0] = n_attr;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char *)attr_ident)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_IDE);
goto ERROR;
}
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char *)attr_ident)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_IDE);
goto ERROR;
}
#endif
/*
* Le Data Set "VAL"
*/
dimd[0] = n_attr;
#if defined(HAVE_F77INT64)
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*)attr_val)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_VAL);
goto ERROR;
}
#else
if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,MED_NO_PFLMOD,0,0,MED_NOPG,dimd,
(unsigned char*)attr_val)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_VAL);
goto ERROR;
}
#endif
/*
* Le Data Set "DES"
*/
dimd[0] = n_attr*MED_TAILLE_DESC+1;
if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc)) < 0) {
MESSAGE("Erreur à l'écriture du dataset : ");
SSCRUTE(MED_NOM_DES);
goto ERROR;
}
/*
* On ferme le Data Group
*/
if ((ret = _MEDdatagroupFermer(datagroup)) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_int(datagroup);
goto ERROR;
}
}
/*
* On ferme tout
*/
ret=0;
ERROR:
if (famid>0) if (_MEDdatagroupFermer(famid) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(famid);ret = -1;
}
if (root>0) if (_MEDdatagroupFermer(root) < 0) {
MESSAGE("Impossible de fermer le datagroup : ");
ISCRUTE_id(root); ret = -1;
}
va_end(params);
*fret = ret;
return;
}
med_err
MEDprofileWr(const med_idt fid,
const char* const profilename,
const med_int profilesize,
const med_int* const profilearray)
{
med_access_mode _MED_ACCESS_MODE;
med_idt _root=0,_pfid=0;
med_err _ret=-1;
char _path[MED_TAILLE_PROFILS+MED_NAME_SIZE+1]=MED_PROFILS;
med_filter _filter = MED_FILTER_INIT;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
/*
* Si le DataGroup /PROFILS/ n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,_path)) < 0)
if ((_root = _MEDdatagroupCreer(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
NOFINALBLANK(profilename,ERROR);
/*
* Si le DataGroup /PROFILS/<profilename> n'existe pas, on le cree
*/
if ((_pfid = _MEDdatagroupOuvrir(_root,profilename)) < 0)
if ((_pfid = _MEDdatagroupCreer(_root,profilename)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,profilename);
SSCRUTE(_path);goto ERROR;
}
strcat(_path,profilename);
/*
* On stocke "profilesize" sous forme d'attribut
*/
if (_MEDattributeIntWr(_pfid,MED_NOM_NBR,&profilesize) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_PROFILE_MSG);
SSCRUTE(profilename);SSCRUTE(MED_NOM_NBR);ISCRUTE(profilesize);
goto ERROR;
}
/*
* On stocke le profil dans un dataset
*/
if ( MEDfilterEntityCr(fid, profilesize, 1, 1, MED_ALL_CONSTITUENT,
MED_NO_INTERLACE,MED_UNDEF_PFLMODE,
MED_NO_PROFILE, MED_UNDEF_SIZE, NULL, &_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILTER,MED_ERR_INTERNAL_MSG);
goto ERROR;
}
if ( _MEDdatasetWr(_pfid,MED_NOM_PFL,MED_INTERNAL_INT,&_filter, profilearray) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_DATASET,MED_NOM_PFL);SSCRUTE(_path);
goto ERROR;
}
if ( MEDfilterClose(&_filter) < 0 ) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_FILTER,MED_ERR_PROFILE_MSG); SSCRUTE(_path);
goto ERROR;
}
_ret = 0;
ERROR:
if (_pfid>0) if (_MEDdatagroupFermer(_pfid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,profilename);
ISCRUTE_id(_pfid);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_PROFILS);
ISCRUTE_id(_root);
}
return _ret;
}
med_err
_MEDmeshCr(const med_idt fid, const char * const root,
const char * const meshname, const med_int spacedim,
const med_int meshdim, const med_mesh_type meshtype,
const char * const description, const char * const dtunit,
const med_sorting_type sortingtype,
const med_axis_type axistype, const char * const axisname,
const char * const axisunit)
{
med_access_mode _MED_ACCESS_MODE;
med_err _ret=-1;
med_idt _root=0,_datagroup1=0;
/* _datagroup2=0,_datagroup3=0; */
med_int _intmeshtype = (med_int) meshtype;
med_int _intaxistype = (med_int) axistype;
char _datagroupname1[MED_NAME_SIZE+1]="";
/* char _geotypename[MED_NAME_SIZE_ENTITE+1]=""; */
med_int _lastnumdt=MED_NO_DT, _lastnumit=MED_NO_IT;
med_int _intsortingtype =(med_int) MED_SORT_UNDEF;
med_int _intexistingmeshtype=(med_int) MED_UNDEF_MESH_TYPE;
med_mesh_type _existingmeshtype = meshtype;
med_sorting_type _existingsortingtype = sortingtype;
med_size _nstep=0;
/*
* On inhibe le gestionnaire d'erreur
*/
_MEDmodeErreurVerrouiller();
if (_MEDcheckVersion30(fid) < 0) goto ERROR;
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
if ( _MED_ACCESS_MODE == MED_ACC_RDONLY) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
ISCRUTE_int(_MED_ACCESS_MODE);
goto ERROR;
}
if ( sortingtype == MED_SORT_UNDEF) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_PARAMETER,"sortingtype");
ISCRUTE_int(sortingtype);
goto ERROR;
}
/*
* Si le DataGroup root n'existe pas, on le cree
*/
if ((_root = _MEDdatagroupOuvrir(fid,root)) < 0)
if ((_root = _MEDdatagroupCreer(fid,root)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,root);
goto ERROR;
}
NOFINALBLANK(meshname,ERROR);
/*
* Si le Data Group "/MAA.../<meshname>" n'existe pas, on le cree
*/
if ((_datagroup1 = _MEDdatagroupOuvrir(_root,meshname)) < 0)
if ((_datagroup1 = _MEDdatagroupCreer(_root,meshname)) < 0 ) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,meshname);
goto ERROR;
}
/*
* Creation de l'attribut dimension du maillage
*/
if (meshdim > spacedim) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_PARAMETER,"meshdim");
ISCRUTE(meshdim);ISCRUTE(spacedim);
SSCRUTE(root);SSCRUTE(meshname);goto ERROR;
}
/*
* Creation de l'attribut dimension de l'espace
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_ESP,&spacedim) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_ESP);
ISCRUTE(spacedim);goto ERROR;
}
/*
* Creation de l'attribut dimension du maillage
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_DIM,&meshdim) < 0 ) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_DIM);
ISCRUTE(meshdim);goto ERROR;
}
/* Lecture de l'attribut MED_NOM_TYP */
if (_MEDattrEntierLire(_datagroup1,MED_NOM_TYP,&_intexistingmeshtype) >= 0)
_existingmeshtype = (med_mesh_type) (_intexistingmeshtype);
if ( _existingmeshtype != meshtype ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_WRITE,MED_ERR_ATTRIBUTE_MSG);
SSCRUTE(MED_NOM_TYP);SSCRUTE(meshname);SSCRUTE(_datagroupname1);
ISCRUTE_int(_existingmeshtype);ISCRUTE_int(meshtype);goto ERROR;
}
/*
* Creation de l'attribut correspondant au type du maillage (MED_STRUCTURE, MED_NON_STRUCTURE)
* L'attribut "TYP"
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_TYP);
ISCRUTE(_intmeshtype);goto ERROR;
}
/*
* La description associee au maillage
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_DES,MED_COMMENT_SIZE,description) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_DES);
SSCRUTE(description);goto ERROR;
}
/*
* Creation de l'attribut nom de l'unit~ des dates
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNT,MED_SNAME_SIZE,dtunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNT);
SSCRUTE(dtunit);goto ERROR;
}
/*
* Test de l'existence de l'attribut de tri des s~quences de calcul
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_SRT,&_intsortingtype) >= 0) {
_existingsortingtype = (med_sorting_type) (_intsortingtype);
/* Nombre d'~tapes de calcul existantes */
_MEDnObjects(_datagroup1,".",&_nstep);
}
if ( (_existingsortingtype != sortingtype) && _nstep ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_COMPUTINGSTEP,MED_ERR_ATTRIBUTE_MSG);
SSCRUTE(MED_NOM_SRT);SSCRUTE(meshname);SSCRUTE(_datagroupname1);
ISCRUTE_int(_existingsortingtype);ISCRUTE_int(sortingtype);goto ERROR;
}
/*
* Creation de l'attribut de tri des s~quences de calcul
*/
_intsortingtype = sortingtype;
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_SRT);
ISCRUTE_int(sortingtype);goto ERROR;
}
/*
* Creation de l'attribut de la derni~re it~ration cr~e
*/
/* if ( _MEDattributeIntWr(_datagroup1,MED_NOM_NXI,&_lastnumit) < 0) { */
/* MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG); */
/* SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NXI); */
/* ISCRUTE(_lastnumit);goto ERROR; */
/* } */
/*
* L'attribut "REP"
*/
if ( _MEDattributeIntWr(_datagroup1,MED_NOM_REP,&_intaxistype) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_REP);
ISCRUTE(_intaxistype);goto ERROR;
}
/*
* Attribut "NOM"
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_NOM,spacedim*MED_SNAME_SIZE,axisname) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_NOM);
SSCRUTE(axisname);goto ERROR;
}
/*
* Attribut "UNI"
*/
if ( _MEDattributeStringWr(_datagroup1,MED_NOM_UNI,spacedim*MED_SNAME_SIZE,axisunit) < 0) {
MED_ERR_(_ret,MED_ERR_WRITE,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_UNI);
SSCRUTE(axisunit);goto ERROR;
}
/*
* Cr~ation du datagroup des mailles associ~es ~ un maillage structur~
* Cel~ permet d'utiliser les routines famille, num~ros/noms optionnels
* de la m~me fa~on que pour les maillages non structur~s
*/
/* if ( meshtype == MED_STRUCTURE ) { */
/* if ((_datagroup2 = _MEDdatagroupCreer(_datagroup1,MED_NOM_MAI)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,root); */
/* SSCRUTE(meshname);SSCRUTE(MED_NOM_MAI);goto ERROR; */
/* } */
/* switch ( meshdim ) { */
/* case 1 : strcpy(_geotypename,MED_NOM_SE2); */
/* break; */
/* case 2 : strcpy(_geotypename,MED_NOM_QU4); */
/* break; */
/* case 3 : strcpy(_geotypename,MED_NOM_HE8); */
/* break; */
/* case 0 : strcpy(_geotypename,MED_NOM_PO1); */
/* break; */
/* default : */
/* MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_PARAMETER,""); */
/* ISCRUTE(meshdim);SSCRUTE(root);SSCRUTE(meshname);goto ERROR; */
/* } */
/* if ((_datagroup3 = _MEDdatagroupCreer(_datagroup2,_geotypename)) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DATAGROUP,_geotypename); */
/* SSCRUTE(root);SSCRUTE(meshname);SSCRUTE(MED_NOM_MAI);ISCRUTE_int(_geotypename); */
/* goto ERROR; */
/* } */
/* } */
/*
* Nettoyages divers
*/
_ret = 0;
ERROR:
/* if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_geotypename); */
/* ISCRUTE_id(_datagroup3); */
/* } */
/* if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) { */
/* MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,MED_NOM_MAI); */
/* ISCRUTE_id(_datagroup2); */
/* } */
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,meshname);
ISCRUTE_id(_datagroup1);
}
if (_root>0) if (_MEDdatagroupFermer(_root) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,root);
ISCRUTE_id(_root);
}
return _ret;
}
