void
_MEDmeshnEntity30(int dummy, ...)
{
med_access_mode _MED_ACCESS_MODE;
med_int _ret=-1,_err=-1;
med_idt _meshid=0, _datagroup=0,_datagroupf=0,_datagroup1=0;
med_idt _datagroup2=0,_datagroup3=0,_datagroup4=0,_dataset=0;
char _meshpath [MED_TAILLE_SUP_MAA+MED_NAME_SIZE+1]="";
char _datagroupname1 [2*MED_MAX_PARA+1] ="";
char _datagroupname2 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname3 [MED_TAILLE_NOM_ENTITE+1]="";
char _datagroupname4 [MAX(MED_TAILLE_VARATR,MED_TAILLE_COOTRF)]="";
char _datasetconame [3 + 1 + 3 + 1 ] ="";
char _profilename [MED_NAME_SIZE+1] ="";
char _geotypename [MED_TAILLE_NOM_ENTITE+1]="";
char _datasetname [MED_TAILLE_NOM_ENTITE+1]="";
med_sorting_type _sortingtype = 0;
med_int _intsortingtype = 0;
med_int _profilearraysize = 0;
med_int _changement=0, _changement_s=0, _transformation=0;
med_bool _changement_co = MED_FALSE;
med_size _n=0;
med_int _intn=0;
med_bool _isasupportmesh = MED_FALSE;
med_bool _isasoftlink = MED_FALSE;
med_bool _datasetexist = MED_FALSE;
med_int _ntmpmeddatatype = 1;
med_data_type _tmpmeddatatype[4] = {MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE,MED_UNDEF_DATATYPE};
med_grid_type _gridtype = MED_UNDEF_GRID_TYPE;
med_int _intgridtype = 0;
med_int _intmeshtype = 0;
med_int _meshdim = 0;
int _i = 0;
med_connectivity_mode _cmode ;
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , meshname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(const, med_data_type , , meddatatype );
MED_VARGS_DECL(const, med_connectivity_mode , , cmode );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, med_bool *, const , changement );
MED_VARGS_DECL(, med_bool *, const , transformation );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , meshname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(const, med_data_type , , meddatatype );
MED_VARGS_DEF(const, med_connectivity_mode , , cmode );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, med_bool *, const , changement );
MED_VARGS_DEF(, med_bool *, const , transformation );
MED_VARGS_DEF(, med_int * ,, fret );
_cmode = cmode;
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
if ( (_MED_ACCESS_MODE = _MEDmodeAcces(fid) ) == MED_ACC_UNDEF ) {
MED_ERR_(_ret,MED_ERR_UNRECOGNIZED,MED_ERR_ACCESSMODE,MED_ERR_FILE_MSG);
goto ERROR;
}
/*
* Ouverture du datagroup de niveau 1 <_meshpath>/<meshname>
*/
NOFINALBLANK(meshname,ERROR);
if ((_meshid=_MEDmeshDatagroupOpen(fid,meshname,_meshpath,&_isasupportmesh)) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(_meshpath); goto ERROR;
}
/* Lecture de la dimension du maillage */
if (_MEDattrEntierLire(_meshid,MED_NOM_DIM,&_meshdim) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_DIM);ISCRUTE(_meshdim);goto ERROR;
}
/* Lecture du type de maillage (attribut MED_NOM_TYP) */
if (_MEDattrEntierLire(_meshid,MED_NOM_TYP,&_intmeshtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_TYP);ISCRUTE(_intmeshtype);goto ERROR;
}
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
/* Lecture de l'attribut MED_NOM_GTY */
if (_MEDattrEntierLire(_meshid,MED_NOM_GTY,&_intgridtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_GTY);ISCRUTE(_intgridtype);goto ERROR;
}
_gridtype= (med_grid_type) _intgridtype;
}
/*
* Ouverture du datagroup de niveau 2 <numdt>.<numit>
*/
if ( _MEDattrEntierLire(_meshid,MED_NOM_SRT,&_intsortingtype) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);SSCRUTE(MED_NOM_SRT);ISCRUTE(_intsortingtype);goto ERROR;
}
_sortingtype = (med_sorting_type) (_intsortingtype);
_MEDgetComputationStepName(_sortingtype,numdt,numit,_datagroupname1);
if ( (_datagroup1 = _MEDdatagroupOuvrir(_meshid,_datagroupname1)) < 0 ) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATAGROUP,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);ISCRUTE_id(_datagroup1);goto ERROR;
}
/*
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup1,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname1);SSCRUTE(MED_NOM_CGT);goto ERROR;
}
*changement = (med_bool) _changement;
*transformation = MED_FALSE;
/*
* Gestion entitytype == MED_UNDEF_ENTITY_TYPE
*/
if ( entitytype == MED_UNDEF_ENTITY_TYPE ) {
_n=0; goto SORTIE;
}
/*
* Gestion entitytype == MED_ALL_ENTITY_TYPE
*/
if ( entitytype == MED_ALL_ENTITY_TYPE ) {
_err=_MEDnObjects(_datagroup1,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname1);
goto ERROR;
}
goto SORTIE;
}
/*
* Ouverture du datagroup de niveau 3 <entitytype>
*/
if (_MEDgetEntityTypeName(_datagroupname2,entitytype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_ENTITY,MED_ERR_VALUE_MSG);
ISCRUTE_int(entitytype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);goto ERROR;
}
if ((_datagroup2 = _MEDdatagroupOuvrir(_datagroup1,_datagroupname2)) < 0) {
*changement = (med_bool) MED_FALSE;
_n=0;_datagroup2=0;
goto SORTIE;
}
/* MAJ du changement pour le type d'entité <entitytype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
*/
if ( _MEDattrEntierLire(_datagroup2,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
/*
* Ouverture du datagroup de niveau 4 <geotype>
*/
/* Pas Utilisation pour MED_NODE */
if ( geotype == MED_GEO_ALL ) {
_err=_MEDnObjects(_datagroup2,".",&_n);
if ( _err == (MED_ERR_COUNT + MED_ERR_DATAGROUP) ) {
MED_ERR_(_ret,MED_ERR_COUNT,MED_ERR_DATAGROUP,_datagroupname2);
goto ERROR;
}
/*Par construction du modèle, le tableau de coordonnées preexiste aux autres */
if ( ( entitytype == MED_NODE ) && (_n > 0) ) _n=1;
goto SORTIE;
}
if ( entitytype != MED_NODE ) {
/* Lecture du nom de type géométrique */
/*TODO : Remplacer les deux appels suivants par un seul gérant les geotype dynamiques et statiques*/
if ( entitytype == MED_STRUCT_ELEMENT ) {
if ( MEDstructElementName(fid, geotype,_datagroupname3) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDstructElementName");
ISCRUTE_int(geotype);goto ERROR;
}
} else
if ( _MEDgetInternalGeometryTypeName(_datagroupname3,geotype) < 0) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_GEOMETRIC,MED_ERR_VALUE_MSG);
ISCRUTE_int(geotype);SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);goto ERROR;
}
if ((_datagroup3 = _MEDdatagroupOuvrir(_datagroup2,_datagroupname3)) < 0) {
_n=0;
*changement = MED_FALSE;
goto SORTIE;
}
}
if (_datagroup3) _datagroup=_datagroup3; else _datagroup=_datagroup2;
/* MAJ du changement pour le type géométrique d'entité <geotype>
* ( annulant eventuellement le changement global précédent concernant tous les types d'entités)
* Attribut CGT (un changement a eu lieu depuis l'étape de calcul précédente)
* Prend en charge le cas d'un dataset vide écrit pour un typegeo donné (CHGT==1)
*/
if (_datagroup3) {
if ( _MEDattrEntierLire(_datagroup3,MED_NOM_CGT,&_changement) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
*changement = (med_bool) _changement;
}
/*
* Lecture du flag de modification sur autre chose que MED_CONNECTIVITY,MED_COORDINATE,MED_COORDINATE_AXIS<i>
*
*/
if ( _MEDattrEntierLire(_datagroup,MED_NOM_CGS,&_changement_s) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGS);goto ERROR;
}
/* 1) Lorsque l'utilisateur interroge un <meddatatype> qui est relatif a des coordonnées (famille,....) il faut mettre
* le flag chgt à jour par rapport à des modifications potentiellement effectuées sur ces coordonnées
* <=>
* Si on interroge autre chose que MED_CONNECTIVITY,MED_COORDINATE
* et qu'un changement est présent sur MED_CONNECTIVITY,MED_COORDINATE
* le flag chgt doit être positionné à vrai
* Une demande entitype==MED_NODE && (meddatatype == MED_COORDINATE_AXIS1)||(meddatatype == MED_COORDINATE_AXIS2)
* ||(meddatatype === MED_COORDINATE_AXIS3) est assimilée à une demande concernant des coordonnées
* <=>
* Y-a-t'il une modification des datasets COO(si NOE)| NOD|DES(si !NOE)
*/
/* 2)
* Positionne un mode de connectivité _cmode si le meddatatype demandé
* est autre chose que des coordonnées ou des connectivités et que le cmode n'a pas été
* spécifié par l'utilisateur.
* Cette Information est necessaire pour construire le nom du dataset.
*/
if ( (meddatatype != MED_CONNECTIVITY) && ( meddatatype != MED_COORDINATE )
&& (meddatatype != MED_COORDINATE_AXIS1)
&& (meddatatype != MED_COORDINATE_AXIS2)
&& (meddatatype != MED_COORDINATE_AXIS3)
&& (meddatatype != MED_INDEX_FACE)
&& (meddatatype != MED_INDEX_NODE)) {
if (entitytype == MED_NODE) {
if ( ( (med_mesh_type) _intmeshtype ) != MED_UNSTRUCTURED_MESH ) {
if ( (_gridtype == MED_CARTESIAN_GRID) ||
(_gridtype == MED_CURVILINEAR_GRID) ) {
_ntmpmeddatatype=_meshdim;
_tmpmeddatatype[0] = MED_COORDINATE_AXIS1;
_tmpmeddatatype[1] = MED_COORDINATE_AXIS2;
_tmpmeddatatype[2] = MED_COORDINATE_AXIS3;
} else if (_gridtype == MED_CURVILINEAR_GRID ) {
/*Les grilles curvilinéaires utilisent MED_COORDINATE_AXISx pour stocker la structure et le tableau MED_COORDINATE pour stocker les coordonnées des noeuds */
++_ntmpmeddatatype;
_tmpmeddatatype[3] = MED_COORDINATE;
} else {
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_GRIDTYPE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE_int(_gridtype);goto ERROR;
}
} else
_tmpmeddatatype[0] = MED_COORDINATE;
} else {
switch (geotype) {
case MED_POLYHEDRON:
_ntmpmeddatatype=3;
_tmpmeddatatype[2] = MED_CONNECTIVITY;
_tmpmeddatatype[1] = MED_INDEX_FACE;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
case MED_POLYGON:
_ntmpmeddatatype=2;
_tmpmeddatatype[1] = MED_CONNECTIVITY;
_tmpmeddatatype[0] = MED_INDEX_NODE;
break;
default:
if ( ( (med_mesh_type) _intmeshtype ) == MED_STRUCTURED_MESH ) {
_ntmpmeddatatype=0;
break;
}
_tmpmeddatatype[0] = MED_CONNECTIVITY;
if ( cmode == MED_NO_CMODE ) {
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_NODAL,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
if ( _datasetexist ) _cmode= MED_NODAL;
else
if ( _MEDdatasetExistByMedtype(_datagroup,MED_CONNECTIVITY,MED_DESCENDING,
&_datasetexist, &_isasoftlink) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDdatasetExistByMedtype");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
} else
_cmode = MED_DESCENDING;
}
}
}
*changement = MED_FALSE;
for (_i=0; _i < _ntmpmeddatatype ;++_i) {
if ( _MEDgetDatasetChgt( _datagroup, _tmpmeddatatype[_i], _cmode,
&_isasoftlink, &_changement_co ) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"getDatasetChgt");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
*changement |= _changement_co;
}
}
/*
* Niveau de datagroup 5 supplémentaire pour les éléments de structure ou les transformations.
*/
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) ) {
if (meddatatype == MED_VARIABLE_ATTRIBUTE)
strcpy(_datagroupname4,MED_VARATR_NOM);
else
strcpy(_datagroupname4,MED_COOTRF_NOM);
if ((_datagroup4 = _MEDdatagroupOuvrir(_datagroup,_datagroupname4)) < 0) {
_n=0;
goto SORTIE;
}
}
if ( (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF ) )
_datagroupf=_datagroup4;
else
_datagroupf=_datagroup;
/*
* Construction du nom du dataset à lire
*/
if ( _MEDgetDatasetName(_datasetname,meddatatype,cmode) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDgetDatasetName");
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);goto ERROR;
}
/*
* MAJ du champ transformation pour le (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if (_datagroup4) {
if ( _MEDattrEntierLire(_datagroup4,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
if ( (_dataset = _MEDdatasetOuvrir(_datagroupf,_datasetname)) < 0) {
_n=0;_dataset=0;*transformation = (med_bool) MED_FALSE;
/* if ( (numdt != MED_NO_DT) || (numit != MED_NO_IT) ) { */
/* MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_DATASET,_datasetname); */
/* SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt); */
/* SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4); */
/* ISCRUTE_size(_n); */
/* goto ERROR; */
/* } */
goto SORTIE;
}
if (!_datagroup4) {
/*
* Lire l'attribut CGT pour savoir si le dataset a changé
* n'a pas de sens si le dataset est en fait un lien vers le dataset précedent.
* En testant si le dataset est un lien on détermine si un changement a eu lieu
* depuis la séquence de calcul précédente.
* Ce traitement ne doit pas être effectué pour le pas de temps initial et pour
* (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
if ( _MEDisasoftlink(_datagroupf, _datasetname,MED_TRUE, &_isasoftlink ) < 0) {
MED_ERR_(_ret,MED_ERR_OPEN,MED_ERR_LINK,_datasetname);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
ISCRUTE_size(_n);goto ERROR;
}
if (_isasoftlink)
_transformation = MED_FALSE;
else {
if ( _MEDattrEntierLire(_dataset,MED_NOM_CGT,&_transformation) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3);SSCRUTE(MED_NOM_CGT);
goto ERROR;
}
}
}
*transformation = (med_bool) _transformation;
if ( ( meddatatype == MED_CONNECTIVITY) && ( meddatatype == MED_COORDINATE ) ) {
*transformation &= (med_bool) !_changement_s;
}
/*
* Attribut PFL (nombre de noeuds ou d'elements)
* la lecture est faite sur le datagroup _datagroup et non sur _datagroupf
* pour (meddatatype==MED_VARIABLE_ATTRIBUTE) || (meddatatype==MED_COORDINATE_TRSF)
*/
_profilearraysize = 0;
profilename[0]='\0';
if ( _MEDattrStringLire(_datagroup,MED_NOM_PFL,MED_NAME_SIZE,_profilename) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_datagroupname3); SSCRUTE(MED_NOM_PFL);SSCRUTE(_profilename);goto ERROR;
}
if ( strcmp(_profilename,MED_NO_PROFILE_INTERNAL) ) {
strncpy(profilename,_profilename,MED_NAME_SIZE+1);
profilename[MED_NAME_SIZE]='\0';
if ( ( _profilearraysize = MEDprofileSizeByName( fid,_profilename) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);SSCRUTE(_datagroupname2);
SSCRUTE(_profilename);SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
*profilesize=(med_int) _profilearraysize;
/*
* Attribut NBR (nombre d'entité)
*/
if ( _MEDattrEntierLire(_dataset,MED_NOM_NBR,&_intn) < 0) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE,MED_ERR_MESH_MSG);
SSCRUTE(meshname);ISCRUTE(numit);ISCRUTE(numdt);
SSCRUTE(_datagroupname2);SSCRUTE(_datagroupname3);SSCRUTE(_datagroupname4);
SSCRUTE(_datasetname);SSCRUTE(MED_NOM_NBR);ISCRUTE_size(_n);goto ERROR;
}
_n = _intn;
if (_profilearraysize)
switch(storagemode) {
case MED_GLOBAL_PFLMODE :
break;
case MED_COMPACT_PFLMODE :
if ( meddatatype!=MED_COORDINATE_TRSF )
_n=_profilearraysize;
break;
default :
MED_ERR_(_ret,MED_ERR_RANGE,MED_ERR_STORAGEMODE,MED_ERR_VALUE_MSG);
ISCRUTE_int(storagemode);goto ERROR;
break;
}
SORTIE:
_ret = _n;
ERROR:
if (_dataset>0) if (_MEDdatasetFermer(_dataset) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATASET,MED_NOM_COO);
ISCRUTE_id(_dataset);
}
if (_datagroup4>0) if (_MEDdatagroupFermer(_datagroup4) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname4);
ISCRUTE_id(_datagroup4);
}
if (_datagroup3>0) if (_MEDdatagroupFermer(_datagroup3) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname3);
ISCRUTE_id(_datagroup3);
}
if (_datagroup2>0) if (_MEDdatagroupFermer(_datagroup2) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname2);
ISCRUTE_id(_datagroup2);
}
if (_datagroup1>0) if (_MEDdatagroupFermer(_datagroup1) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_datagroupname1);
ISCRUTE_id(_datagroup1);
}
if (_meshid>0) if (_MEDdatagroupFermer(_meshid) < 0) {
MED_ERR_(_ret,MED_ERR_CLOSE,MED_ERR_DATAGROUP,_meshpath);
ISCRUTE_id(_meshid);
}
/* _MEDobjetsOuverts(fid); */
*fret = _ret;
va_end(params);
return;
}
void
_MEDfieldnValue236(int dummy, ...)
{
med_int _ret =-1;
med_int _nprofile = 0;
med_int _n = 0;
med_int _profilearraysize = 0,_nvaluesperentity=0;
med_int _nintegrationpoint= 0;
med_bool _anyprofile = MED_FALSE;
med_geometrie_element _locgeotype = 0;
med_int _intlocgeotype = 0;
med_int _nvaluesperentityfromloc=0;
int _dummy =0;
char _localizationname [MED_TAILLE_NOM+1] = "";
char _tmpprofilename [MED_NAME_SIZE+1] = "", *_profilename=0;
char _path [MED_LOCALIZATION_GRP_SIZE+MED_TAILLE_NOM+1]= MED_LOCALIZATION_GRP;
char _geotype [MED_TAILLE_NOM_ENTITE+1] = "";
MED_VARGS_DECL(const, med_idt , , fid );
MED_VARGS_DECL(const, char * , const , fieldname );
MED_VARGS_DECL(const, med_int , , numdt );
MED_VARGS_DECL(const, med_int , , numit );
MED_VARGS_DECL(const, med_entity_type , , entitytype );
MED_VARGS_DECL(const, med_geometry_type , , geotype );
MED_VARGS_DECL(, char *, const , profilename );
MED_VARGS_DECL(const, int , , profileit );
MED_VARGS_DECL(const, med_storage_mode , , storagemode );
MED_VARGS_DECL(, med_int *, const , profilesize );
MED_VARGS_DECL(, char *, const , localizationname );
MED_VARGS_DECL(, med_int *, const , nintegrationpoint );
MED_VARGS_DECL(, med_int * ,, fret );
va_list params;
va_start(params,dummy);
MED_VARGS_DEF(const, med_idt , , fid );
MED_VARGS_DEF(const, char * , const , fieldname );
MED_VARGS_DEF(const, med_int , , numdt );
MED_VARGS_DEF(const, med_int , , numit );
MED_VARGS_DEF(const, med_entity_type , , entitytype );
MED_VARGS_DEF(const, med_geometry_type , , geotype );
MED_VARGS_DEF(, char *, const , profilename );
MED_VARGS_DEF(const, int , , profileit );
MED_VARGS_DEF(const, med_storage_mode , , storagemode );
MED_VARGS_DEF(, med_int *, const , profilesize );
MED_VARGS_DEF(, char *, const , localizationname );
MED_VARGS_DEF(, med_int *, const , nintegrationpoint );
MED_VARGS_DEF(, med_int * ,, fret );
/*
* On inhibe le gestionnaire d'erreur HDF 5
*/
_MEDmodeErreurVerrouiller();
NOFINALBLANK(fieldname,ERROR);
if ( (profileit != 1) &&
(profileit != -1)) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_PARAMETER,MED_ERR_VALUE_MSG);
ISCRUTE_int(profileit);goto ERROR;
}
/*
* Cette appel effectue l'appel à _MEDfieldComputingStepCheck236
*/
_MEDfieldnProfile236(_dummy,fid,fieldname,numdt,numit,entitytype,geotype,
&_tmpprofilename,&_localizationname,&_nprofile );
if ( _nprofile < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"_MEDfieldnProfile236");
goto ERROR;
}
/* REM: MEDnVal prend en compte le nombre de points de Gauss, ce qui n'est pas le cas
de MEDfieldnValue */
if ( (_n = MEDnVal(fid, (char *) fieldname,entitytype,geotype,
numdt,numit,MED_NOREF,(med_mode_profil) storagemode) ) < 0 ) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,"MEDnVal");
goto ERROR;
}
/*
* Lecture de la taille du profil (eventuellement MED_ALLENTITIES_PROFILE)
*/
/* REM: (profileit < 0 ) signifie que l'on nous a fourni <profilename> */
if ( profileit < 0 ) {
if ( !strlen(profilename)) {
_profilename = MED_NOPFL;
} else {
if ( strcmp(_tmpprofilename,profilename) ) {
MED_ERR_(_ret,MED_ERR_INVALID,MED_ERR_PARAMETER,profilename);
SSCRUTE(_tmpprofilename); goto ERROR;
}
_profilename=profilename;
_anyprofile=MED_TRUE;
}
} else {
strncpy(profilename,_tmpprofilename,MED_TAILLE_NOM+1);
profilename[MED_TAILLE_NOM]='\0';
_profilename=profilename;
if ( strlen(profilename)) _anyprofile=MED_TRUE;
}
if ( _anyprofile ) {
if ( (_profilearraysize=MEDprofileSizeByName(fid, _profilename)) < 0) {
MED_ERR_(_ret,MED_ERR_CALL,MED_ERR_API,MED_ERR_FIELD_MSG);
SSCRUTE(fieldname); SSCRUTE(_profilename);
SSCRUTE("MEDprofileSizeByName");goto ERROR;
}
}
/*
* Lecture du nombre de points d'intégration.
*/
strncpy(localizationname,_localizationname,MED_TAILLE_NOM+1);
localizationname[MED_TAILLE_NOM]='\0';
/* Vérification de la cohérence du nombre de valeurs pas entité */
if (entitytype == MED_NODE_ELEMENT ) {
if ( strlen( _localizationname) ) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_PARAMETER,_localizationname);
SSCRUTE(MED_NO_LOCALIZATION);ISCRUTE_int(entitytype);goto ERROR;
}
_nvaluesperentityfromloc = geotype % 100;
} else if (! strcmp(_localizationname,MED_GAUSS_ELNO)) {
/* Les points de Gauss sont d"finis sur les noeuds de l'element (mot cle) */
/* le nombre de points de Gauss est egal au nombre de noeuds de l'element */
_nvaluesperentityfromloc = geotype % 100;
} else if ( strlen(_localizationname) ) {
strcat(_path,_localizationname);
if ( _MEDattributeNumRdByName(fid, _path, MED_NOM_NBR,MED_INTERNAL_INT,(unsigned char *) &_nvaluesperentityfromloc) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(MED_NOM_NBR);SSCRUTE(_path); ISCRUTE(_nvaluesperentityfromloc);goto ERROR;
}
if ( _MEDattributeNumRdByName(fid, _path, MED_NOM_GEO, MED_INTERNAL_INT,(unsigned char *) &_intlocgeotype) < 0 ) {
MED_ERR_(_ret,MED_ERR_READ,MED_ERR_ATTRIBUTE, MED_ERR_NAME_MSG );
SSCRUTE(MED_NOM_GEO);SSCRUTE(_path); ISCRUTE(_intlocgeotype);goto ERROR;
}
_locgeotype = (med_geometry_type) _intlocgeotype;
if ( _locgeotype != geotype ) {
MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG);
SSCRUTE(_localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE_int(_locgeotype);ISCRUTE_int(geotype);
goto ERROR;
}
} else {
_nvaluesperentityfromloc = 1;
}
/* Pour effectuer la vérification suivante (incohérence dans le fichier suite à une
maj de la localisation ou du champ sans prise en compte d'un nombre de points d'intégration différent),
il faudrait lire l'attribut MED_NOM_NGA sur le maillage par défaut du champ*/
/* Pour celà il faut soit developper une nouvelle routine soit utiliser MEDpasdetempsInfo mais qui
est itérative*/
/* if ( _nvaluesperentityfromloc != _nvaluesperentity ) { */
/* MED_ERR_(_ret,MED_ERR_NOTEQUAL,MED_ERR_ATTRIBUTE,MED_ERR_LOCALIZATION_MSG); */
/* SSCRUTE(_localizationname);SSCRUTE(MED_NOM_GEO);ISCRUTE(_nvaluesperentityfromloc); */
/* ISCRUTE(_nvaluesperentity);goto ERROR; */
/* } */
*nintegrationpoint = _nvaluesperentityfromloc;
_n/=_nvaluesperentityfromloc;
/*Rectification de la valeur 2.3.6 qui prend en compte le nombre de points d'intégration*/
if (_anyprofile)
*profilesize=_profilearraysize;
else
*profilesize=_n;
_ret = _n;
ERROR:
va_end(params);
*fret = _ret;
return;
}
med_err _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 getFieldsOn(med_idt fid, char * nomcha, med_field_type typcha, med_int ncomp,
med_entity_type entite, med_switch_mode stockage, med_int ncstp) {
int j,k,l,m,n,nb_geo=0;
med_int nbpdtnor=0,pflsize,*pflval,ngauss=0,ngroup,*vale=NULL,nval;
med_int numdt=0,numo=0,_nprofile;
med_float *valr=NULL,dt=0.0;
med_err ret=0;
char pflname [MED_NAME_SIZE+1]="";
char locname [MED_NAME_SIZE+1]="";
char * lien = NULL;
char dt_unit [MED_SNAME_SIZE+1]="unknown";
med_geometry_type * type_geo;
const char * const * AFF;
const char * const * AFF_ENT=MED_GET_ENTITY_TYPENAME+1;
switch (entite) {
case MED_NODE :
type_geo = MED_GET_NODE_GEOMETRY_TYPE;
nb_geo = MED_N_NODE_FIXED_GEO;
AFF = MED_GET_NODE_GEOMETRY_TYPENAME;
break;
case MED_CELL :
case MED_NODE_ELEMENT :
type_geo = MED_GET_CELL_GEOMETRY_TYPE;
nb_geo = MED_N_CELL_FIXED_GEO;
AFF = MED_GET_CELL_GEOMETRY_TYPENAME;
break;
case MED_DESCENDING_FACE :
type_geo = MED_GET_FACE_GEOMETRY_TYPE;
nb_geo = MED_N_FACE_FIXED_GEO;
AFF = MED_GET_FACE_GEOMETRY_TYPENAME;
break;
case MED_DESCENDING_EDGE :
type_geo = MED_GET_EDGE_GEOMETRY_TYPE;
nb_geo = MED_N_EDGE_FIXED_GEO;
AFF = MED_GET_EDGE_GEOMETRY_TYPENAME;
break;
}
for (k=1;k<=nb_geo;k++) {
/* Combien de (PDT,NOR) a lire */
nbpdtnor = ncstp;
if (nbpdtnor < 1 ) continue;
for (j=0;j<nbpdtnor;j++) {
if ( MEDfieldComputingStepInfo(fid,nomcha,j+1, &numdt, &numo, &dt ) <0) {
MESSAGE("Erreur a la demande d'information sur (pdt,nor) : ");
ISCRUTE(numdt); ISCRUTE(numo);
ret = -1; continue;
}
if ( (_nprofile = MEDfieldnProfile(fid,nomcha,numdt,numo,entite,type_geo[k],
pflname,locname ) ) < 0 ) {
MESSAGE("Erreur a la demande du nombre de profils referencés par le champ : ");
SSCRUTE(nomcha);
ISCRUTE(numdt); ISCRUTE(numo);
ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
SSCRUTE(AFF_ENT[(int)entite]);SSCRUTE(AFF[k]);
ret = -1; continue;
};
for (l=0;l<_nprofile;l++) {
if ( (nval = MEDfieldnValueWithProfile(fid, nomcha, numdt, numo, entite, type_geo[k],
l+1, USER_MODE, pflname,&pflsize,
locname, &ngauss) ) < 0 ) {
MESSAGE("Erreur a la lecture du nombre de valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE(numdt);ISCRUTE(numo);
ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
ISCRUTE_int(USER_MODE);
ret = -1; continue;
};
printf("\n +Pas de Temps n."IFORMAT" (%f) [%s], n. d'ordre "IFORMAT", avec "IFORMAT" valeur(s) par entité.\n",numdt,dt,dt_unit,numo,ngauss);
printf("\t- Il y a "IFORMAT" entités qui portent des valeurs en mode %i. Chaque entite %s\
de type geometrique %s associes au profile |%s| a "IFORMAT" valeurs associées \n",
nval,USER_MODE,AFF_ENT[(int)entite],AFF[k],pflname,ngauss);
/*Lecture des valeurs du champ */
if (typcha == MED_FLOAT64) {
valr = (med_float*) calloc(ncomp*nval*ngauss,sizeof(med_float));
EXIT_IF(valr == NULL,NULL,NULL);
if (MEDfieldValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],
USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
(unsigned char*) valr) < 0 ) {
MESSAGE("Erreur a la lecture des valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
ISCRUTE(numdt);ISCRUTE(numo);
ret = -1;
}
} else {
vale = (med_int*) calloc(ncomp*nval*ngauss,sizeof(med_int));
EXIT_IF(vale == NULL,NULL,NULL);
if (MEDfieldValueWithProfileRd(fid, nomcha, numdt,numo, entite,type_geo[k],
USER_MODE, pflname, stockage,MED_ALL_CONSTITUENT,
(unsigned char*) vale) < 0 ) {
MESSAGE("Erreur a la lecture des valeurs du champ : ");
SSCRUTE(nomcha);ISCRUTE_int(entite);ISCRUTE_int(type_geo[k]);
ISCRUTE(numdt);ISCRUTE(numo);
ret = -1;
};
}
if ( strlen(locname) )
printf("\t- Modèle de localisation des points de Gauss de nom |%s|\n",locname);
if (entite == MED_NODE_ELEMENT)
ngroup = (type_geo[k] % 100);
else
ngroup = ngauss;
switch (stockage) {
case MED_FULL_INTERLACE :
printf("\t- Valeurs :\n\t");
for (m=0;m<(nval*ngauss)/ngroup;m++) {
printf("|");
for (n=0;n<ngroup*ncomp;n++)
if (typcha == MED_FLOAT64)
printf(" %f ",*(valr+(m*ngroup*ncomp)+n));
else
printf(" "IFORMAT" ",*(vale+(m*ngroup*ncomp)+n));
}
break;
/*Affichage en fonction du profil à traiter*/
case MED_NO_INTERLACE :
printf("\t- Valeurs :\n\t");
for (m=0;m<ncomp;m++) {
printf("|");
for (n=0;n<(nval*ngauss);n++)
if (typcha == MED_FLOAT64)
printf(" %f ",*(valr+(m*nval)+n));
else
printf(" "IFORMAT" ",*(vale+(m*nval)+n));
}
break;
}
printf("|\n");
if (typcha == MED_FLOAT64) {
if ( valr ) {free(valr);valr = NULL;}}
else
if (vale) { free(vale);vale = NULL; }
/*Lecture du profil associe */
if (strcmp(pflname,MED_NO_PROFILE) == 0 )
printf("\t- Profil : MED_NO_PROFILE\n");
else {
if ( (pflsize = MEDprofileSizeByName(fid,pflname)) <0 ) {
MESSAGE("Erreur a la lecture du nombre de valeurs du profil : ");
SSCRUTE(pflname);
ret = -1; continue;
}
printf("\t- Profil : |%s| de taille "IFORMAT"\n",pflname,pflsize);
pflval = (med_int*) malloc(sizeof(med_int)*pflsize);
EXIT_IF(pflval == NULL,NULL,NULL);
if ( MEDprofileRd(fid,pflname,pflval) <0) {
MESSAGE("Erreur a la lecture des valeurs du profil : ");
SSCRUTE(pflname);
ret = -1;
}
printf("\t");
for (m=0;m<pflsize;m++) printf(" "IFORMAT" ",*(pflval+m));
printf("\n");
free(pflval);
}
}
}
} /* fin for sur les mailles*/
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;
}
