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 _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 _MEDfieldComputingStepCheck236(med_idt fid, const char * const fieldname,
med_size * const ncpst,
med_bool checkmultiplemesh, med_bool * const multiplemesh,
med_bool checkmeshname, med_bool * const samedefaultmeshname)
{
med_err _ret=-1,_err=0;
med_idt _cstpid=0;
char _ent_geo [2*MED_TAILLE_NOM_ENTITE+2]="";
char _path [(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+
(2*MED_TAILLE_NOM_ENTITE+1)+1+(2*MED_MAX_PARA)+1]=MED_CHA;
int _pathlen=0;
med_size _i=0,_n=0;
med_size _prevnseq=0,_nseq =0;
med_string_itdatas _itdatas;
if( _MEDfieldChecked(fid,fieldname) ) goto SORTIE;
/*
* On construit le nom du datagroup
*/
strcat(_path,fieldname);
/*
* On compte le nombre de couple (entitytype,geotype)
*/
if ((_err=_MEDnObjects(fid,_path,&_n)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,MED_NOM_ENT "." MED_NOM_GEO);
goto ERROR;
}
_pathlen = strlen(_path);
/*
* Pour tous les couples (entitytype,geotype)
* on vérifie qu'il y a le même nombre de séquences de calcul (sinon le fichier n'est pas conforme au modèle 2.3.6)
* Ceci est une vérification partielle que le modèle 2.3.6 a été respecté :
* - Il faudrait normalement vérifier qu'il s'agit aussi des mêmes séquences de calcul
* Etant donnée la faible utilisation du usecase multimaillages et le coût de traitement associé à cette
* vérification complémentaire, celle-ci n'est pas faite.
* Par contre, il est necessaire de savoir si plusieurs noms de maillages
apparaissent ou si un seul est utilisé (ici on vérifie uniquement que le maillage par défaut est le même)
*/
/*L'attribut dont il faut vérifier la valeur pour toutes les étapes de calcul de tous les
couple (entitytype,geotype) est MED_NOM_MAI*/
if (checkmeshname) _MEDcheckAttributeStringInit(&_itdatas,MED_NOM_MAI,MED_TAILLE_NOM);
for (_i=0; _i <_n; ++_i ) {
/*
* On recupere le nom du couple (entitytype,geotype) n°_i
*/
if ( _MEDobjectGetName(fid, _path ,_i, _ent_geo) < 0 ) {
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_DATAGROUP,_path);
SSCRUTE(_path); goto ERROR;
}
/* SSCRUTE(_path); */
strcpy(&_path[_pathlen],"/");
strcat(_path,_ent_geo);
/* SSCRUTE(_path); */
/* ISCRUTE(_prevnseq); */
/* ISCRUTE(_nseq); */
/*
* On vérifie qu'il y a le même nombre de séquences de calcul
* que pour le couple (entitytype,geotype) précédent
* on le vérifie pas que ce sont bien les mêmes
*/
if ( _prevnseq != _nseq ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_ent_geo);
ISCRUTE_size(_prevnseq);ISCRUTE_size(_nseq);ISCRUTE_size(_i);
goto ERROR;
}
/*
* On compte le nombre de séquences de calcul pour le couple (entitytype,geotype) n°_i
*/
if ((_err=_MEDnObjects(fid,_path,&_nseq)) <0)
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_ent_geo);
goto ERROR;
}
_prevnseq = _nseq;
if (checkmeshname || checkmultiplemesh) {
if ((_cstpid = _MEDdatagroupOuvrir(fid,_path)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,_path);
goto ERROR;
}
}
if (checkmeshname) {
/*
* On vérifie que le nom du maillage par défaut est le même pour toutes
* les étapes de calcul de tous les couples (entitytype,geotype)
*/
if (_MEDiterate(_cstpid, _MEDcheckAttributeStringFunc, &_itdatas ) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ATTRIBUTE,MED_ERR_VALUE_MSG);
SSCRUTE(_itdatas.attvalprec); SSCRUTE(_itdatas.attval); goto ERROR;
}
}
/*
* On vérifie qu'un seul maillage est utilisé pour toutes
* les étapes de calcul de tous les couples (entitytype,geotype)
*/
if (checkmultiplemesh) {
if (_MEDiterate(_cstpid, _MEDchecknSublinkFunc, multiplemesh ) < 0) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,MED_ERR_NBR_MSG MED_ERR_MESH_MSG);
SSCRUTE(_path);goto ERROR;
}
}
if (_cstpid>0) if (_MEDdatagroupFermer(_cstpid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_path);
ISCRUTE_id(_cstpid);
}
_path[_pathlen]='\0';
}
if (checkmeshname) _MEDcheckAttributeStringFin(&_itdatas);
*ncpst = _nseq;
_MEDfieldCheckedSetCache(fid, fieldname,MED_TRUE);
SORTIE:
_ret = 0;
ERROR:
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;
}
med_err _MEDfilterBlockOfEntityNoICompactCr(const med_idt fid,
const med_int nentity,
const med_int nvaluesperentity,
const med_int nconstituentpervalue,
const med_int constituentselect,
const med_storage_mode storagemode,
const char * const profilename,
const med_size start,
const med_size stride,
const med_size count,
const med_size blocksize,
const med_size lastblocksize,
med_filter* const filter) {
med_size _start=start-1,_count=count;
med_size _1[1]={1};
med_idt _memspace [MED_MAX_FILTER_SPACES]= MED_MAX_FILTER_SPACES_INIT;
med_idt _filespace[MED_MAX_FILTER_SPACES]= MED_MAX_FILTER_SPACES_INIT;
med_size _memspacesize[1]={0},_filespacesize[1]={0};
med_size _startmem[1]={0},_startfile[1]={0},_filelastblocksize[1]={0};
med_size _stridemem[1]={0},_countmem[1]={0},_countfilelastblock[1]={0};
med_size _startfile_lastblock[1]={0},_stridefile[1]={0},_blocksize[1]={0},_memblocksize[1]={0};
med_size _onedimallvaluesfileoffset=0,_onedimallvaluesmemoffset=0;
med_err _ret=-1;
int _dim=0, _firstdim=0, _dimutil=0, _lastdim=0,_index=0 ;
int _anyprofil=0,_anylastblock=0;
med_int _profilearraysize=0,profilearraysize=0;
if ( constituentselect != MED_ALL_CONSTITUENT) {
_firstdim = constituentselect-1;
_lastdim = constituentselect;
_dimutil = 1;
} else {
_firstdim = 0;
_lastdim = nconstituentpervalue;
_dimutil = nconstituentpervalue;
}
if ( (count < 1 ) || ( blocksize < 1 ) ) {
_index=0;
for (_dim=_firstdim; _dim < _lastdim; _dim++) {
if ( (_memspace[_index]=H5Screate(H5S_NULL)) < 0 ) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_MEMSPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_memspace[_index]);
goto ERROR;
}
if ( (_filespace[_index]=H5Screate(H5S_NULL)) < 0 ) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_FILESPACE,MED_ERR_ID_MSG);
ISCRUTE_int(_filespace[_index]);
goto ERROR;
}
++_index;
}
goto SAVEFILTER;
}
if ( (count > 1) && (lastblocksize != blocksize) && lastblocksize ) /*Tester ou non si lastblocksize est bien > blocksize */
{--_count;_anylastblock=1;_countfilelastblock[0]=1;_filelastblocksize[0]=1;}
/* ISCRUTE(_start); */
/* ISCRUTE(_count); */
/* ISCRUTE(_countfilelastblock[0]); */
/* Conditionne les traitements à l'existence d'un profil */
if ( _anyprofil=(strlen(profilename)) ) {
profilearraysize = MEDprofileSizeByName(fid,profilename);
_profilearraysize=profilearraysize;
} else {
_profilearraysize = nentity;
}
_blocksize [0] = blocksize*nvaluesperentity; /*!*nconstituentpervalue car on sélectionne par constituent*/
_onedimallvaluesmemoffset = _blocksize[0]*_count+ _anylastblock*lastblocksize*nvaluesperentity;
_memspacesize [0] = _onedimallvaluesmemoffset*nconstituentpervalue;
_stridemem [0] = 1;
_countmem [0] = 1;
_memblocksize [0] = _onedimallvaluesmemoffset;
_onedimallvaluesfileoffset = _profilearraysize*nvaluesperentity;
_filespacesize [0] = _onedimallvaluesfileoffset*nconstituentpervalue;
_stridefile [0] = stride*nvaluesperentity;
_filelastblocksize [0] *= lastblocksize*nvaluesperentity;
/* ISCRUTE(_blocksize [0] ); */
/* ISCRUTE(_onedimallvaluesmemoffset ); */
/* ISCRUTE_id(_memspacesize [0] ); */
/* ISCRUTE(_stridemem [0] ); */
/* ISCRUTE(_countmem [0] ); */
/* ISCRUTE(_memblocksize [0] ); */
/* ISCRUTE(_onedimallvaluesfileoffset ); */
/* ISCRUTE_int(_filespacesize [0] ); */
/* ISCRUTE(_stridefile [0] ); */
/* ISCRUTE(_filelastblocksize [0] ); */
if ( _memspacesize[0] > _filespacesize[0] ) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_MEMSPACE,MED_ERR_SIZE_MSG);
ISCRUTE_size(_memspacesize[0]);
ISCRUTE_size(_filespacesize[0]);
goto ERROR;
}
_index=0;
for (_dim=_firstdim; _dim < _lastdim; _dim++) {
if ( (_memspace[_index] = H5Screate_simple (1, _memspacesize, NULL)) <0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_MEMSPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_memspace[_index]);
MESSAGE(MED_ERR_SIZE_MSG);
ISCRUTE_size(_memspacesize[0]);
goto ERROR;
}
_startmem [0] = _dim*_onedimallvaluesmemoffset;
if ( H5Sselect_hyperslab (_memspace[_index], H5S_SELECT_SET, _startmem, _stridemem,
_countmem, _memblocksize) <0 ) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_MEMSPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_memspace[_index]);
goto ERROR;
}
/* ISCRUTE_id(_memspace[_index]); */
if ( (_filespace[_index] = H5Screate_simple(1,_filespacesize,NULL)) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_FILESPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_filespace[_index]);
MESSAGE(MED_ERR_SIZE_MSG);
ISCRUTE_size(_filespacesize[0]);
goto ERROR;
}
_startfile[0] = _dim*_onedimallvaluesfileoffset+_start*nvaluesperentity;
if ( H5Sselect_hyperslab (_filespace[_index], H5S_SELECT_SET, _startfile, _stridefile,
&_count, _blocksize ) <0) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_FILESPACE,MED_ERR_ID_MSG);
ISCRUTE_int(_filespace[_index]);
goto ERROR;
}
/*File: Conditionally (_count) add a specific lastblock selection */
_startfile_lastblock[0] = _startfile[0]+_stridefile[0]*_count;
/* ISCRUTE(_startfile_lastblock[0]); */
if ( H5Sselect_hyperslab (_filespace[_index], H5S_SELECT_OR, _startfile_lastblock,_1 ,
_countfilelastblock, _filelastblocksize ) <0) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_FILESPACE,MED_ERR_ID_MSG);
ISCRUTE_int(_filespace[_index]);
goto ERROR;
}
/* ISCRUTE_int(_filespace[_index]); */
if (_index > MED_MAX_FILTER_SPACES) {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_PARAMETER,"");
ISCRUTE_int(_index);
ISCRUTE(nconstituentpervalue);
ISCRUTE_int(MED_MAX_FILTER_SPACES);
goto ERROR;
} else
++_index;
}
SAVEFILTER:
if ( _MEDsetFilter(_dimutil,_memspace, _filespace, nentity,
nvaluesperentity, nconstituentpervalue,
constituentselect, MED_NO_INTERLACE,
MED_NO_FILTER_SIZE,profilearraysize,
storagemode, profilename, filter ) <0) {
MED_ERR_(_ret,MED_ERR_INIT,MED_ERR_FILTER,"");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err _MEDselectAllEntitiesNoI(const med_idt fid,
const med_int nentity,
const med_int nvaluesperentity,
const med_int nconstituentpervalue,
const med_int constituentselect,
med_filter* const filter) {
med_idt _memspace[1]={0},_diskspace[1]={0};
med_size _memspacesize[1],_diskspacesize[1];
med_size _start_mem[1]={0};
med_err _ret=-1;
med_size _onedimallvaluesdiskoffset[1]={0};
med_size _profilearraysize[1]={0};
/*TODO : propager cette modif aux autres filtres*/
if ( ! nentity) {
_memspace[0] = H5Screate(H5S_NULL);
_diskspace[0] = H5Screate(H5S_NULL);
goto _CREATE_FILTER;
}
_onedimallvaluesdiskoffset[0] = nentity*nvaluesperentity;
_memspacesize[0] = _onedimallvaluesdiskoffset[0]*nconstituentpervalue;
_diskspacesize[0] = _memspacesize[0];
if ( (_memspace[0] = H5Screate_simple (1, _memspacesize, NULL)) <0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_MEMSPACE,MED_ERR_SIZE_MSG);
ISCRUTE_size(*_memspacesize);
ISCRUTE_int(_memspace[0]);
goto ERROR;
}
if ( constituentselect != MED_ALL_CONSTITUENT) {
_start_mem[0] = (constituentselect-1)*_onedimallvaluesdiskoffset[0];
_profilearraysize[0]=_onedimallvaluesdiskoffset[0];
} else {
_start_mem[0] = 0;
_profilearraysize[0]=_memspacesize[0];
};
if ( H5Sselect_hyperslab (_memspace[0], H5S_SELECT_SET, _start_mem, NULL,
_profilearraysize, NULL) <0 ) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_MEMSPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_memspace[0]);
goto ERROR;
}
/* ISCRUTE_int(_memspace[0]); */
if ( (_diskspace[0] = H5Scopy(_memspace[0])) < 0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DISKSPACE,MED_ERR_SIZE_MSG);
ISCRUTE_size(*_memspacesize);
ISCRUTE_id(_memspace[0]);
ISCRUTE_id(_diskspace[0]);
goto ERROR;
}
_CREATE_FILTER:
if ( _MEDsetFilter(1,_memspace, _diskspace, nentity,
nvaluesperentity, nconstituentpervalue,
constituentselect, MED_NO_INTERLACE,
MED_NO_FILTER_SIZE, MED_NO_PROFILE_SIZE,
MED_UNDEF_STMODE, MED_NO_PROFILE, filter ) <0) {
MED_ERR_(_ret,MED_ERR_INIT,MED_ERR_FILTER,"");
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}
med_err _MEDfilterEntityFullIGlobalCr(const med_idt fid,
const med_int nentity,
const med_int nvaluesperentity,
const med_int nconstituentpervalue,
const med_int constituentselect,
const med_storage_mode storagemode,
const char * const profilename,
const med_int filterarraysize,
const med_int* const filterarray,
med_filter* const filter) {
med_idt _memspace[1]={0},_diskspace[1]={0};
med_size _memspacesize[1]={0},_diskspacesize[1]={0};
med_int profilearraysize=0;
med_int _profilearraysize=0, *_profilearray=0, (*_profilearrayfunc)(const med_int * const,int)=0;
med_int _filterarraysize=0,(*_filterarrayfunc)(const med_int * const,int)=0;
med_size *_fltmem=NULL,*_pfldisk=NULL;
med_size _fltmemsize[1],_pfldisksize[1];
med_size _onedimallvaluesdiskoffset=0;
med_err _ret=-1;
int _i=0,_j=0,_index=0;
int _dim=0, _firstdim=0, _dimutil=0, _lastdim=0 ;
if ( constituentselect != MED_ALL_CONSTITUENT) {
_firstdim = constituentselect-1;
_lastdim = constituentselect;
_dimutil = 1;
} else {
_firstdim = 0;
_lastdim = nconstituentpervalue;
_dimutil = nconstituentpervalue;
}
/* Conditionne les traitements à l'existence d'un profil */
if ( strlen(profilename) ) {
profilearraysize = MEDprofileSizeByName(fid,profilename);
_profilearraysize = profilearraysize;
_profilearray = (med_int *) malloc (sizeof(med_int)*_profilearraysize);
if ( MEDprofileRd(fid,profilename, _profilearray) <0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_PROFILE,profilename);
goto ERROR;
}
_profilearrayfunc = _withprofilearray;
} else {
_profilearrayfunc = _identity;
_profilearraysize = nentity;
}
/* Conditionne les traitements à l'existence d'un filtre */
if ( (filterarraysize <= 0) ) {
_filterarrayfunc = _identity;
_filterarraysize = _profilearraysize;
} else {
_filterarrayfunc = _withfilterarray;
_filterarraysize = filterarraysize;
}
_fltmemsize[0] = _filterarraysize*nvaluesperentity*_dimutil;
_fltmem = (med_size *) malloc (sizeof(med_size)*_fltmemsize[0]);
_memspacesize[0] = nentity*nvaluesperentity*nconstituentpervalue;
if ( (_memspace[0] = H5Screate_simple (1,_memspacesize, NULL)) <0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_MEMSPACE,MED_ERR_SIZE_MSG);
ISCRUTE_size(*_memspacesize);
goto ERROR;
}
/*Dimensionement profil interne et diskspace */
_pfldisksize[0] = _fltmemsize[0];
_pfldisk = (med_size *) malloc (sizeof(med_size)*_pfldisksize[0]);
_onedimallvaluesdiskoffset = _profilearraysize*nvaluesperentity;
_diskspacesize[0] = _onedimallvaluesdiskoffset*nconstituentpervalue;
if ( (_diskspace[0] = H5Screate_simple (1,_diskspacesize, NULL)) <0) {
MED_ERR_(_ret,MED_ERR_CREATE,MED_ERR_DISKSPACE,MED_ERR_SIZE_MSG);
ISCRUTE_size(*_diskspacesize);
goto ERROR;
}
_index=0;
for (_dim=_firstdim; _dim < _lastdim; ++_dim) {
for (_i=0; _i < _filterarraysize; _i++) {
for (_j=0; _j < nvaluesperentity; _j++) {
/* ISCRUTE(_filterarrayfunc(_i));ISCRUTE(_profilearrayfunc(_filterarrayfunc(_i))); */
/* ISCRUTE(_profilearrayfunc(_filterarrayfunc(_i))*nvaluesperentity*nconstituentpervalue); */
_fltmem[_index] =
_profilearrayfunc(_profilearray,_filterarrayfunc(filterarray,_i))*nvaluesperentity*nconstituentpervalue
+ _j*nconstituentpervalue+_dim;
_pfldisk[_index] = _dim*_onedimallvaluesdiskoffset + _filterarrayfunc(filterarray,_i)*nvaluesperentity+_j;
#ifdef _DEBUG_
printf("FullGlb :_fltmem[%d]=%llu -- _pfldisk[%d]=%llu \n",_index,_fltmem[_index],_index,_pfldisk[_index]);
#endif
++_index;
}
}
}
if ( H5Sselect_elements(_memspace[0],H5S_SELECT_SET, _fltmemsize[0], HDF5_SELECT_BUG _fltmem ) <0) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_MEMSPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_memspace[0]);
goto ERROR;
}
/*Ce type de sélection n'est pas utilisable en parallélisme*/
if ( H5Sselect_elements(_diskspace[0] ,H5S_SELECT_SET,_pfldisksize[0], HDF5_SELECT_BUG _pfldisk ) <0) {
MED_ERR_(_ret,MED_ERR_SELECT,MED_ERR_DISKSPACE,MED_ERR_ID_MSG);
ISCRUTE_id(_diskspace[0]);
goto ERROR;
}
free(_fltmem); _fltmem=NULL;
free(_pfldisk); _pfldisk=NULL;
free(_profilearray); _profilearray=NULL;
if ( _MEDsetFilter(1,_memspace, _diskspace, nentity,
nvaluesperentity, nconstituentpervalue,
constituentselect, MED_FULL_INTERLACE,
filterarraysize,profilearraysize,
storagemode, profilename, filter ) <0) {
MED_ERR_(_ret,MED_ERR_INIT,MED_ERR_FILTER,"");
goto ERROR;
}
_ret = 0;
ERROR:
if (_fltmem) free(_fltmem);
if (_pfldisk) free(_pfldisk);
if (_profilearray) free(_profilearray);
return _ret;
}
med_err _MEDchecknSublinkFunc(med_idt id,const char *lname, const H5L_info_t *linfo, med_bool *data) {
med_err _ret=-1;
H5O_info_t oinfo;
H5G_info_t _group_info;
#ifdef _DEBUG_
SSCRUTE(lname);
#endif
if (!strcmp(lname,".")) return 0;
switch ( (*linfo).type ) {
case H5L_TYPE_SOFT:
oinfo.type=H5G_LINK;
break;
case H5L_TYPE_HARD:
if ( H5Oget_info_by_name( id, lname, &oinfo, H5P_DEFAULT ) <0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"H5Oget_info_by_name");
SSCRUTE(lname);
}
break;
case H5L_TYPE_EXTERNAL:
case H5L_TYPE_ERROR:
default:
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_HDFTYPE,lname);
ISCRUTE_int((*linfo).type);
goto ERROR;
break;
}
switch ( oinfo.type ) {
case H5G_GROUP:
if ( H5Gget_info_by_name(id, lname, &_group_info, H5P_DEFAULT ) < 0 ){
MED_ERR_(_ret,MED_ERR_ACCESS,MED_ERR_GROUP, MED_ERR_NAME_MSG );
SSCRUTE(lname);goto ERROR;
}
if ( _group_info.nlinks > 1 ) {
*data=MED_TRUE;
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GROUP,lname);
ISCRUTE_size(_group_info.nlinks);goto ERROR;
}
/* SSCRUTE(lname); */
/* ISCRUTE(*data); */
/* ISCRUTE(_group_info.nlinks); */
break;
case H5G_DATASET:
case H5G_LINK:
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_HDFTYPE,lname);
goto ERROR;
break;
case H5G_TYPE:
default:
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_HDFTYPE,lname);
goto ERROR;
}
_ret = 0;
ERROR:
return _ret;
}