Back to index

salome-med  6.5.0
Typedefs | Enumerations | Functions
med_2_1 Namespace Reference

Typedefs

typedef hsize_t med_size
typedef hssize_t med_ssize
typedef hid_t med_idt
typedef herr_t med_err
typedef double med_float
typedef int med_int

Enumerations

enum  med_grid_type { MED_CARTESIAN, MED_POLAR, MED_BODY_FITTED }
enum  med_grid {
  MED_GRID_D1 = 0, MED_GRID_D2 = 1, MED_GRID_D3 = 2, MED_GRID_NOEUD = 3,
  MED_FAM_NOEUD = 4, MED_FAM_ARETE = 5, MED_FAM_FACE = 6, MED_FAM_MAILLE = 7
}
enum  med_mode_switch { MED_FULL_INTERLACE, MED_NO_INTERLACE }
enum  med_mode_profil { MED_GLOBALE, MED_COMPACT }
enum  med_mode_acces { MED_LECT, MED_ECRI, MED_REMP }
enum  med_entite_maillage { MED_MAILLE, MED_FACE, MED_ARETE, MED_NOEUD }
enum  med_table {
  MED_COOR, MED_CONN, MED_NOM, MED_NUM,
  MED_FAM
}
enum  med_type_champ { MED_REEL64 = 6, MED_INT32 = 24, MED_INT64 = 26, MED_INT }
enum  med_geometrie_element {
  MED_POINT1 = 1, MED_SEG2 = 102, MED_SEG3 = 103, MED_TRIA3 = 203,
  MED_QUAD4 = 204, MED_TRIA6 = 206, MED_QUAD8 = 208, MED_TETRA4 = 304,
  MED_PYRA5 = 305, MED_PENTA6 = 306, MED_HEXA8 = 308, MED_TETRA10 = 310,
  MED_PYRA13 = 313, MED_PENTA15 = 315, MED_HEXA20 = 320
}
enum  med_connectivite { MED_NOD, MED_DESC }
enum  med_repere { MED_CART, MED_CYL, MED_SPHER }
enum  med_booleen { MED_FAUX, MED_VRAI }
enum  med_dim_famille { MED_GROUPE, MED_ATTR, MED_FAMILLE }
enum  med_dim_champ { MED_COMP, MED_DTYPE }
enum  med_fich_info { MED_HDF_VERSION, MED_VERSION, MED_FICH_DES }

Functions

char * _MED1cstring (char *chaine, int longueur_reelle, int longueur_fixee)
char * _MED2cstring (char *chaine, int longueur)
med_idt _MEDfichierCreer (char *nom)
med_idt _MEDfichierOuvrir (char *nom, med_mode_acces mode)
med_err _MEDfichierFermer (med_idt fid)
med_idt _MEDdatagroupCreer (med_idt pid, char *nom)
med_idt _MEDdatagroupOuvrir (med_idt pid, char *nom)
med_err _MEDdatagroupFermer (med_idt id)
med_idt _MEDdatasetOuvrir (med_idt pid, char *nom)
med_err _MEDdatasetFermer (med_idt id)
med_err _MEDdatasetNumEcrire (med_idt pere, char *nom, med_type_champ type, med_mode_switch interlace, med_size nbdim, med_size fixdim, med_size psize, med_ssize *profil, med_int ngauss, med_size *size, unsigned char *val, med_mode_acces mode)
med_err _MEDdatasetNumLire (med_idt pere, char *nom, med_type_champ type, med_mode_switch interlace, med_size nbdim, med_size fixdim, med_size psize, med_ssize *pfltab, med_int ngauss, unsigned char *val)
med_err _MEDdatasetStringEcrire (med_idt pere, char *nom, med_size *dimd, char *val, med_mode_acces mode)
med_err _MEDdatasetStringLire (med_idt pere, char *nom, char *val)
med_idt _MEDattrOuvrir (med_idt pid, char *nom)
med_err _MEDattrFermer (med_idt id)
med_err _MEDattrNumEcrire (med_idt pere, med_type_champ type, char *nom, unsigned char *val, med_mode_acces mode)
med_err _MEDattrNumLire (med_idt pere, med_type_champ type, char *nom, unsigned char *val)
med_err _MEDattrStringEcrire (med_idt pere, char *nom, int longueur, char *val, med_mode_acces mode)
med_err _MEDattrStringLire (med_idt pere, char *nom, int longueur, char *val)
med_err _MEDindiceInfo (med_idt id, const char *nom, void *donnees)
med_err _MEDindiceNum (med_idt id, const char *nom, void *donnees)
med_err _MEDobjetIdentifier (med_idt fid, char *chemin, int indice, void *nom)
med_err _MEDnObjets (med_idt fid, char *chemin, int *n)
void _MEDmodeErreurVerrouiller ()
med_err _MEDcstringFree (char *chaine)
med_err _MEDfstring (char *chaine, med_int longueur_fixee)
med_err _MEDnomEntite (char *nom_ent, med_entite_maillage type_ent)
med_err _MEDnomGeometrie (char *nom_geo, med_geometrie_element type_geo)
med_err _MEDparametresGeometrie (med_entite_maillage type_ent, med_geometrie_element type_geo, int *dim, int *nnoe, int *ndes)
med_err _MEDnomDataset (char *nom_dataset, med_table quoi, med_connectivite type_conn)
med_err _MEDGeometrieElement (med_geometrie_element typ_geo[], med_entite_maillage typ_ent)
MEDWRAPPER_V2_1_CORE_EXPORT med_idt MEDouvrir (char *nom, med_mode_acces mode_acces)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfermer (med_idt fid)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDlFichDes (med_idt fid)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfichEntete (med_idt fid, med_fich_info quoi, char str[])
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfichDesEcr (med_idt fid, char *des, med_mode_acces mode)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDunvCr (med_idt fid, char *maa)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDunvLire (med_idt fid, char *maa, char *nomu)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDformatConforme (const char *nomfich)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDversionConforme (const char *nom)
MEDWRAPPER_V2_1_CORE_EXPORT void MEDversionDonner (med_int *majeur, med_int *mineur, med_int *release)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDversionLire (med_idt fid, med_int *majeur, med_int *mineur, med_int *release)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDmaaCr (med_idt fid, char *maillage, med_int dim)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDdimLire (med_idt fid, char *maillage)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDmaaInfo (med_idt fid, int indice, char *maillage, med_int *dim)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnMaa (med_idt fid)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnbnosoEcr (med_idt fid, char *nom_maillage, med_int n)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnbnosoLire (med_idt fid, char *nom_maillage)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnbnoisEcr (med_idt fid, char *nom_maillage, med_int n)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnbnoisLire (med_idt fid, char *nom_maillage)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnbnomaEcr (med_idt fid, char *nom_maillage, med_int n)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnbnomaLire (med_idt fid, char *nom_maillage)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDconnEcr (med_idt fid, char *maa, med_int mdim, med_int *connectivite, med_mode_switch mode_switch, med_int nbre, med_mode_acces mode, med_entite_maillage type_ent, med_geometrie_element type_geo, med_connectivite type_conn)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDconnLire (med_idt fid, char *maa, med_int mdim, med_int *connectivite, med_mode_switch mode_switch, med_int *pfltab, med_size psize, med_entite_maillage type_ent, med_geometrie_element type_geo, med_connectivite type_conn)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnomEcr (med_idt fid, char *maa, char *nom, med_int n, med_mode_acces mode, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnomLire (med_idt fid, char *maa, char *nom, med_int n, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnumLire (med_idt fid, char *maa, med_int *num, med_int n, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnumEcr (med_idt fid, char *maa, med_int *num, med_int n, med_mode_acces mode, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDcoordEcr (med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo, med_int n, med_mode_acces mode, med_repere type_rep, char *nom, char *unit)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDcoordLire (med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo, med_int numco, med_int *pfltab, med_size psize, med_repere *type_rep, char *nom, char *unit)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnEntMaa (med_idt fid, char *maa, med_table quoi, med_entite_maillage type_ent, med_geometrie_element type_geo, med_connectivite type_conn)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDchampCr (med_idt fid, char *champ, med_type_champ type, char *comp, char *unit, med_int ncomp)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDchampEcr (med_idt fid, char *maa, char *cha, unsigned char *val, med_mode_switch interlace, med_int nbelem, med_int ngauss, med_int numco, char *profil, med_mode_acces mode, med_entite_maillage type_ent, med_geometrie_element type_geo, med_int numdt, char *dt_unit, med_float dt, med_int numo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDchampLire (med_idt fid, char *maa, char *cha, unsigned char *val, med_mode_switch interlace, med_int numco, char *profil, med_entite_maillage type_ent, med_geometrie_element type_geo, med_int numdt, med_int numo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDchampInfo (med_idt fid, int indice, char *champ, med_type_champ *type, char *comp, char *unit, med_int ncomp)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnChamp (med_idt fid, int indice)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnVal (med_idt fid, char *champ, med_entite_maillage typ_ent, med_geometrie_element typ_geo, med_int numdt, med_int numo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamEcr (med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamLire (med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamCr (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)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnFam (med_idt fid, char *maa, int indice, med_dim_famille quoi)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamInfo (med_idt fid, char *maa, int indice, 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)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDequivCr (med_idt fid, char *maa, char *eq, char *desc)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDequivLire (med_idt fid, char *maa, char *eq, med_int *corr, med_int n, med_entite_maillage typ_ent, med_geometrie_element typ_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDequivEcr (med_idt fid, char *maa, char *eq, med_int *corr, med_int n, med_mode_acces mode, med_entite_maillage typ_ent, med_geometrie_element typ_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDequivInfo (med_idt fid, char *maa, int ind, char *eq, char *des)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnEquiv (med_idt fid, char *maa)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnCorres (med_idt fid, char *maa, char *eq, med_entite_maillage typ_ent, med_geometrie_element typ_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnEntites (med_idt fid, char *maa, med_entite_maillage typ_ent, med_connectivite typ_con)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnoeudsLire (med_idt fid, char *maa, med_int mdim, med_float *coord, med_mode_switch mode_coo, med_repere *repere, char *nomcoo, char *unicoo, char *nom, med_booleen *inom, med_int *num, med_booleen *inum, med_int *fam, med_int nnoeuds)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDnoeudsEcr (med_idt fid, char *maa, med_int mdim, med_float *coord, med_mode_switch mode_coo, med_repere repere, char *nomcoo, char *unicoo, char *nom, med_booleen inom, med_int *num, med_booleen inum, med_int *fam, med_int nnoeuds, med_mode_acces mode)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDelementsEcr (med_idt fid, char *maa, med_int mdim, med_int *connectivite, med_mode_switch mode_switch, char *nom, med_booleen inom, med_int *num, med_booleen inum, med_int *fam, med_int nele, med_entite_maillage typ_ent, med_geometrie_element typ_geo, med_connectivite typ_conn, med_mode_acces mode)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDelementsLire (med_idt fid, char *maa, med_int mdim, med_int *connectivite, med_mode_switch mode_switch, char *nom, med_booleen *inom, med_int *num, med_booleen *inum, med_int *fam, med_int nele, med_entite_maillage typ_ent, med_geometrie_element typ_geo, med_connectivite typ_conn)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamMaaInfo (med_idt fid, char *maa, med_int *nfam, med_int *nattc, med_int *ngroc)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamMaaLire (med_idt fid, char *maa, med_int *numfam, med_int *attide, med_int *attval, char *attdes, int *indatt, char *gro, int *indgro, med_int nfamilles)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamMaaCr (med_idt fid, char *maa, med_int *numfam, med_int *attide, med_int *attval, char *attdes, int *indatt, char *gro, int *indgro, med_int nfamilles)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDprofilInfo (med_idt fid, int indice, char *profil, med_int *n)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnProfil (med_idt fid)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDprofilEcr (med_idt fid, med_int *pflval, med_int n, char *nom)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnValProfil (med_idt fid, char *nom)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDprofilLire (med_idt fid, med_int *pflval, char *nom)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnPasdetemps (med_idt fid, char *cha, med_entite_maillage type_ent, med_geometrie_element type_geo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDpasdetempsInfo (med_idt fid, char *champ, med_entite_maillage type_ent, med_geometrie_element type_geo, int indice, char *maa, med_int *ngauss, med_int *numdt, char *dt_unit, med_float *dt, med_int *numo)
MEDWRAPPER_V2_1_CORE_EXPORT med_int MEDnGrid (med_idt fid, char *maa, med_grid n)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDgridCr (med_idt fid, char *maillage, med_int dim, med_grid_type typ)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDgridInfo (med_idt fid, int indice, med_int *isAGrid, med_grid_type *typ)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDgridEcr (med_idt fid, char *maa, med_int mdim, med_float *coo, med_int nb, med_int dim, med_mode_switch mode_coo, med_repere repere, char *nomcoo, char *unicoo, med_mode_acces mode)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDgridLire (med_idt fid, char *maa, med_int mdim, med_float *coo, med_int dim, med_mode_switch mode_coo, med_repere *repere, char *nomcoo, char *unicoo)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamGridEcr (med_idt fid, char *maa, med_int *fam, med_int n, med_mode_acces mode, med_entite_maillage type_ent)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDfamGridLire (med_idt fid, char *maa, med_int *fam, med_int n, med_entite_maillage type_ent)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDbodyFittedEcr (med_idt fid, char *maa, med_int mdim, med_float *coo, med_int *nbr, med_mode_switch mode_coo, med_repere repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds, med_mode_acces mode)
MEDWRAPPER_V2_1_CORE_EXPORT med_err MEDbodyFittedLire (med_idt fid, char *maa, med_int mdim, med_float *coo, med_mode_switch mode_coo, med_repere *repere, char *nomcoo, char *unicoo, med_int *fam, med_int nnoeuds)
med_err MEDequivInfo (int fid, char *maa, int ind, char *eq, char *des)
med_err MEDfam2groA (med_int nfam, med_int *numfam, med_int *numfamnoe, med_int nnoeuds, med_int *numfamele, med_int nelements, char *grofam, int *indfamgro, med_int *ngn, med_int *nge, med_int *nindn, med_int *ninde)
med_err MEDfam2groB (med_int nfam, med_int *numfam, med_int *numfamnoe, med_int nnoeuds, med_int *numfamele, med_int nelements, char *grofam, int *indfamgro, med_int *numnoeuds, med_int *numele, med_int ngn, med_int nge, med_int nindn, med_int ninde, char *nomgronoe, char *nomgroele, int *indgronoe, int *indgroele, med_int *tabgronoe, med_int *tabgroele)
med_err MEDgro2famA (med_int nnoe, med_int nele, med_int *numnoe, med_int *numele, med_int ngn, med_int nge, med_int nindn, med_int ninde, int *indgronoe, int *indgroele, med_int *tabgronoe, med_int *tabgroele, med_int *nfamg, med_int *nindf)
med_err MEDgro2famB (med_int nnoe, med_int nele, med_int *numnoe, med_int *numele, med_int ngn, med_int nge, med_int nindn, med_int ninde, char *nomgronoe, char *nomgroele, int *indgronoe, int *indgroele, med_int *tabgronoe, med_int *tabgroele, med_int nfamg, med_int nindf, med_int *newnumfam, med_int *newnumfamele, med_int *newnumfamnoe, int *newindfamgro, char *newfamgro)

Typedef Documentation

typedef herr_t med_2_1::med_err

Definition at line 97 of file med.hxx.

typedef double med_2_1::med_float

Definition at line 101 of file med.hxx.

typedef hid_t med_2_1::med_idt

Definition at line 96 of file med.hxx.

typedef int med_2_1::med_int

Definition at line 105 of file med.hxx.

typedef hsize_t med_2_1::med_size

Definition at line 94 of file med.hxx.

typedef hssize_t med_2_1::med_ssize

Definition at line 95 of file med.hxx.


Enumeration Type Documentation

Enumerator:
MED_FAUX 
MED_VRAI 

Definition at line 73 of file med.hxx.

Enumerator:
MED_NOD 
MED_DESC 

Definition at line 69 of file med.hxx.

Enumerator:
MED_COMP 
MED_DTYPE 

Definition at line 77 of file med.hxx.

Enumerator:
MED_GROUPE 
MED_ATTR 
MED_FAMILLE 

Definition at line 75 of file med.hxx.

Enumerator:
MED_MAILLE 
MED_FACE 
MED_ARETE 
MED_NOEUD 

Definition at line 54 of file med.hxx.

Enumerator:
MED_HDF_VERSION 
MED_VERSION 
MED_FICH_DES 

Definition at line 79 of file med.hxx.

Enumerator:
MED_POINT1 
MED_SEG2 
MED_SEG3 
MED_TRIA3 
MED_QUAD4 
MED_TRIA6 
MED_QUAD8 
MED_TETRA4 
MED_PYRA5 
MED_PENTA6 
MED_HEXA8 
MED_TETRA10 
MED_PYRA13 
MED_PENTA15 
MED_HEXA20 

Definition at line 63 of file med.hxx.

Enumerator:
MED_GRID_D1 
MED_GRID_D2 
MED_GRID_D3 
MED_GRID_NOEUD 
MED_FAM_NOEUD 
MED_FAM_ARETE 
MED_FAM_FACE 
MED_FAM_MAILLE 

Definition at line 40 of file med.hxx.

Enumerator:
MED_CARTESIAN 
MED_POLAR 
MED_BODY_FITTED 

Definition at line 38 of file med.hxx.

Enumerator:
MED_LECT 
MED_ECRI 
MED_REMP 

Definition at line 52 of file med.hxx.

Enumerator:
MED_GLOBALE 
MED_COMPACT 

Definition at line 49 of file med.hxx.

Enumerator:
MED_FULL_INTERLACE 
MED_NO_INTERLACE 

Definition at line 46 of file med.hxx.

Enumerator:
MED_CART 
MED_CYL 
MED_SPHER 

Definition at line 71 of file med.hxx.

Enumerator:
MED_COOR 
MED_CONN 
MED_NOM 
MED_NUM 
MED_FAM 

Definition at line 56 of file med.hxx.

Enumerator:
MED_REEL64 
MED_INT32 
MED_INT64 
MED_INT 

Definition at line 58 of file med.hxx.


Function Documentation

char * med_2_1::_MED1cstring ( char *  chaine,
int  longueur_reelle,
int  longueur_fixee 
)

Definition at line 39 of file MED1cstring.cxx.

{
  char *nouvelle;
  int i;

  if (longueur_reelle > longueur_fixee)
    return NULL;

  if ((nouvelle = (char *) malloc(sizeof(char)*(longueur_fixee+1))) == NULL)
    return NULL;

  for (i=0;i<longueur_reelle;i++)
    *(nouvelle+i) = *(chaine+i);

  for (i=longueur_reelle;i<longueur_fixee;i++)
    *(nouvelle+i) = ' ';
  
  *(nouvelle+longueur_fixee) = '\0';

  return nouvelle;
}
char * med_2_1::_MED2cstring ( char *  chaine,
int  longueur 
)

Definition at line 35 of file MED2cstring.cxx.

{
  char *nouvelle;
  char *temoin;
  int long_reelle = longueur;
  int i;

  if ( longueur < 0 ) return NULL;

  temoin = chaine+longueur-1;
  while (*temoin == ' ' && (temoin != chaine) )
    {
      temoin --;
      long_reelle--;
    }
  if ( *temoin == ' ') long_reelle = 0;
      
  if ((nouvelle = (char *) malloc(sizeof(char)*(long_reelle+1))) == NULL)
    return NULL;

  for (i=0;i<long_reelle+1;i++)
    *(nouvelle+i) = *(chaine+i);
  *(nouvelle+long_reelle) = '\0';

  return nouvelle;
}

Definition at line 34 of file MEDattrFermer.cxx.

{
  med_err ret;

  if ((ret = H5Aclose(id)) < 0)
    return -1;

  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDattrNumEcrire ( med_idt  pere,
med_type_champ  type,
char *  nom,
unsigned char *  val,
med_mode_acces  mode 
)

Definition at line 37 of file MEDattrNumEcrire.cxx.

{
  med_idt aid,attr;
  med_err ret;
  int type_hdf;

  switch(type)
    {
    case MED_REEL64 :
      /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
         the file read under SGI is incorrect
         2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
         REM  : Be careful of compatibility between MED files when changing this (med2.2)    
                */
#if defined(PCLINUX) || defined(PPRO_NT) || defined(PCLINUX64) || defined(PCLINUX64_32) || defined(OSF1)
      type_hdf = H5T_IEEE_F64BE;
#else 
      type_hdf = H5T_IEEE_F64LE;
#endif
      break;
      
    case MED_INT :
#if defined(HAVE_F77INT64)
      type_hdf = H5T_NATIVE_LONG;
#elif defined(PCLINUX) || defined(PCLINUX64_32)
      /* This explicit convertion avoid a core dump between in HDF&ASTER when reading on SGI
         a file written under a PCLINUX system (in founction H5Tconvert),
         we don't know yet if it is an HDF bug or an ASTER one */
      /* The problem seems to be in convertion process between INT32LE->INT32BE ? */
      type_hdf = H5T_STD_I32BE;
      if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,1,(void *)val,NULL,0)) < 0) 
          return -1;
#else
      type_hdf = H5T_NATIVE_INT;
#endif
      break;

    default :
      return -1;
    }

  if ((aid = H5Screate(H5S_SCALAR)) < 0)
    return -1;

  if ( ((attr = H5Aopen_name(pere,nom)) > 0) && (mode != MED_REMP) )
    return -1;
  else
    if ( attr < 0)
      if ((attr = H5Acreate(pere,nom,type_hdf,aid,H5P_DEFAULT)) < 0) return -1;  

  if ((ret = H5Awrite(attr,type_hdf,val)) < 0)
    return -1;


  if ((ret = H5Sclose(aid)) < 0)
    return -1;
  if ((ret = H5Aclose(attr)) < 0)
    return -1;

#if defined(PCLINUX) || defined(PCLINUX64_32)
  /* This explicit convertion cancel the previous on which avoid a mysterious bug between HDF&ASTER when reading
     a file written under a PCLINUX system, we don't know yet if it is an HDF bug or an ASTER one */  
  if (type == MED_INT) 
    if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,1,(void *)val,NULL,0)) < 0) 
      return -1;
#endif

  return 0;
}
med_err med_2_1::_MEDattrNumLire ( med_idt  pere,
med_type_champ  type,
char *  nom,
unsigned char *  val 
)

Definition at line 39 of file MEDattrNumLire.cxx.

{
  med_idt attid;
  med_err ret;
  int type_hdf;

  if ((attid = H5Aopen_name(pere,nom)) < 0)
    return -1;

  switch(type) 
    {
    case MED_REEL64 :
#if defined(PCLINUX) || defined(OSF1) || defined(PPRO_NT) || defined(PCLINUX64) || defined(PCLINUX64_32)
      type_hdf = H5T_IEEE_F64BE;
#else 
      type_hdf = H5T_IEEE_F64LE;
#endif
      break;
      
    case MED_INT :
#if defined(HAVE_F77INT64)
      type_hdf = H5T_NATIVE_LONG; 
#else
      type_hdf = H5T_NATIVE_INT;
#endif
      break;
      
    default :
      return -1;
    }

  if ((ret = H5Aread(attid,type_hdf,val)) < 0)
    return -1;

  if (strcmp(nom, MED_NOM_NGA) == 0 ) {
    med_int* ngauss = (med_int*)val;
    if( *ngauss <= 0 || *ngauss > 128) 
      *ngauss =1;
  }

  if ((ret = H5Aclose(attid)) < 0)
    return -1;

  return 0;
}
med_idt med_2_1::_MEDattrOuvrir ( med_idt  pid,
char *  nom 
)

Definition at line 35 of file MEDattrOuvrir.cxx.

{
   med_idt aid;

   if ((aid = H5Aopen_name(pid,nom)) < 0)
     return -1;

   return aid;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDattrStringEcrire ( med_idt  pere,
char *  nom,
int  longueur,
char *  val,
med_mode_acces  mode 
)

Definition at line 36 of file MEDattrStringEcrire.cxx.

{
  med_idt aid,attr, datatype;
  med_err ret;

  if ((aid = H5Screate(H5S_SCALAR)) < 0)
    return -1;
  if((datatype = H5Tcopy(H5T_C_S1)) < 0)
    return -1;
  if((ret = H5Tset_size(datatype,longueur+1)) < 0)
    return -1;

  if ( ((attr = H5Aopen_name(pere,nom)) > 0)
       && (mode != MED_REMP) )
    return -1;
  else
    if ( attr < 0)
      if ((attr = H5Acreate(pere,nom,datatype,aid,H5P_DEFAULT)) < 0) return -1;
  
  if ((ret = H5Awrite(attr, datatype, val)) < 0)
    return -1;

  if ((ret = H5Sclose(aid)) < 0)
    return -1;
  if ((ret = H5Tclose(datatype)) < 0)
    return -1;
  if ((ret = H5Aclose(attr)) < 0)
    return -1;

  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDattrStringLire ( med_idt  pere,
char *  nom,
int  longueur,
char *  val 
)

Definition at line 36 of file MEDattrStringLire.cxx.

{
  med_idt attid,datatype;
  med_err ret;

  if ((datatype = H5Tcopy(H5T_C_S1)) < 0)
    return -1;
  if ((ret = H5Tset_size(datatype,longueur+1)) < 0)
    return -1;
  if ((attid = H5Aopen_name(pere,nom)) < 0)
    return -1;
  if ((ret = H5Aread(attid,datatype,val)) < 0)
    return -1;
  if ((ret = H5Tclose(datatype)) < 0)
    return -1;
  if ((ret = H5Aclose(attid)) < 0)
    return -1;

  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDcstringFree ( char *  chaine)

Definition at line 34 of file MEDcstringFree.cxx.

{

  free(chaine);
  return 0;

}
med_idt med_2_1::_MEDdatagroupCreer ( med_idt  pid,
char *  nom 
)

Definition at line 35 of file MEDdatagroupCreer.cxx.

{
  med_idt id;

  if ((id = H5Gcreate(pid,nom,0)) < 0)
    return -1;

  return id;
}

Here is the caller graph for this function:

Definition at line 34 of file MEDdatagroupFermer.cxx.

{
  med_err ret;

  if ((ret = H5Gclose(id)) < 0)
    return -1;
  else
    return 0;
}
med_idt med_2_1::_MEDdatagroupOuvrir ( med_idt  pid,
char *  nom 
)

Definition at line 35 of file MEDdatagroupOuvrir.cxx.

{
  med_idt id;

  if ((id = H5Gopen(pid,nom)) < 0)
    return -1;

  return id;
}

Definition at line 33 of file MEDdatasetFermer.cxx.

{
  med_err ret;

  if ((ret = H5Dclose(id)) < 0)
    return -1;
  
  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDdatasetNumEcrire ( med_idt  pere,
char *  nom,
med_type_champ  type,
med_mode_switch  interlace,
med_size  nbdim,
med_size  fixdim,
med_size  psize,
med_ssize *  profil,
med_int  ngauss,
med_size *  size,
unsigned char *  val,
med_mode_acces  mode 
)

Definition at line 49 of file MEDdatasetNumEcrire.cxx.

{
  med_idt    dataset, dataspace = 0, memspace = 0;
#ifdef HDF_NEW_API
  med_size  start_mem[1],start_data[1],*pflmem,*pfldsk;
#else
  med_ssize  start_mem[1],start_data[1],*pflmem,*pfldsk;
#endif
  med_size   stride[1],count[1],pcount[1],pflsize[1];
  med_err    ret;
  int        i,j,index,type_hdf;
  int        dim, firstdim, dimutil, lastdim ;
  med_mode_profil pflmod;

  /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
  if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) 
    return -1;

  /* block pflmod to MED_COMPACT (until med2.2) */
  pflmod = MED_COMPACT;

  switch(type) 
    {
    case MED_REEL64 :
      /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
         the file read under SGI is incorrect
         2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
         REM  : Be careful of compatibility between MED files when changing this (med2.2)                    */
#if defined(PCLINUX) || defined(PCLINUX64) || defined(PCLINUX64_32) || defined(OSF1) || defined( PPRO_NT )
      type_hdf = H5T_IEEE_F64BE;
#else     
      type_hdf = H5T_IEEE_F64LE;
#endif
      break;

    case MED_INT32 :
#if defined(PCLINUX) || defined(PCLINUX64) || defined(PCLINUX64_32)
      type_hdf = H5T_STD_I32BE;
      if ((H5Tconvert(H5T_NATIVE_INT,H5T_STD_I32BE,(hsize_t)*size,(void *)val,NULL,(hid_t)0)) < 0) 
          return -1;
#else
      type_hdf = H5T_NATIVE_INT;
#endif
      break;
 
    case MED_INT64 :
      type_hdf = H5T_NATIVE_LONG;
      break;

    default :
      return -1;
    }


  if ((dataset = H5Dopen(pere,nom)) < 0)
    {
      /* Whatever the size of the profil is we create a dataset with the size of the value array               */
      /* Then if we used the MED_REMP mode we can append a new dimension to a previous one in the dataset      */
      /* When we'll use the compression mode, the space used by unused values would be easily compressed       */
  
      if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
        return -1;
      if ((dataset = H5Dcreate(pere,nom,type_hdf,dataspace,
                               H5P_DEFAULT)) < 0)
        return -1;      
    }
  else
    if (mode != MED_REMP)
      {
        H5Dclose(dataset);
        return -1;
      }
    else
      if ((dataspace = H5Dget_space(dataset)) <0)
        return -1;


  switch(interlace) 
    {  /* switch Interlace */
    case MED_FULL_INTERLACE :
      
      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
      if ( fixdim != MED_ALL) 
        { 
          firstdim = (int)fixdim-1;
          lastdim  = (int)fixdim;
          dimutil  = 1;
        } else  {
          firstdim = 0;
          lastdim  = (int)nbdim;
          dimutil  = (int)nbdim; 
        }

      count [0] = (*size)/(nbdim);


      if ( psize == MED_NOPF ) {  

        /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
        if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
          return -1;
        
        stride[0] = nbdim;  

        for (dim=firstdim; dim < lastdim; dim++) {
          
          start_mem[0] = dim;
          if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, 
                                           count, NULL)) <0)
            return -1; 
          
          start_data[0] = dim*count[0];
          if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
                                           count, NULL)) <0)
            return -1; 
          
          if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,
                              H5P_DEFAULT, val)) < 0)
            return -1;
        }
        
      } else { /* psize != MED_NOPF */
        
        pflsize [0] = psize*ngauss*nbdim;
        pcount  [0] = psize*ngauss*dimutil;
#ifdef HDF_NEW_API
        pflmem      = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
        pfldsk      = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
#else
        pflmem      = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
        pfldsk      = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
#endif
        
        switch(pflmod)
          { /* switch pflmod pout FULL_INTERLACE*/
          case MED_GLOBALE :

            /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
            if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
              return -1;

            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye les élements du profil */
                for (j=0; j < ngauss; j++) {         
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
                  pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
                }
            }
             
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0) 
              return -1; 
              
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1; 
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0) 
              return -1; 
              
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1; 
#else
            if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0) 
              return -1; 
              
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1; 
#endif
            
            break;
            
          case MED_COMPACT :

            /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
            /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
            /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 

            if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
              return -1;
            
            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye les élements du profil */
                for (j=0; j < ngauss; j++) {         
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
                  pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
                }
            }
            
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1; 
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1; 
#else
            if ( (ret = H5Sselect_elements(memspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1; 
#endif
             
            break;
          
          default :
            return -1; 
          }

        if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
          return -1;
        
        free(pflmem);
        free(pfldsk);
      }
      
      
      break;
      
    case MED_NO_INTERLACE :

      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/

      count[0] = (*size)/nbdim;

      if ( psize == MED_NOPF ) {  
        
        if ( fixdim != MED_ALL) 
          start_data[0] = (fixdim-1)*count[0];
        else {
          count[0] = *size;
          start_data[0] =  0;
        };
        
        if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
                                         count, NULL)) <0)
          return -1; 
        
        if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,
                            H5P_DEFAULT, val)) < 0)
          return -1;
        
      } else {

        if ( fixdim != MED_ALL) 
          { 
            firstdim = (int)fixdim-1;
            lastdim  = (int)fixdim;
            dimutil  = 1;
          } else        {
            firstdim = 0;
            lastdim  = (int)nbdim;
            dimutil  = (int)nbdim; 
          }
        
        pflsize [0] = psize*ngauss*nbdim;
        pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */      
#ifdef HDF_NEW_API
        pfldsk     = (med_size *) malloc(sizeof(med_size)*(size_t)pcount[0]);
#else
        pfldsk     = (med_ssize *) malloc(sizeof(med_ssize)*(size_t)pcount[0]);
#endif

        switch(pflmod)
          { /*switch plfmod pour NO_INTERLACE */
          case MED_GLOBALE :
            
            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
                for (j=0; j < ngauss; j++) { 
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;      
                }
            }
            
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1;
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1;
#else
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1;
#endif
            
            if ((ret = H5Dwrite(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
              return -1;
            
            break;
            
          case MED_COMPACT :
            
            /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
            /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
            /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 

            if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
              return -1;

#ifdef HDF_NEW_API
            pflmem     = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
#else
            pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
#endif
            
            /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/
            
            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
                for (j=0; j < ngauss; j++) {
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j;
                  pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;           
                }
            }
             
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pflmem ) ) <0) 
              return -1; 
              
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1;
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pflmem ) ) <0) 
              return -1; 
              
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1;
#else
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pflmem ) ) <0) 
              return -1; 
              
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1;
#endif
           
            if ((ret = H5Dwrite(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
              return -1;

            free(pflmem);
            
            break;
            
          default :
            return -1;      
            
          }
   
        free(pfldsk);
        
      };

      break;
      
    default :
      return -1;
    }
  
  
  if (memspace) 
    if ((ret = H5Sclose(memspace)) < 0)
      return -1;
  
  if ((ret = H5Sclose(dataspace)) < 0)
    return -1;
  
  if ((ret = H5Dclose(dataset)) < 0)
    return -1;      

#if defined(PCLINUX) || defined(PCLINUX64) || defined(PCLINUX64_32)
  if (type == MED_INT32)
      if ((H5Tconvert(H5T_STD_I32BE,H5T_NATIVE_INT,(hsize_t)*size,(void *)val,NULL,(hid_t)0)) < 0) 
          return -1;
#endif 
  
  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDdatasetNumLire ( med_idt  pere,
char *  nom,
med_type_champ  type,
med_mode_switch  interlace,
med_size  nbdim,
med_size  fixdim,
med_size  psize,
med_ssize *  pfltab,
med_int  ngauss,
unsigned char *  val 
)

Definition at line 46 of file MEDdatasetNumLire.cxx.

{
  med_idt    dataset, dataspace = 0, memspace = 0;
#ifdef HDF_NEW_API
  med_size  start_mem[1],start_data[1],*pflmem=0,*pfldsk=0;
#else
  med_ssize  start_mem[1],start_data[1],*pflmem=0,*pfldsk=0;
#endif
  med_size   stride[1],count[1],pcount[1],size[1],pflsize[1];
  med_err    ret;
  int        i,j,index,type_hdf;
  hid_t      datatype;
  size_t     typesize;
  int        dim, firstdim, dimutil, lastdim;
  med_mode_profil pflmod;

  /* Verify fixdim is between [0, nbdim] ( 0 is MED_ALL ) */
  if ( ( fixdim < 0 ) || ( fixdim > nbdim ) ) 
    return -1;
 
  /* block pflmod to MED_COMPACT (until med2.2) */
  pflmod = MED_COMPACT;

  switch(type)
    {
    case MED_REEL64 :
      /* 1) IA32 is LE but due to an (?HDF convertion BUG?) when using H5T_NATIVE_DOUBLE/MED_REEL64? under PCLINUX
            the file read under SGI is incorrect
         2) Compaq OSF/1 is LE, since we force SGI64,SUN4SOL2,HP to write double in LE even if they are BE, mips OSF/1 must be BE
         REM  : Be careful of compatibility between MED files when changing this (med2.2)
         3) PPRO_NT is added for med2.1.6 support under Win32 */
#if defined(PCLINUX) || defined(OSF1) || defined(PPRO_NT) || defined(PCLINUX64) || defined(PCLINUX64_32)
      type_hdf = H5T_IEEE_F64BE;
#else 
      type_hdf = H5T_IEEE_F64LE;
#endif
      break;

    case MED_INT32 :
      type_hdf = H5T_NATIVE_INT;
      break;

    case MED_INT64 :
      type_hdf = H5T_NATIVE_LONG;
      break;

    default :
      return -1;
    }

  /* Ouverture du Dataset à lire */
  if ((dataset = H5Dopen(pere,nom)) < 0)
    return -1;

  /* Interrogation de la taille du dataset */
  if ( (datatype  = H5Dget_type(dataset )) < 0) return -1;
  if ( (typesize  = H5Tget_size(datatype)) < 0) return -1;
  size[0] = H5Dget_storage_size(dataset) / typesize; 
  if ( H5Tclose(datatype) < 0) return -1;

  /* Create dataspace */
  if ((dataspace = H5Screate_simple(1,size,NULL)) < 0)
    return -1;
  
  switch(interlace)
    {
    case MED_FULL_INTERLACE :

      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/
      if ( fixdim != MED_ALL) 
        { 
          firstdim = (int)fixdim-1;
          lastdim  = (int)fixdim;
          dimutil  = 1;
        } else  {
          firstdim = 0;
          lastdim = (int)nbdim;
          dimutil  = (int)nbdim; 
        }

      count [0] = (*size)/(nbdim);
      

      /*rem: Pas de vérification de l'assertion (*size)=n*nbdim */
      if ( psize == MED_NOPF ) {  

      /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
      if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
        return -1;

        stride[0] = nbdim;  

        for (dim=firstdim; dim < lastdim; dim++) {
                  
          start_mem[0] = dim;
          if ( (ret = H5Sselect_hyperslab (memspace, H5S_SELECT_SET, start_mem, stride, 
                                           count, NULL)) <0)
            return -1; 
          
          start_data[0] = dim*count[0];
          if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
                                           count, NULL)) <0)
            return -1; 
          
          if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,
                             H5P_DEFAULT, val)) < 0)
            return -1;
        }
        
      } else {

        pflsize [0] = psize*ngauss*nbdim;
        pcount  [0] = psize*ngauss*dimutil;
#ifdef HDF_NEW_API
        pflmem     = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
        pfldsk     = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
#else
        pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
        pfldsk     = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
#endif
        
        switch(pflmod)
          { /* switch pflmod pour FULL_INTERLACE*/
          case MED_GLOBALE :

            /* Creation d'un data space mémoire de dimension 1, de longeur size, et de longeur maxi size */
            if ( (memspace = H5Screate_simple (1, size, NULL)) <0)
              return -1;

            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye les élements du profil */
                for (j=0; j < ngauss; j++) {         
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pflmem[index] = (pfltab[i]-1)*ngauss*nbdim + j*nbdim+dim;
                  pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
                }
            }
            
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1; 
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1; 
#else
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1; 
#endif
            
            break;
        
          case MED_COMPACT :
        
            /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
            /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
            /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 
            
            if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
              return -1;
            
            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye les élements du profil */
                for (j=0; j < ngauss; j++) {         
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pflmem[index] = i*ngauss*nbdim + j*nbdim+dim;
                  pfldsk[index] = dim*count[0] + (pfltab[i]-1)*ngauss+j;             
                }             
            }
            
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1; 
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1; 
#else
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1; 
#endif
            
            break;

          default :
            return -1; 
          }
        
        if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
          return -1;
        
        free(pflmem);
        free(pfldsk);
      }
     
      break;
      
    case MED_NO_INTERLACE :

      /*Initialisation des indices de boucle du traitement de l'entrelacement en fonction de la dimension fixee*/

      count[0] = (*size)/nbdim;
      
      if ( psize == MED_NOPF ) {  
        
        if ( fixdim != MED_ALL) 
          start_data[0] = (fixdim-1)*count[0];
        else {
          count[0] = *size;
          start_data[0] =  0;
        };
        
        if ( (ret = H5Sselect_hyperslab (dataspace, H5S_SELECT_SET, start_data, NULL, 
                                         count, NULL)) <0)
          return -1; 
        
        if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,
                           H5P_DEFAULT, val)) < 0)
          return -1;
        
      } else {

        if ( fixdim != MED_ALL) 
          { 
            firstdim = (int)fixdim-1;
            lastdim  = (int)fixdim;
            dimutil  = 1;
          } else        {
            firstdim = 0;
            lastdim  = (int)nbdim;
            dimutil  = (int)nbdim; 
          }

        pflsize [0] = psize*ngauss*nbdim;       
        pcount  [0] = psize*ngauss*dimutil; /* nom pas très coherent avec count !!! A revoir */      
#ifdef HDF_NEW_API
        pfldsk      = (med_size *) malloc(sizeof(med_size)*(size_t)pcount[0]);
#else
        pfldsk      = (med_ssize *) malloc(sizeof(med_ssize)*(size_t)pcount[0]);
#endif
        
        switch(pflmod)
          { /*switch plfmod pour NO_INTERLACE */
          case MED_GLOBALE :
            
            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
                for (j=0; j < ngauss; j++) { 
                  index = i*ngauss+j + (dim-firstdim)*((int)psize*ngauss);
                  pfldsk[index] = dim*count[0]+(pfltab[i]-1)*ngauss+j;      
                }
            }
            
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1;
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1;
#else
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1;
#endif
            
            if ((ret = H5Dread(dataset,type_hdf,dataspace,dataspace,H5P_DEFAULT, val)) < 0)
              return -1;
              
            break;
            
          case MED_COMPACT :
            
            /* Creation d'un data space mémoire de dimension 1, de la longeur du profil          */
            /* La dimension utilisée est ici nbdim, même pour un profil compact on suppose       */
            /*  que l'utilisateur a toutes les coordonées stockées, même si il en demande qu'une */ 

            if ( (memspace = H5Screate_simple (1, pflsize, NULL)) <0)
              return -1;

#ifdef HDF_NEW_API
            pflmem     = (med_size *) malloc (sizeof(med_size)*(size_t)pcount[0]);
#else
            pflmem     = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)pcount[0]);
#endif
            
            /* Le profil COMPACT est contigüe, mais il est possible que l'on selectionne uniquemenent une dimension*/

            index = 0;
            for (dim=firstdim; dim < lastdim; dim++) {
              
              for (i=0; i < psize; i++)              /* i balaye le nbre d'élements du profil                */
                for (j=0; j < ngauss; j++) {
//                index = i*ngauss+j + (dim-firstdim)*(psize*ngauss);
//                pflmem[index] = dim*(psize*ngauss) + (pfltab[i]-1)*ngauss+j;
//                pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;           
                  pflmem[index] = ( (dim*psize) + i )*ngauss + j;
                  pfldsk[index] = dim*count[0]  + (pfltab[i]-1)*ngauss+j;
                  index++;          
                }
            }
            
#ifdef HDF_NEW_API2
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t *) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t *) pfldsk ) ) <0) 
              return -1;          
#elif defined HDF_NEW_API
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hsize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hsize_t **) pfldsk ) ) <0) 
              return -1;          
#else
            if ( (ret = H5Sselect_elements(memspace ,H5S_SELECT_SET, (size_t)pcount[0], (const hssize_t **) pflmem ) ) <0) 
              return -1; 
            
            if ( (ret = H5Sselect_elements(dataspace,H5S_SELECT_SET,(size_t)pcount[0], (const hssize_t **) pfldsk ) ) <0) 
              return -1;          
#endif
            
            if ((ret = H5Dread(dataset,type_hdf,memspace,dataspace,H5P_DEFAULT, val)) < 0)
              return -1;
            
            break;
            
          default :
            return -1;      
            
          }
        
        free(pfldsk);
                
      };
      
      break;
      
    default :
      return -1;
    }
  
  

  if (memspace) 
    if ((ret = H5Sclose(memspace)) < 0)
      return -1;

  if ((ret = H5Sclose(dataspace)) < 0)
    return -1;
  
  if ((ret = H5Dclose(dataset)) < 0)
    return -1;      

  return 0;
}

Here is the caller graph for this function:

med_idt med_2_1::_MEDdatasetOuvrir ( med_idt  pid,
char *  nom 
)

Definition at line 34 of file MEDdatasetOuvrir.cxx.

{
  med_idt id;

  if ((id = H5Dopen(pid,nom)) < 0)
    return -1;

  return id;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDdatasetStringEcrire ( med_idt  pere,
char *  nom,
med_size *  dimd,
char *  val,
med_mode_acces  mode 
)

Definition at line 37 of file MEDdatasetStringEcrire.cxx.

{
  med_idt dataset;
  med_idt datatype = 0;
  med_idt dataspace = 0;
  med_err ret;

  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 (mode != MED_REMP)
      {
        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;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDdatasetStringLire ( med_idt  pere,
char *  nom,
char *  val 
)

Definition at line 35 of file MEDdatasetStringLire.cxx.

{
  med_idt dataset,datatype;
  med_err ret;

  if ((dataset = H5Dopen(pere,nom)) < 0)
    return -1;
  if ((datatype = H5Tcopy(H5T_C_S1)) < 0)
    return -1;
  if ((ret = H5Tset_size(datatype,1)) < 0)
    return -1;
  if ((ret = H5Dread(dataset,datatype,H5S_ALL,H5S_ALL,H5P_DEFAULT,val)) < 0)
     return -1;
  if ((ret = H5Tclose(datatype)) < 0)
    return -1;
  if ((ret = H5Dclose(dataset)) < 0)
    return -1;

  return 0;
}

Here is the caller graph for this function:

Definition at line 34 of file MEDfichierCreer.cxx.

{
  med_idt fid,gid;
  med_err ret;
  med_int majeur = MED_NUM_MAJEUR;
  med_int mineur = MED_NUM_MINEUR; 
  med_int release = MED_NUM_RELEASE;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  if ((fid = H5Fcreate(nom,H5F_ACC_TRUNC,
                               H5P_DEFAULT,H5P_DEFAULT)) < 0)
    return -1;

  if ((gid = _MEDdatagroupCreer(fid,MED_NOM_INFOS)) < 0)
    return -1;

  /* Numero de versions de MED */
  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MAJEUR,&majeur,MED_REMP)) < 0)
    return -1;

  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_MINEUR,&mineur,MED_REMP)) < 0)
    return -1;

  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_RELEASE,&release,MED_REMP)) < 0)
    return -1;

  /* On ferme tout */
  if ((ret = _MEDdatagroupFermer(gid)) < 0)
    return -1;

  return fid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 33 of file MEDfichierFermer.cxx.

{
  med_err ret;

  if ((ret = H5Fclose(fid)) < 0)
    return -1;

  return 0;
}

Here is the caller graph for this function:

med_idt med_2_1::_MEDfichierOuvrir ( char *  nom,
med_mode_acces  mode 
)

Definition at line 35 of file MEDfichierOuvrir.cxx.

{ 
  med_idt fid;
  int hdf_mode;

  switch(mode)
    {
    case MED_ECRI :
      hdf_mode = H5F_ACC_RDWR; 
      break;

    case MED_LECT :
      hdf_mode = H5F_ACC_RDONLY;
      break;

    default :
      return -1;
    }  

  if ((fid = H5Fopen(nom,hdf_mode,H5P_DEFAULT)) < 0)
    return -1;

  return fid;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDfstring ( char *  chaine,
med_int  longueur_fixee 
)

Definition at line 29 of file MEDfstring.cxx.

{
  int longueur_reelle, i;

  if (longueur_fixee == 0 ) return 0;

  longueur_reelle = (int)strlen(chaine);
  if (longueur_fixee < longueur_reelle)
    return -1;

  /* on supprime le caractere de fin de chaine C '\0'
     et complete par des blancs */
  for (i=longueur_reelle;i<longueur_fixee;i++)
    *(chaine+i) = ' ';

  return 0;
}
med_err med_2_1::_MEDGeometrieElement ( med_geometrie_element  typ_geo[],
med_entite_maillage  typ_ent 
)

Definition at line 25 of file MEDGeometrieElement.cxx.

{
  int i;
  med_geometrie_element typ_mai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, 
                                                         MED_SEG3,MED_TRIA3,
                                                         MED_TRIA6,MED_QUAD4,
                                                         MED_QUAD8,MED_TETRA4,
                                                         MED_TETRA10,MED_HEXA8,
                                                         MED_HEXA20,MED_PENTA6,
                                                         MED_PENTA15,MED_PYRA5,
                                                         MED_PYRA13};
  med_geometrie_element typ_fac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
                                                       MED_QUAD4,MED_QUAD8};
  med_geometrie_element typ_are[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};  

  switch(typ_ent)
    {
    case MED_MAILLE :
      for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
        typ_geo[i] = typ_mai[i];
      break;

    case MED_FACE :
      for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
        typ_geo[i] = typ_fac[i];
      break;
      
    case MED_ARETE :
      for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
        typ_geo[i] = typ_are[i];
      break;

    default :
      return -1;
    }
  return 0;
}
med_err med_2_1::_MEDindiceInfo ( med_idt  id,
const char *  nom,
void *  donnees 
)

Definition at line 40 of file MEDindiceInfo.cxx.

{
  if (donnees != NULL)
    strcpy((char*)donnees,nom);
  else 
    return -1;

  return 1;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDindiceNum ( med_idt  id,
const char *  nom,
void *  donnees 
)

Definition at line 37 of file MEDindiceNum.cxx.

{
  int *compteur;
  
  compteur = (int *) donnees;
  (*compteur)++;

  return 0;
}

Here is the caller graph for this function:

Definition at line 32 of file MEDmodeErreurVerrouiller.cxx.

{
  H5Eset_auto(NULL,NULL);
}
med_err med_2_1::_MEDnObjets ( med_idt  fid,
char *  chemin,
int *  n 
)

Definition at line 36 of file MEDnObjets.cxx.

{
  int idx;

  if ((idx  = H5Giterate(fid,chemin,NULL,_MEDindiceNum,(void *)n)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::_MEDnomDataset ( char *  nom_dataset,
med_table  quoi,
med_connectivite  type_conn 
)

Definition at line 38 of file MEDnomDataset.cxx.

{
  switch(quoi)
    {
    case MED_COOR :
      strcpy(nom_dataset,MED_NOM_COO);
      break;

    case MED_CONN :
      switch(type_conn)
        {
        case MED_NOD :
          strcpy(nom_dataset,MED_NOM_NOD);
          break;

        case MED_DESC :
          strcpy(nom_dataset,MED_NOM_DES);
          break;

        default :
          return -1;
        }
      break;

    case MED_NOM :
      strcpy(nom_dataset,MED_NOM_NOM);
      break;

    case MED_NUM :
      strcpy(nom_dataset,MED_NOM_NUM);
      break;

    case MED_FAM :
      strcpy(nom_dataset,MED_NOM_FAM);
      break;

    default :
      return -1;
    }

  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDnomEntite ( char *  nom_ent,
med_entite_maillage  type_ent 
)

Definition at line 36 of file MEDnomEntite.cxx.

{
   switch(type_ent)
     {
     case MED_NOEUD :
       strcpy(nom_ent,MED_NOM_NOE);
       break;

     case MED_MAILLE :
       strcpy(nom_ent,MED_NOM_MAI);
       break;

     case MED_FACE :
       strcpy(nom_ent,MED_NOM_FAC);
       break;

     case MED_ARETE :
       strcpy(nom_ent,MED_NOM_ARE);
       break;

     default :
       return -1;
     }
   return 0;
}

Here is the caller graph for this function:

med_err med_2_1::_MEDnomGeometrie ( char *  nom_geo,
med_geometrie_element  type_geo 
)

Definition at line 37 of file MEDnomGeometrie.cxx.

{
   switch (type_geo)
     {
     case MED_POINT1 :
       strcpy(nom_geo,MED_NOM_PO1);
       break;
       
     case MED_SEG2 :
       strcpy(nom_geo,MED_NOM_SE2);
       break;
           
     case MED_SEG3 :
       strcpy(nom_geo,MED_NOM_SE3);
       break;
           
     case MED_TRIA3 :
       strcpy(nom_geo,MED_NOM_TR3);
       break;
           
     case MED_TRIA6 :
       strcpy(nom_geo,MED_NOM_TR6);
       break;
           
     case MED_QUAD4 :
       strcpy(nom_geo,MED_NOM_QU4);
       break;
       
     case MED_QUAD8 :
       strcpy(nom_geo,MED_NOM_QU8);
       break;
       
     case MED_TETRA4 :
       strcpy(nom_geo,MED_NOM_TE4);
       break;
       
     case MED_TETRA10 :
       strcpy(nom_geo,MED_NOM_T10);
       break;
       
     case MED_HEXA8 :
       strcpy(nom_geo,MED_NOM_HE8);
       break;
       
     case MED_HEXA20 :
       strcpy(nom_geo,MED_NOM_H20);
       break;
       
     case MED_PENTA6 :
       strcpy(nom_geo,MED_NOM_PE6);
       break;
       
     case MED_PENTA15 :
       strcpy(nom_geo,MED_NOM_P15);
       break;
       
     case MED_PYRA5 :
       strcpy(nom_geo,MED_NOM_PY5);
       break;
       
     case MED_PYRA13 :
       strcpy(nom_geo,MED_NOM_P13);
       break;

     default :
       return -1;
         }
   
   return 0;
} 

Here is the caller graph for this function:

med_err med_2_1::_MEDobjetIdentifier ( med_idt  fid,
char *  chemin,
int  indice,
void *  nom 
)

Definition at line 38 of file MEDobjetIdentifer.cxx.

{
  int idx;

  if ((idx = H5Giterate(fid,chemin,&indice,_MEDindiceInfo,
                        nom)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::_MEDparametresGeometrie ( med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
int *  dim,
int *  nnoe,
int *  ndes 
)

Definition at line 40 of file MEDparametresGeometrie.cxx.

{
  *nnoe = type_geo % 100;
  *dim = type_geo / 100;

  switch(type_ent)
    {
    case MED_MAILLE :
      switch (type_geo)
        {
        case MED_POINT1 :
          *ndes = 0;
          break;
          
        case MED_SEG2 :
          *ndes = 2;
          break;
          
        case MED_SEG3 :
          *ndes = 3;
          break;
          
        case MED_TRIA3 :
          *ndes = 3;
          break;
          
        case MED_TRIA6 :
          *ndes = 3;
          break;
          
        case MED_QUAD4 :
          *ndes = 4;
          break;
          
        case MED_QUAD8 :
          *ndes = 4;
          break;
          
        case MED_TETRA4 :
          *ndes = 4;
          break;
          
        case MED_TETRA10 :
          *ndes = 4;
          break;
          
        case MED_HEXA8 :
          *ndes = 6;
          break;
          
        case MED_HEXA20 :
          *ndes = 6;
          break;
          
        case MED_PENTA6 :
          *ndes = 5;
          break;
          
        case MED_PENTA15 :
          *ndes = 5;
          break;
          
        case MED_PYRA5 :
          *ndes = 5;
          break;
          
        case MED_PYRA13 :
          *ndes = 5;
          break;
          
        default :
          return -1;
        }
      break;
      
    case MED_FACE :
      switch(type_geo)
        {
        case MED_TRIA3 :
          *ndes = 3;
          break;
          
        case MED_TRIA6 :
          *ndes = 3;
          break;
          
        case MED_QUAD4 :
          *ndes = 4;
          break;
          
        case MED_QUAD8 :
          *ndes = 4;
          break;
          
        default :
          return -1;
        }
      break;
      
    case MED_ARETE :
      switch(type_geo)
        {
        case MED_SEG2 :
          *ndes = 2;
          break;
          
        case MED_SEG3 :
          *ndes = 3;
          break;
          
        default :
          return -1;
        }
      break;
      
    default :
      return -1;
    }
  
  return 0;
}

Here is the caller graph for this function:

med_err med_2_1::MEDbodyFittedEcr ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coo,
med_int *  nbr,
med_mode_switch  mode_coo,
med_repere  repere,
char *  nomcoo,
char *  unicoo,
med_int *  fam,
med_int  nnoeuds,
med_mode_acces  mode 
)

Definition at line 33 of file MEDbodyFittedEcr.cxx.

{
    /* ecriture des coordonnees */
    med_idt   maaid, noeid, dataset;
    med_size dimd[1];
    char     chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
    med_int  type_rep_int;
    int      d;
    char     *ds;

    /* On inhibe le gestionnaire d'erreur HDF */
    _MEDmodeErreurVerrouiller();

    /* Si le maillage n'existe pas => erreur */
    strcpy(chemin, MED_MAA);
    strcat(chemin, maa);
    if ((maaid = _MEDdatagroupOuvrir(fid, chemin)) < 0) {
        return(-1);
    };

    /* Si le Data Group "NOE" n'existe pas on le cree */
    if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) {
        if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) {
            return(-1);
        };
    };

    /* Creation du Data Set "BOF" */
    dimd[0] = nnoeuds*mdim;
    if (_MEDdatasetNumEcrire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) {
        return(-1);
    };
  
    /* On re-ouvre le Data Set "BOF" pour y placer des attributs */
    if ((dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF)) < 0) {
        return(-1);
    };

    /* Attribut NBR (nombre de noeuds) */
    if (_MEDattrEntierEcrire(dataset, MED_NOM_NBR, &nnoeuds, mode) < 0) {
        return(-1);
    };

    /* L'attribut "REP" */
    type_rep_int = (med_int)repere;
    if (_MEDattrEntierEcrire(dataset, MED_NOM_REP, &type_rep_int, mode) < 0) {
        return(-1);
    };

    /* Attribut "NOM" */
    if (_MEDattrStringEcrire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) {
        return(-1);
    };

    /* Attribut "UNI" */
    if (_MEDattrStringEcrire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) {
        return(-1);
    };

    if (_MEDdatasetFermer(dataset) < 0) return(-1);

    dimd[0] = 1;
    for (d=0; d<mdim; d++) {
        switch (d) {
            case 0 : {
                ds = MED_NOM_IN1;
                break;
            };
            case 1 : {
                ds = MED_NOM_IN2;
                break;
            };
            case 2 : {
                ds = MED_NOM_IN3;
                break;
            };
            default : {
                return(-1);
            };
        };

        /* Creation du Data Set "IN1", "IN2", "IN3" contenant la taille du bodyfitted sur cette dimension */
        if (_MEDdatasetNumEcrire(noeid, ds, MED_INTEGER, mode_coo, MED_DIM1, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)&nbr[d], mode) < 0) {
            return(-1);
        };

        /* On re-ouvre ce Data Set pour y placer des attributs */
        if ((dataset = _MEDdatasetOuvrir(noeid, ds)) < 0) {
            return(-1);
        };

        /* Attribut NBR (nombre de noeuds dans l'une des dimensions) */
        if (_MEDattrEntierEcrire(dataset, MED_NOM_NBR, &nbr[d], mode) < 0) {
            return(-1);
        };

        if (_MEDdatasetFermer(dataset) < 0) return(-1);
    };

    /* Ecriture des numeros de familles */
    if (MEDfamEcr(fid, maa, fam, nnoeuds, mode, MED_NOEUD, MED_POINT1) < 0) {
        return(-1);
    };

    /* On ferme tout */
    if (_MEDdatagroupFermer(noeid) < 0) return(-1);
    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
    return(0);
}

Here is the call graph for this function:

med_err med_2_1::MEDbodyFittedLire ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coo,
med_mode_switch  mode_coo,
med_repere *  repere,
char *  nomcoo,
char *  unicoo,
med_int *  fam,
med_int  nnoeuds 
)

Definition at line 27 of file MEDbodyFittedLire.cxx.

{
    med_idt maaid, noeid, dataset;
    char    chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
    med_int type_rep_int;

    /* On inhibe le gestionnaire d'erreur */
    _MEDmodeErreurVerrouiller();

    /* Si le maillage n'existe pas => erreur */
    strcpy(chemin, MED_MAA);
    strcat(chemin, maa);
    maaid = _MEDdatagroupOuvrir(fid, chemin);
    if (maaid < 0) return(-1);

    /* Si le Data Group "NOE" n'existe pas => erreur */
    noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
    if (noeid < 0) return(-1);

    /* Lecture du Data Set "BOF" */
    if (_MEDdatasetNumLire(noeid, MED_NOM_BOF, MED_REEL64, mode_coo, mdim, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) {
        return(-1);
    };

    /* On re-ouvre le Data Set "BOF" pour y lire des attributs */
    dataset = _MEDdatasetOuvrir(noeid, MED_NOM_BOF);
    if (dataset < 0) return(-1);

    /* L'attribut "REP" */
    if (_MEDattrEntierLire(dataset, MED_NOM_REP, &type_rep_int) < 0) {
        return(-1);
    } else {
        *repere = (med_repere)type_rep_int;
    };

    /* Attribut "NOM" */
    if (_MEDattrStringLire(dataset, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) {
        return(-1);
    };

    /* Attribut "UNI" */
    if (_MEDattrStringLire(dataset, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) {
        return(-1);
    };

    /* lecture des numeros de familles */
    if (MEDfamLire(fid, maa, fam, nnoeuds, MED_NOEUD, MED_POINT1) < 0) {
        return(-1);
    };

    /* On ferme tout */
    if (_MEDdatasetFermer(dataset) < 0) {
        return(-1);
    };
    if (_MEDdatagroupFermer(noeid) < 0) {
        return(-1);
    };
    if (_MEDdatagroupFermer(maaid) < 0) {
        return(-1);
    };
    return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDchampCr ( med_idt  fid,
char *  champ,
med_type_champ  type,
char *  comp,
char *  unit,
med_int  ncomp 
)

Definition at line 28 of file MEDchampCr.cxx.

{
  med_err ret = 0;
  med_idt root,gid;
  char chemin[MED_TAILLE_CHA+1];
  med_int _type = (med_int) type;
  
  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * 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)
      return -1;  

  /* 
   * Si le Data Group cha n'existe pas, on le cree
   * Sinon => erreur
   */
  if ((gid = _MEDdatagroupOuvrir(root,champ)) >= 0)
    return -1;
  if ((gid = _MEDdatagroupCreer(root,champ)) < 0)
    return -1;

  /*
   * Les infos sur les composants du champ
   */
  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_NCO,&ncomp,MED_REMP)) < 0)
    return -1;
  if ((ret = _MEDattrEntierEcrire(gid,MED_NOM_TYP,&_type,MED_REMP)) < 0)
    return -1;
  if ((ret = _MEDattrStringEcrire(gid,MED_NOM_NOM,MED_TAILLE_PNOM*ncomp,comp,MED_REMP)) < 0)
    return -1;
  if ((ret = _MEDattrStringEcrire(gid,MED_NOM_UNI,MED_TAILLE_PNOM*ncomp,unit,MED_REMP)) < 0)
    return -1;

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatagroupFermer(gid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;
  
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDchampEcr ( med_idt  fid,
char *  maa,
char *  cha,
unsigned char *  val,
med_mode_switch  interlace,
med_int  nbelem,
med_int  ngauss,
med_int  numco,
char *  profil,
med_mode_acces  mode,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
med_int  numdt,
char *  dt_unit,
med_float  dt,
med_int  numo 
)

Definition at line 52 of file MEDchampEcr.cxx.

{
  med_err ret;
  med_idt chid,datagroup1,datagroup2;
  med_int ncomp, chtype, i, locnumdt,pfluse;
  char pflname [MED_TAILLE_NOM+1];
  char maillage[MED_TAILLE_NOM+1];
  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
  char tmp1[MED_TAILLE_NOM_ENTITE+1];
  med_size dimd[1],psize;
  med_int   *pfltabtmp=0;
  med_ssize *pfltab=0;
  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
  
  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

 
  /* 
   * Si le Data Group cha n'existe pas => erreur
   */
  strcpy(chemin,MED_CHA);
  strcat(chemin,cha);
  if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /* 
   *  Creation du datagroup de niveau 1 <type_ent>[.<type_geo>] 
   */
  
  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
    return -1;
  if ((type_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
        return -1;
      strcat(nomdatagroup1,".");
      strcat(nomdatagroup1,tmp1);
    }
  datagroup1 = 0;
  if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0) 
    if ((datagroup1 = _MEDdatagroupCreer(chid,nomdatagroup1)) < 0)
      return -1;
  
  /* Creation du datagroup de niveau 2 <numdt>.<numoo> */
  if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt;
  sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo);

  
  /*Cree ou ouvre (en mode MED_REMP) le datagroup nomdatagroup2 */
  datagroup2 = 0;   
  if (((datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) > 0)    
      && (mode != MED_REMP))   
    return -1;   
  else   
    if (datagroup2 < 0)
      if ((datagroup2 = _MEDdatagroupCreer(datagroup1,nomdatagroup2)) < 0)   
        return -1;   
  
  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NDT */
  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NDT,&numdt,mode)) < 0)
    return -1;
  
  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PDT */
  if ((ret = _MEDattrFloatEcrire(datagroup2,MED_NOM_PDT,&dt,mode)) < 0)
    return -1;
    
  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NOR */
  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NOR,&numo,mode)) < 0)
    return -1;
  
  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NBR */
  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NBR,&nbelem,mode)) < 0)
    return -1;

  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_MAA   */
  /* rem : Aucune verification de l'existence du maillage */
  strncpy(maillage,maa,MED_TAILLE_NOM);
  maillage[MED_TAILLE_NOM]='\0';
  if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maillage,mode)) < 0)
    return -1;
  
  /*Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_PFL   */ 
  pfluse = 0;
  if ( strlen(profil) == 0)   /* idem MED_NOPFL*/
    strncpy(pflname,MED_NOPFLi,MED_TAILLE_NOM+1);
  else {
    strncpy(pflname,profil,MED_TAILLE_NOM);
    pflname[MED_TAILLE_NOM]='\0';
    pfluse = 1;
  }
  if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pflname,mode)) < 0)
    return -1; 

  /*Cree ou ouvre (en mode MED_REMP) l'attribut  MED_NOM_UNI */ 
  if ( strlen(dt_unit) == 0) {
    if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM,(char*)"        ",mode)) < 0)
      return -1;
  } else
    if ((ret = _MEDattrStringEcrire(datagroup2,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit,mode)) < 0)
      return -1;
  

  /* Cree ou ouvre (en mode MED_REMP) l'attribut MED_NOM_NGAU             */ 
  /* Ecriture du nombre de pts de gauss propre au <type_ent>[.<type_geo>] */
  /* On n'utilise pas ngauss=MED_NOPG mais ngauss=1 si aucun pt de gauss  */
  if ((ret = _MEDattrEntierEcrire(datagroup2,MED_NOM_NGA,&ngauss,mode)) < 0)
    return -1;

  /*Lecture de l'attribut MED_NOM_NCO */
  if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0)
    return -1;
 
  /*Determination de la taille dimd[0] du dataset à stocker*/
  dimd[0] = nbelem*ncomp;

  /* Gestion des profils*/
  if ( pfluse ) {
   
    if ( ( i = MEDnValProfil(fid,pflname) ) < 0 )
      return -1;
    else
      psize = i;
    
    pfltabtmp = (med_int *)   malloc (sizeof(med_int)*(size_t)psize);
    pfltab    = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)psize);
    if ((ret = MEDprofilLire(fid,pfltabtmp,pflname)) < 0)
      return -1;
    for (i=0;i<psize;i++)
      pfltab[i] = (med_ssize) pfltabtmp[i];
    
  }
  else
    psize = MED_NOPF;
  
  
  /*
   * Ecriture du champ
   */
  if ((ret = _MEDattrEntierLire(chid,MED_NOM_TYP,&chtype)) < 0)
    return -1;
  switch(chtype)
    {
    case MED_REEL64 :
      if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_REEL64,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
                                       mode)) < 0)
        return -1;
      break;

    case MED_INT32 :
#if defined(HAVE_F77INT64)
     if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_INT64,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
                                       mode)) < 0)
        return -1;
#else
      if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_INT32,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
                                       mode)) < 0)
        return -1;
#endif
      break;

    case MED_INT64 :
#if defined(HAVE_F77INT64)
     if ((ret =  _MEDdatasetNumEcrire(datagroup2,MED_NOM_CO,MED_INT64,interlace,ncomp,numco,psize,pfltab,ngauss,dimd,val,
                                       mode)) < 0)
        return -1;
#else
     return -1;
#endif
     break;   

    default :
      return -1;
    }

  /*
   * On ferme tout 
   */
  if ( pfluse ) { free(pfltab); free(pfltabtmp);}

  if ((ret = _MEDdatagroupFermer(datagroup2)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(datagroup1)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(chid)) < 0)
    return -1;
  
  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDchampInfo ( med_idt  fid,
int  indice,
char *  champ,
med_type_champ *  type,
char *  comp,
char *  unit,
med_int  ncomp 
)

Definition at line 27 of file MEDchampInfo.cxx.

{
  med_err ret=0;
  med_idt gid;
  char chemin[MED_TAILLE_CHA+MED_TAILLE_LNOM+1]; //SRN: Changed to MED_TAILLE_LNOM to avoid a crash 
                                                 //     in case if a field name longer than MED_TAILLE_NOM
  int num;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On recupere le nom du champ
   */
  num = indice - 1;
  strcpy(chemin,MED_CHA);
  if ((ret = _MEDobjetIdentifier(fid,chemin,num,champ)) < 0)
    return -1;

  if(strlen(champ) > MED_TAILLE_NOM) return -1;

  /* 
   * Si le Data Group cha n'existe pas => erreur
   */
  strcat(chemin,champ);
  if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;


  /*
   * La liste des attributs
   */

  // MPV 05.10.2006
  // BUG IPAL 13482: on 64bit Mandriva OS sizeof(med_int)=8, but sizeof(med_type_champ)=4
  med_int aType;
  //  if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,(med_int*) type)) < 0)
  if ((ret = _MEDattrEntierLire(gid,MED_NOM_TYP,&aType)) < 0)
    return -1;
  *type = (med_type_champ)aType;
  
  if ((ret = _MEDattrStringLire(gid,MED_NOM_NOM,ncomp*MED_TAILLE_PNOM,
                                comp)) < 0)
    return -1;
  if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,ncomp*MED_TAILLE_PNOM,
                                unit)) < 0)
    return -1;

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatagroupFermer(gid)) < 0)
    return -1; 

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDchampLire ( med_idt  fid,
char *  maa,
char *  cha,
unsigned char *  val,
med_mode_switch  interlace,
med_int  numco,
char *  profil,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
med_int  numdt,
med_int  numo 
)

Definition at line 30 of file MEDchampLire.cxx.

{
  med_err ret;
  med_idt chid, datagroup1, datagroup2;
  med_int ncomp, chtype, ngauss, i, locnumdt, pfluse;
  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
  char tmp1[MED_TAILLE_NOM_ENTITE+1], pfltmp[MED_TAILLE_NOM+1];
  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];
  med_size   psize;
  med_int   *pfltabtmp=0;
  med_ssize *pfltab=0;
  char maatmp[MED_TAILLE_NOM+1];
  
  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * Si le Data Group cha n'existe pas => erreur
   */
  strcpy(chemin,MED_CHA);
  strcat(chemin,cha);
  if ((chid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

 /* 
   * Si le Data Group  de niveau 1 <type_ent>[.<type_geo>] n'existe pas => erreur
   */
  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
    return -1;
  if ((type_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
        return -1;
      strcat(nomdatagroup1,".");
      strcat(nomdatagroup1,tmp1);
    }
  datagroup1 = 0;
  if ( (datagroup1 = _MEDdatagroupOuvrir(chid,nomdatagroup1)) < 0 )
    return -1;

  /*
   * Si le Data Group de niveau 2 <numdtt>.<numoo> n'existe pas => erreur
   */
  if ( numdt == MED_NOPDT) locnumdt = MED_NOPDT; else locnumdt = numdt;
  sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) locnumdt,MED_MAX_PARA,(long ) numo);
  
  datagroup2 = 0;   
  if ( (datagroup2 = _MEDdatagroupOuvrir(datagroup1,nomdatagroup2)) < 0)    
    return -1;   

  /* Lecture du nbre de composantes du champ */

  if ((ret = _MEDattrEntierLire(chid,MED_NOM_NCO,&ncomp)) < 0)
    return -1;
  
  /* Gestion des profils*/

  /*
   * Lire le profil demandé
   */

  if ((ret = _MEDattrStringLire(datagroup2,MED_NOM_PFL,MED_TAILLE_NOM,pfltmp)) < 0)
    return -1;
  
  if ( (pfluse = (strcmp(pfltmp,MED_NOPFLi) && strcmp(pfltmp,""))) ) /* le test "" pour des raisons de compatibilité */
    {
      strcpy(profil,pfltmp);
      if ( (i = MEDnValProfil(fid,profil)) < 0 )
        return -1;
      else
        psize = i;

      pfltabtmp = (med_int *)   malloc (sizeof(med_int)*(size_t)psize);
      pfltab = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)psize);
      if ((ret = MEDprofilLire(fid,pfltabtmp,profil)) < 0)
        return -1;
      for (i=0;i<psize;i++)
        pfltab[i] = (med_ssize) pfltabtmp[i];
       
    }
  else {
    psize = MED_NOPF;
    strcpy(profil,MED_NOPFL);
  }
  
  /*
   * Lire le nom de maillage associé au champ
   */
  if ((ret = _MEDattrStringLire(datagroup2,MED_NOM_MAI,MED_TAILLE_NOM,maatmp)) < 0)
    return -1;

  if (strcmp(maa,maatmp)) 
    return -1;
  
  /* Lit le nbre de points de Gauss  */ 
  /* (attribut MED_NOM_NGAU) propre au <type_ent>[.<type_geo>] pour simplifier la relecture */
  if ( (ret = _MEDattrEntierLire(datagroup2,MED_NOM_NGA,&ngauss)) < 0 )
    return -1;

  /*
   * Lecture du champ
   */

  if ((ret = _MEDattrEntierLire(chid,MED_NOM_TYP,&chtype)) < 0)
    return -1;

  switch(chtype)
    {
    case MED_REEL64 :
      if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_REEL64,
                                     interlace,ncomp,numco,
                                     psize,pfltab,ngauss,val))< 0)
        return -1;
      break;
      
    case MED_INT32 :
#if defined(HAVE_F77INT64) 
     if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64,
                                     interlace,ncomp,numco,
                                     psize,pfltab,ngauss,val))< 0)
        return -1;
#else
     if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT32,
                                     interlace,ncomp,numco,
                                     psize, pfltab,ngauss,val))< 0)
        return -1;
#endif
     break;

    case MED_INT64 :
#if defined(HAVE_F77INT64) 
     if ((ret =  _MEDdatasetNumLire(datagroup2,MED_NOM_CO,MED_INT64,
                                     interlace,ncomp,numco,
                                     psize,pfltab,ngauss,val))< 0)
        return -1;
#else
     return -1;
#endif
      break;      

    default :
      return -1;
    }

  /*
   * On ferme tout 
   */
  if ( pfluse ) { free(pfltab); free(pfltabtmp);}

  if ((ret = _MEDdatagroupFermer(datagroup2)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(datagroup1)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(chid)) < 0)
    return -1;
    
  return 0;     
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDconnEcr ( med_idt  fid,
char *  maa,
med_int  mdim,
med_int *  connectivite,
med_mode_switch  mode_switch,
med_int  nbre,
med_mode_acces  mode,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
med_connectivite  type_conn 
)

Definition at line 30 of file MEDconnEcr.cxx.

{
  med_idt maaid, entid, geoid, dataset;
  med_err ret;
  med_size dimd[1];
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
  char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
  int dim, nnoe, ndes;
  int nsup = 0;
  int taille;
  
  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;
   /*
    * Si le Data Group des entites n'existe pas on le cree
    */
   /*EF Gerer le mode */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
       return -1;

   /*
    * On cree s'il n'existe pas le Data Group du type geometrique
    */
   /*EF Gerer le mode */
  if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
     return -1;
   if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
     if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
       return -1;

   /*
    * On regarde si le Data Set existe et on le cree sinon
    */
   if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0)
     return -1;
   if (mdim == 2 || mdim == 3)
     if (type_ent == MED_MAILLE && dim == 1)
       nsup = 1;
   if (mdim == 3)
     if (type_ent == MED_MAILLE && dim == 2)
       nsup = 1;
   switch(type_conn)
     {
     case MED_NOD :
       strcpy(nom_dataset,MED_NOM_NOD);
       taille = nsup + nnoe;
       break;

     case MED_DESC :
       strcpy(nom_dataset,MED_NOM_DES);
       taille = nsup + ndes;
       break;
       
     default :
       return -1;
     }
   dimd[0] = nbre*taille;
#if defined(HAVE_F77INT64)
   if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT64,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                    (unsigned char*) connectivite,mode)) < 0)
     return -1;
#else
   if ((ret = _MEDdatasetNumEcrire(geoid,nom_dataset,MED_INT32,mode_switch,(med_size)taille,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                    (unsigned char*) connectivite,mode)) < 0)
     return -1;
#endif

  /*
   * Attribut NBR (nombre de noeuds ou d'elements)
   */
   if ((dataset = _MEDdatasetOuvrir(geoid,nom_dataset)) < 0)
     return -1;
   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&nbre,mode)) < 0)
     return -1;

   /*
    * On ferme tout 
    */
   if ((ret = _MEDdatasetFermer(dataset)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(geoid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDconnLire ( med_idt  fid,
char *  maa,
med_int  mdim,
med_int *  connectivite,
med_mode_switch  mode_switch,
med_int *  pfltab,
med_size  psize,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
med_connectivite  type_conn 
)

Definition at line 30 of file MEDconnLire.cxx.

{
  med_idt maaid,entid,geoid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
  char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
  med_ssize * pfltab = NULL;
  med_size    psize;
  int dim,nnoe,ndes;
  int nsup = 0;
  int taille;  
  int i;
  
  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();
  
  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;
   /*
    * Si le Data Group des entites n'existe pas => erreur
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     return -1;

   /*
    * si le Data Group du type geometrique n'existe pas => erreur
    */
   if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
     return -1;
   if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
     return -1;

   /*
    * Si le Data Set de la connectivite n'existe pas => erreur
    * Si oui => on le lit
    */
   if ((ret=_MEDparametresGeometrie(type_ent,type_geo,&dim,&nnoe,&ndes))<0)
     return -1;
   if (mdim == 2 || mdim == 3)
     if (type_ent == MED_MAILLE && dim == 1)
       nsup = 1;
   if (mdim == 3)
     if (type_ent == MED_MAILLE && dim == 2)
       nsup = 1;


   psize = psizetmp;
   switch(type_conn)
     {
     case MED_NOD :
       strcpy(nom_dataset,MED_NOM_NOD);
       taille = nsup + nnoe;
       break;

     case MED_DESC :
       strcpy(nom_dataset,MED_NOM_DES);
       taille = nsup + ndes;
       if ( psizetmp != MED_NOPF ) {  
         psize = psizetmp;
         pfltab = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)psize);
         for (i=0;i<psizetmp;i++)
           pfltab[i] = (med_ssize) (pfltabtmp[i]);
       };
       
       break;
       
     default :
       return -1;
     }


#if defined(HAVE_F77INT64)
   if ((ret = _MEDdatasetNumLire(geoid,nom_dataset,MED_INT64,
                                 mode_switch,(med_size)taille,MED_ALL,
                                 psize,pfltab,MED_NOPG,
                                 (unsigned char*) connectivite)) < 0)
     return -1;
#else
   if ((ret = _MEDdatasetNumLire(geoid,nom_dataset,MED_INT32,
                                 mode_switch,(med_size) taille,MED_ALL,
                                 psize,pfltab,MED_NOPG,
                                 (unsigned char*) connectivite)) < 0)
     return -1;
#endif 

   /*
    * On ferme tout 
    */

   if ( (psize != MED_NOPF) && (type_conn == MED_DESC) ) free(pfltab);
  
   if ((ret = _MEDdatagroupFermer(geoid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1;

   return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDcoordEcr ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coo,
med_mode_switch  mode_coo,
med_int  n,
med_mode_acces  mode,
med_repere  type_rep,
char *  nom,
char *  unit 
)

Definition at line 28 of file MEDcoordEcr.cxx.

{
  med_idt maaid, noeid, dataset;
  med_err ret;
  med_size dimd[1];
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_int type_rep_int; 
  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Si le Data Group "NOE" n'existe pas
   * on le cree
   */
  /* EF : A faire : gerer le mode MED_REMP*/
  if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
    if ((noeid = _MEDdatagroupCreer(maaid,MED_NOM_NOE)) < 0)
      return -1;

  /*
   * Creation du Data Set "COO"
   */
  dimd[0] = n*mdim;
  if ((ret = _MEDdatasetNumEcrire(noeid,MED_NOM_COO,MED_REEL64,mode_coo,mdim,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                  (unsigned char*) coo,mode)) < 0)
    return -1;
  
  /*
   * On re-ouvre le Data Set "COO" pour y placer des attributs
   */
  if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0)
    return -1;

  /*
   * Attribut NBR (nombre de noeuds)
   */
  if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
    return -1;

  /*
   * L'attribut "REP"
   */
  type_rep_int = (med_int) type_rep; 
  if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_REP,&type_rep_int,mode)) < 0)
    return -1;

  /*
   * Attribut "NOM"
   */
  if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,nom,mode)) < 0)
    return -1;

  /*
   * Attribut "UNI"
   */
  if ((ret = _MEDattrStringEcrire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,unit,mode)) < 0)
    return -1;

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatasetFermer(dataset)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(noeid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDcoordLire ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coo,
med_mode_switch  mode_coo,
med_int  numco,
med_int *  pfltab,
med_size  psize,
med_repere *  type_rep,
char *  nom,
char *  unit 
)

Definition at line 30 of file MEDcoordLire.cxx.

{
  med_idt   maaid, noeid, dataset;
  med_err   ret;
  char      chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  int       i;
  med_int   type_rep_int;
  med_ssize * pfltab = NULL;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   * Sinon on recupere sa dimension au passage
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Si le Data Group "NOE" n'existe pas => erreur
   */
  if ((noeid = _MEDdatagroupOuvrir(maaid,MED_NOM_NOE)) < 0)
      return -1;

  /*
   * Convertion de med_int en med_ssize
   */
  if ( psize != MED_NOPF ) {  
    pfltab = (med_ssize *) malloc (sizeof(med_ssize)*(size_t)psize);
    for (i=0;i<psize;i++)
      pfltab[i] = (med_ssize) pfltabtmp[i];
  }

  /*
   * Lecture du Data Set "COO"
   */
  if ((ret = _MEDdatasetNumLire(noeid,MED_NOM_COO,MED_REEL64,
                                mode_coo,mdim,numco,
                                psize,pfltab,MED_NOPG,
                                (unsigned char*) coo)) < 0)
    return -1;

  

  /*
   * On re-ouvre le Data Set "COO" pour y lire des attributs
   */
  if ((dataset = _MEDdatasetOuvrir(noeid,MED_NOM_COO)) < 0)
    return -1;

  /*
   * L'attribut "REP"
   */
  if ((ret = _MEDattrEntierLire(dataset,MED_NOM_REP,&type_rep_int)) < 0)
    return -1;
  else
    *type_rep = (med_repere) type_rep_int;

  /*
   * Attribut "NOM"
   */
  if ((ret = _MEDattrStringLire(dataset,MED_NOM_NOM,mdim*MED_TAILLE_PNOM,
                                nom)) < 0)
    return -1;

  /*
   * Attribut "UNI"
   */
  if ((ret = _MEDattrStringLire(dataset,MED_NOM_UNI,mdim*MED_TAILLE_PNOM,
                                unit)) < 0)
    return -1;

  /*
   * On ferme tout
   */
  if ( psize != MED_NOPF ) free(pfltab); 
  
  if ((ret = _MEDdatasetFermer(dataset)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(noeid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDdimLire ( med_idt  fid,
char *  maillage 
)

Definition at line 27 of file MEDdimLire.cxx.

{
  med_idt maaid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_int dim;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On regarde si le groupe existe => erreur si non 
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maillage);  
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On va lire l'attribut dimension
   */
  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,&dim)) < 0)
    return -1;

  /*
   * Fermetures des objets HDF 
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return dim;
}

Here is the call graph for this function:

med_err med_2_1::MEDelementsEcr ( med_idt  fid,
char *  maa,
med_int  mdim,
med_int *  connectivite,
med_mode_switch  mode_switch,
char *  nom,
med_booleen  inom,
med_int *  num,
med_booleen  inum,
med_int *  fam,
med_int  nele,
med_entite_maillage  typ_ent,
med_geometrie_element  typ_geo,
med_connectivite  typ_conn,
med_mode_acces  mode 
)

Definition at line 24 of file MEDelementsEcr.cxx.

{
  med_err ret;

  /* Ecriture de la connectivite */
  if ((ret = MEDconnEcr(fid,maa,mdim,connectivite,mode_switch,nele,mode,typ_ent,typ_geo,
                        typ_conn)) < 0)
    return -1;

  /* Ecriture des noms */
  if (inom == MED_VRAI)
    if ((ret = MEDnomEcr(fid,maa,nom,nele,mode,typ_ent,typ_geo)) < 0)
      return -1;

  /* Ecriture des numeros */
  if (inum == MED_VRAI)
    if ((ret = MEDnumEcr(fid,maa,num,nele,mode,typ_ent,typ_geo)) < 0)
      return -1;

  /* Ecriture des numeros de familles */
  if ((ret = MEDfamEcr(fid,maa,fam,nele,mode,typ_ent,typ_geo)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDelementsLire ( med_idt  fid,
char *  maa,
med_int  mdim,
med_int *  connectivite,
med_mode_switch  mode_switch,
char *  nom,
med_booleen *  inom,
med_int *  num,
med_booleen *  inum,
med_int *  fam,
med_int  nele,
med_entite_maillage  typ_ent,
med_geometrie_element  typ_geo,
med_connectivite  typ_conn 
)

Definition at line 24 of file MEDelementsLire.cxx.

{
  med_err ret;

  /* Lecure de la connectivite */
  if ((ret = MEDconnLire(fid,maa,mdim,connectivite,mode_switch,0,MED_NOPF,
                         typ_ent,typ_geo,typ_conn)) < 0)
    return -1;

  /* Lecture des noms */
  if ((ret = MEDnomLire(fid,maa,nom,nele,typ_ent,typ_geo)) < 0)
    *inom = MED_FAUX;
  else
    *inom = MED_VRAI;

  /* Lecture des numeros */
  if ((ret = MEDnumLire(fid,maa,num,nele,typ_ent,typ_geo)) < 0)
    *inum = MED_FAUX;
  else
    *inum = MED_VRAI;

  /* Lecture des numeros de familles */
  if ((ret = MEDfamLire(fid,maa,fam,nele,typ_ent,typ_geo)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDequivCr ( med_idt  fid,
char *  maa,
char *  eq,
char *  desc 
)

Definition at line 28 of file MEDequivCr.cxx.

{
  med_idt root,eqid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+MED_TAILLE_NOM+1];
  char tmp[MED_TAILLE_EQS+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * Si le Data Group "EQS" n'existe pas, on le cree
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strncpy(tmp,MED_EQS,MED_TAILLE_EQS-1);
  tmp[MED_TAILLE_EQS-1] = '\0';
  strcat(chemin,tmp);
  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
      return -1;

  /*
   * Si une equivalence du meme nom existe => erreur
   * Sinon on la cree
   */
  if ((eqid = _MEDdatagroupOuvrir(root,eq)) >= 0)
    return -1;
  if ((eqid = _MEDdatagroupCreer(root,eq)) < 0)
    return -1;

  /*
   * L'attribut "DES"
   */
  if ((ret = _MEDattrStringEcrire(eqid,MED_NOM_DES,MED_TAILLE_DESC,desc,MED_REMP)) < 0)
    return -1;

  /*
   * On ferme tout 
   */
  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;

  return 0 ; 
}

Here is the call graph for this function:

med_err med_2_1::MEDequivEcr ( med_idt  fid,
char *  maa,
char *  eq,
med_int *  corr,
med_int  n,
med_mode_acces  mode,
med_entite_maillage  typ_ent,
med_geometrie_element  typ_geo 
)

Definition at line 30 of file MEDequivEcr.cxx.

{
  med_idt eqid, datagroup;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; 
  char nomdatagroup[MED_TAILLE_NOM+1];
  char tmp[MED_TAILLE_NOM_ENTITE+1];
  med_size dimd[1];

  if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 ||
      typ_geo == MED_HEXA8  || typ_geo == MED_HEXA20  ||
      typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 ||
      typ_geo == MED_PYRA5  || typ_geo == MED_PYRA13)
    return -1;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * Si le Data Group de "eq" n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_EQS);
  strcat(chemin,eq);
  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;  

  /*
   * Ecriture de l'equivalence
   */
  if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0)
    return -1;
  if ((typ_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0)
        return -1;
      strcat(nomdatagroup,".");
      strcat(nomdatagroup,tmp);
    }
  datagroup = 0;
  if (((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) > 0) && 
      (mode != MED_REMP))
    return -1;
  else
    if (datagroup > 0)
      _MEDdatagroupFermer(datagroup);

  /* EF : verifier que çà marche si le data groupe existe déjà */
  if ((datagroup = _MEDdatagroupCreer(eqid,nomdatagroup)) < 0)
    return -1;

  if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n,mode)) < 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,0,MED_NOPG,dimd,
                                (unsigned char*) corr,mode)) < 0)
    return -1;
#else
  if ((ret =  _MEDdatasetNumEcrire(datagroup,MED_NOM_COR,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*) corr,mode)) < 0)
    return -1;
#endif

  /*
   * On ferme tout 
   */
  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
    return -1;

  return 0; 
}

Here is the call graph for this function:

med_err med_2_1::MEDequivInfo ( int  fid,
char *  maa,
int  ind,
char *  eq,
char *  des 
)

Definition at line 28 of file MEDequivInfo.cxx.

{
  med_idt eqid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1];
  int num;
  int idx;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On recupere le nom de l'equivalence
   */
  num = ind - 1;
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_EQS); 
  if ((idx = _MEDobjetIdentifier(fid,chemin,num,eq)) < 0)
    return -1;

  /* 
   * Si le Data Group eq n'existe pas => erreur
   */
  strcat(chemin,eq);
  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * L'attribut "DES"
   */
  if ((ret = _MEDattrStringLire(eqid,MED_NOM_DES,MED_TAILLE_DESC,des)) < 0)
    return -1;

  /*
   * On ferme tout 
   */
  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

MEDWRAPPER_V2_1_CORE_EXPORT med_err med_2_1::MEDequivInfo ( med_idt  fid,
char *  maa,
int  ind,
char *  eq,
char *  des 
)

Here is the caller graph for this function:

med_err med_2_1::MEDequivLire ( med_idt  fid,
char *  maa,
char *  eq,
med_int *  corr,
med_int  n,
med_entite_maillage  typ_ent,
med_geometrie_element  typ_geo 
)

Definition at line 30 of file MEDequivLire.cxx.

{
  med_idt eqid, datagroup;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; 
  char nomdatagroup[MED_TAILLE_NOM+1];
  char tmp[MED_TAILLE_NOM_ENTITE+1];

  if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 ||
      typ_geo == MED_HEXA8  || typ_geo == MED_HEXA20  ||
      typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 ||
      typ_geo == MED_PYRA5  || typ_geo == MED_PYRA13)
    return -1;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * Si le Data Group de "eq" n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_EQS);
  strcat(chemin,eq);
  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;  

  /*
   * Lecture de l'equivalence
   */
  if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0)
    return -1;
  if ((typ_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0)
        return -1;
      strcat(nomdatagroup,".");
      strcat(nomdatagroup,tmp);
    }
  if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0)
    return -1;
#if defined(HAVE_F77INT64)
  if ((ret =  _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT64,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char *) corr)) < 0)
    return -1;
#else
  if ((ret =  _MEDdatasetNumLire(datagroup,MED_NOM_COR,MED_INT32,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char *) corr)) < 0)
    return -1;
#endif

  /*
   * On ferme tout 
   */
  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
    return -1;

  return 0;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfam2groA ( med_int  nfam,
med_int *  numfam,
med_int *  numfamnoe,
med_int  nnoeuds,
med_int *  numfamele,
med_int  nelements,
char *  grofam,
int *  indfamgro,
med_int *  ngn,
med_int *  nge,
med_int *  nindn,
med_int *  ninde 
)

Definition at line 80 of file MEDfam2groA.cxx.

{
  int i,j,k;
  char groupe[MED_TAILLE_LNOM];
  char *nomgronoe,*nomgroele,*tmp;
  med_int numc;
  int nnoe = 0,nele = 0;
  int flag = 0;

  *ngn = 0;
  *nge = 0;
  *nindn = 0;
  *ninde = 0;
  
  tmp = NULL;
  nomgronoe = NULL;
  nomgroele = NULL;

  /* Pour chaque famille, on regarde s'il y a de nouveaux groupes
     de noeuds ou d'elements a creer. Pour chaque nouveau groupe,
     on compte le nombre de noeuds ou d'elements qui devront lui etre
     rataches */
  for (i=1;i<=nfam;i++)
    if ((*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM > 0) 
      {
        /* on releve le numero de la famille courante */
        numc = *(numfam+i-1);
        nnoe = 0;
        nele = 0;
        /* si c'est une famille de noeuds, on compte le nombre de
           noeuds qui y sont rattaches */
        if (numc > 0)
          for (j=0;j<nnoeuds;j++)
            if (*(numfamnoe+j) == numc)
              nnoe++;
        /* si c'est une famille d'elements, on compte le nombre d'elements
           qui y sont rattaches */
        if (numc < 0)
          for (j=0;j<nelements;j++)
            if (*(numfamele+j) == numc)
              nele++;     
        /* on parcourt la liste des groupes de la famille et pour chaque
           groupe :
           1 - on met a jour les compteurs nindn et ninde ;
           2 - on verifie s'il s'agit d'un groupe deja repertorie.
               Si c'est le cas on ne fait rien, sinon on met a jour les
               compteurs ngn ou nge */
        for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM;j++)
          {
            strncpy(groupe,grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
                    MED_TAILLE_LNOM);
            if (numc > 0)
              {
                *nindn = *nindn+nnoe;
                if (*ngn == 0)
                  {
                    *ngn = 1;
                    if ((nomgronoe=(char*)malloc(sizeof(char)*MED_TAILLE_LNOM))
                         == NULL)
                      return -1;
                    strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
                  }
                else
                  { 
                    flag = 0;
                    for (k=0;k<(*ngn);k++)
                      if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
                                  MED_TAILLE_LNOM) == 0)
                        flag = 1;
                    if (flag == 0)
                      { 
                        *ngn = *ngn + 1;
                        if ((tmp=(char*)malloc(sizeof(char)*
                                               MED_TAILLE_LNOM**ngn)) == NULL)
                          return -1;
                        strncpy(tmp,nomgronoe,MED_TAILLE_LNOM*(*ngn-1));
                        strncpy(tmp+MED_TAILLE_LNOM*(*ngn-1),groupe, 
                                MED_TAILLE_LNOM);
                        free(nomgronoe); 
                        nomgronoe = tmp;
                      }
                  } 
              } 
            if (numc < 0)
              {
                *ninde = *ninde+nele;
                if (*nge == 0)
                  {
                    *nge = 1;
                    if ((nomgroele=(char *)malloc(sizeof(char)*
                                                  MED_TAILLE_LNOM)) == NULL)
                      return -1;
                    strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
                  }
                else
                  { 
                    flag = 0;
                    for (k=0;k<(*nge);k++)
                      if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM, 
                                  MED_TAILLE_LNOM) == 0)
                        flag = 1;
                    if (flag == 0)
                      {
                        *nge = *nge + 1;
                        if ((tmp = (char*) malloc(sizeof(char)*MED_TAILLE_LNOM*
                                                  *nge)) == NULL)
                          return -1;
                        strncpy(tmp,nomgroele,MED_TAILLE_LNOM*(*nge-1));
                        strncpy(tmp+MED_TAILLE_LNOM*(*nge-1), groupe, 
                                MED_TAILLE_LNOM);
                        free(nomgroele);
                        nomgroele = tmp;
                      }
                  }
              } 
          } 
      }

  /* nettoyage memoire */
  free(nomgronoe);
  free(nomgroele);
  
  return 0;
}
med_err med_2_1::MEDfam2groB ( med_int  nfam,
med_int *  numfam,
med_int *  numfamnoe,
med_int  nnoeuds,
med_int *  numfamele,
med_int  nelements,
char *  grofam,
int *  indfamgro,
med_int *  numnoeuds,
med_int *  numele,
med_int  ngn,
med_int  nge,
med_int  nindn,
med_int  ninde,
char *  nomgronoe,
char *  nomgroele,
int *  indgronoe,
int *  indgroele,
med_int *  tabgronoe,
med_int *  tabgroele 
)

Definition at line 78 of file MEDfam2groB.cxx.

{
  int i,j,k;
  char groupe[MED_TAILLE_LNOM];
  med_int numc;
  int nnoe = 0, nele = 0;
  int flag = 0;
  int nn = 0, ne = 0;
  int pos, cpt;

  /* initialisations */
  for (i=0;i<=ngn;i++)
    *(indgronoe+i) = 0;
  for (i=0;i<=nge;i++)
    *(indgroele+i) = 0;

  /* 1ere passe : on passe en revue toutes les familles :
     1 - on etablit dans (nomgronoe) et dans (nomgroele) les listes 
     des noms de groupes de noeuds et d'elements
     2 - on place dans les tables d'index (indgronoe) et (indgroele)
     le nombre de noeuds ou d'elements que chaque groupe se verra 
     attribuer */
  for (i=1;i<=nfam;i++)
      {
        numc = *(numfam+i-1);
        nnoe = 0;
        nele = 0;
        if (numc > 0)
            for (j=0;j<nnoeuds;j++)
              if (*(numfamnoe+j) == numc)
                nnoe++;
        if (numc < 0)
          for (j=0;j<nelements;j++)
            if (*(numfamele+j) == numc)
              nele++;     
        for (j=0;j<(*(indfamgro+i)-*(indfamgro+i-1))/MED_TAILLE_LNOM; j++)
          {
            strncpy(groupe, grofam+*(indfamgro+i-1)+j*MED_TAILLE_LNOM,
                    MED_TAILLE_LNOM);
            if (numc > 0)
              {
                if (nn == 0)
                  {
                    strncpy(nomgronoe,groupe,MED_TAILLE_LNOM);
                    nn = 1;
                    pos = 1;
                  }
                else
                  {
                    flag = 0;
                    for (k=0; k<nn;k++)
                      if (strncmp(groupe,nomgronoe+k*MED_TAILLE_LNOM,
                                  MED_TAILLE_LNOM) == 0)
                        {
                          flag = 1;
                          pos = k+1;
                        }
                    if (flag == 0)
                      {
                        strncpy(nomgronoe+nn*MED_TAILLE_LNOM,groupe, 
                                MED_TAILLE_LNOM);
                        pos = nn + 1;
                        nn = nn + 1;
                      }
                  }
                *(indgronoe+pos) = *(indgronoe+pos) + nnoe;
              } 
            if (numc < 0)
              {
                if (ne == 0)
                  {
                    strncpy(nomgroele,groupe,MED_TAILLE_LNOM);
                    ne = 1;
                    pos = 1;
                  }
                else
                  {
                    flag = 0;
                    for (k=0; k<ne;k++)
                      if (strncmp(groupe,nomgroele+k*MED_TAILLE_LNOM,
                                  MED_TAILLE_LNOM) == 0)
                        {
                          flag = 1;
                          pos = k + 1;
                        }
                    if (flag == 0)
                      {
                        strncpy(nomgroele+ne*MED_TAILLE_LNOM,groupe, 
                                MED_TAILLE_LNOM);
                        pos = ne + 1;
                        ne = ne + 1;
                      }
                  }
                *(indgroele+pos) = *(indgroele+pos) + nele;
              }
          } 
      }
  *(nomgronoe+ngn*MED_TAILLE_LNOM) = '\0';
  *(nomgroele+nge*MED_TAILLE_LNOM) = '\0';

  /* 2e passe : on construit les listes des index ainsi que les
     les tables des groupes */
  for (i=1;i<=ngn;i++)
    {
      cpt = 0;
      *(indgronoe+i) = *(indgronoe+i-1) + *(indgronoe+i);
      strncpy(groupe,nomgronoe+(i-1)*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
      for (j=1;j<=nfam;j++)
          {
            numc = *(numfam+j-1);
            if (numc > 0)
              {
                flag = 0;
                for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM;
                     k++)
                  if (! strncmp(groupe,
                                grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM,
                                MED_TAILLE_LNOM))
                    flag = 1;
                if (flag == 1)
                  for (k=0;k<nnoeuds;k++)
                    if (*(numfamnoe+k) == numc)
                      {
                        *(tabgronoe+*(indgronoe+i-1)+cpt) = *(numnoeuds+k);
                        cpt++;
                      }
              }
          }
    }         
  
  for (i=1;i<=nge;i++)
    {
      cpt = 0;
      *(indgroele+i) = *(indgroele+i-1) + *(indgroele+i);  
      strncpy(groupe,nomgroele+(i-1)*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
      for (j=1;j<=nfam;j++)
          {
            numc = *(numfam+j-1);
            if (numc < 0)
              {
                flag = 0;
                for (k=0;k<(*(indfamgro+j)-*(indfamgro+j-1))/MED_TAILLE_LNOM;
                     k++)
                  if (! strncmp(groupe,
                                grofam+*(indfamgro+j-1)+k*MED_TAILLE_LNOM,
                                MED_TAILLE_LNOM))
                    flag = 1;
                if (flag == 1)
                  for (k=0;k<nelements;k++)
                    if (*(numfamele+k) == numc)
                      {
                        *(tabgroele+*(indgroele+i-1)+cpt) = *(numele+k);
                        cpt++;
                      }
              }
          }
    }
  
  return 0;
}
med_err med_2_1::MEDfamCr ( 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 
)

Definition at line 28 of file MEDfamCr.cxx.

{
  med_idt root, datagroup, famid;
  med_err ret;
  med_size dimd[1];
  char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+MED_TAILLE_NOM+1];
  char tmp[MED_TAILLE_FAS+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * Si le Data Group FAS n'existe pas, on le cree
   */
  strcpy(chemin,MED_MAA);
  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)
      return -1;
    
  /*
   * Si le Data Group de meme nom que famille existe => erreur
   * Sinon on le cree
   */
  if ((famid = _MEDdatagroupOuvrir(root,famille)) >= 0)
    return -1;
  if ((famid = _MEDdatagroupCreer(root,famille)) < 0)
    return -1;

  /*
   * L'attribut NUM
   */
  if ((ret = _MEDattrEntierEcrire(famid,MED_NOM_NUM,&numero,MED_REMP)) < 0)
    return -1;

  /*
   * Le Data Group "GRO"
   */
  if (n_groupe > 0)
    {
      /*
       * On cree le Data Group 
       */
      if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_GRO)) < 0)
        return -1;

      /*
       * L'attribut "NBR"
       */
      if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_groupe,MED_REMP)) < 0)
        return -1;
      
      /* 
       * Data Set des noms des groupes "NOM"
       */
      dimd[0] = n_groupe*MED_TAILLE_LNOM+1;
      if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_NOM,dimd,groupe,
                                      MED_REMP))<0)
        return -1;

      /* 
       * On ferme le Data Group
       */
      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
        return -1;
    }

  /*
   * Le Data Group "ATT"
   */
  
  if (n_attr > 0)
    {
      if ((datagroup = _MEDdatagroupCreer(famid,MED_NOM_ATT)) < 0)
        return -1;

      /*
       * L'attribut "NBR"
       */
      if ((ret = _MEDattrEntierEcrire(datagroup,MED_NOM_NBR,&n_attr,MED_REMP)) < 0)
        return -1;
      
      /*
       * 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,0,MED_NOPG,dimd,
                                   (unsigned char *)attr_ident,MED_REMP)) < 0)
        return -1;    
#else
      if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_IDE,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                   (unsigned char *)attr_ident,MED_REMP)) < 0)
        return -1;      
#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,0,MED_NOPG,dimd,
                                   (unsigned char*)attr_val,MED_REMP)) < 0)
        return -1;
#else
      if ((ret = _MEDdatasetNumEcrire(datagroup,MED_NOM_VAL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                   (unsigned char*)attr_val,MED_REMP)) < 0)
        return -1;
#endif

      /*
       * Le Data Set "DES"
       */
      dimd[0] = n_attr*MED_TAILLE_DESC+1;
      if ((ret = _MEDdatasetStringEcrire(datagroup,MED_NOM_DES,dimd,attr_desc,
                                      MED_REMP)) < 0)
        return -1;

      /* 
       * On ferme le Data Group
       */
      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
        return -1;
    }

  /* 
   * On ferme tout
   */ 
  if ((ret = _MEDdatagroupFermer(famid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfamEcr ( med_idt  fid,
char *  maa,
med_int *  fam,
med_int  n,
med_mode_acces  mode,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 28 of file MEDfamEcr.cxx.

{
  med_idt root, maaid, entid, geoid, dataset;
  med_err ret;
  med_size dimd[1];
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;

   /*
    * Si le Data Group des entites n'existe pas on le cree
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
       return -1;

   /*
    * Pour les mailles, les faces et le aretes, on cree
    * s'il n'existe pas le Data Group du type geometrique
    */
   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
     {
       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
         return -1;

       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
         if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
           return -1;
     }
   else 
     geoid = -1;

   /*
    * Creation du Data Set "FAM" 
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
   dimd[0] = n;
#if defined(HAVE_F77INT64)
   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*)fam,mode)) < 0)
     return -1;
#else
   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_FAM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*)fam,mode)) < 0)
     return -1;
#endif

  /*
   * Attribut NBR (nombre de noeuds)
   */
   if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_FAM)) < 0)
     return -1;
   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
     return -1;

   /*
    * On ferme tout
    */
   if ((ret = _MEDdatasetFermer(dataset)) < 0)
     return -1;
   if (geoid != -1)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1; 

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfamGridEcr ( med_idt  fid,
char *  maa,
med_int *  fam,
med_int  n,
med_mode_acces  mode,
med_entite_maillage  type_ent 
)

Definition at line 24 of file MEDfamGridEcr.cxx.

                                                                                                                  {
    /* Ecrire des numeros de familles pour les grilles cartesiennes ou polaires :
       - pour les noeuds
       - pour les aretes
       - pour les faces
       - pour les mailles */

    med_geometrie_element type_geo;

    switch(type_ent) {
        case MED_NOEUD : {
            type_geo = MED_POINT1;
            break;
        };
        case MED_ARETE : {
            type_geo = MED_SEG2;
            break;
        };
        case MED_FACE : {
            type_geo = MED_QUAD4;
            break;
        };
        case MED_MAILLE : {
            type_geo = MED_HEXA8;
            break;
        };
        default : {
            return(-1);
        };
    };

    return(MEDfamEcr(fid, maa, fam, n, mode, type_ent, type_geo));
}

Here is the call graph for this function:

med_err med_2_1::MEDfamGridLire ( med_idt  fid,
char *  maa,
med_int *  fam,
med_int  n,
med_entite_maillage  type_ent 
)

Definition at line 24 of file MEDfamGridLire.cxx.

                                                                                              {
    /* lecture des numeros de familles pour les grilles cartesiennes ou polaires :
       - pour les noeuds
       - pour les aretes
       - pour les faces
       - pour les mailles */

    med_geometrie_element type_geo;

    switch(type_ent) {
        case MED_NOEUD : {
            type_geo = MED_POINT1;
            break;
        };
        case MED_ARETE : {
            type_geo = MED_SEG2;
            break;
        };
        case MED_FACE : {
            type_geo = MED_QUAD4;
            break;
        };
        case MED_MAILLE : {
            type_geo = MED_HEXA8;
            break;
        };
        default : {
            return(-1);
        };
    };

    return(MEDfamLire(fid, maa, fam, n, type_ent, type_geo));
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfamInfo ( med_idt  fid,
char *  maa,
int  indice,
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 
)

Definition at line 28 of file MEDfamInfo.cxx.

{
  med_idt famid,datagroup;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1];
  int num;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On recupere le nom de la famille
   */
  num = indice - 1;
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_FAS); 
  if ((ret = _MEDobjetIdentifier(fid,chemin,num,famille)) < 0)
    return -1;

  /* 
   * Si le Data Group de la famille n'existe pas => erreur
   */
  strcat(chemin,famille);
  if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * L'attribut NUM
   */
  if ((ret = _MEDattrEntierLire(famid,MED_NOM_NUM,numero)) < 0)
    return -1;

  /*
   * Le Data Group "GRO"
   */
  if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) >= 0)
    {
      /*
       * L'attribut "NBR"
       */
      if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_groupe)) < 0)
        return -1;
      
      /* 
       * Data Set des noms des groupes "NOM"
       */
      if ((ret = _MEDdatasetStringLire(datagroup,MED_NOM_NOM,groupe)) < 0)
        return -1;

      /* 
       * On ferme le Data Group
       */
      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
        return -1;
    }
  else
    *n_groupe = 0;

  /*
   * Le Data Group "ATT"
   */
  if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) >= 0)
    {
      /*
       * L'attribut "NBR"
       */
      if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,n_attr)) < 0)
        return -1;
      
      /*
       * Le Data Set "IDE"
       */
#if defined(HAVE_F77INT64)
      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT64,
                                    MED_NO_INTERLACE,1,MED_ALL,
                                    MED_NOPF,0,MED_NOPG,
                                    (unsigned char*) attr_ident)) < 0)
        return -1;     
#else
      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_IDE,MED_INT32,
                                    MED_NO_INTERLACE,1,MED_ALL,
                                    MED_NOPF,0,MED_NOPG,
                                    (unsigned char*) attr_ident)) < 0)
        return -1;     
#endif

      /*
       * Le Data Set "VAL"
       */
#if defined(HAVE_F77INT64)
      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT64,
                                    MED_NO_INTERLACE,1,MED_ALL,
                                    MED_NOPF,0,MED_NOPG,
                                    (unsigned char *) attr_val)) < 0)
        return -1;
#else
      if ((ret = _MEDdatasetNumLire(datagroup,MED_NOM_VAL,MED_INT32,
                                    MED_NO_INTERLACE,1,MED_ALL,
                                    MED_NOPF,0,MED_NOPG,
                                    (unsigned char *) attr_val)) < 0)
        return -1;
#endif

      /*
       * Le Data Set "DES"
       */
      ret = _MEDdatasetStringLire(datagroup,MED_NOM_DES,attr_desc);

      /* 
       * On ferme le Data Group
       */
      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
        return -1;
    }
  else
    *n_attr = 0;

  /* 
   * On ferme tout
   */ 
  if ((ret = _MEDdatagroupFermer(famid)) < 0)
    return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfamLire ( med_idt  fid,
char *  maa,
med_int *  fam,
med_int  n,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 28 of file MEDfamLire.cxx.

{
  med_idt root,maaid, entid, geoid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;

   /*
    * Si le Data Group des entites n'existe pas => erreur
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     return -1;

   /*
    * Pour les mailles, les faces et le aretes, on cree
    * si le Data Group du type geometrique => erreur
    */
   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
     {
       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
         return -1;
       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
         return -1;
     }
   else 
     geoid = -1;

   /*
    * lecture du Data Set "FAM" 
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
#if defined(HAVE_F77INT64)
   if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT64,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char *)fam)) < 0)
     return -1;
#else
   if ((ret = _MEDdatasetNumLire(root,MED_NOM_FAM,MED_INT32,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char *)fam)) < 0)
     return -1;
#endif

   /*
    * On ferme tout
    */
   if (geoid != -1)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1; 

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfamMaaCr ( med_idt  fid,
char *  maa,
med_int *  numfam,
med_int *  attide,
med_int *  attval,
char *  attdes,
int *  indatt,
char *  gro,
int *  indgro,
med_int  nfamilles 
)

Definition at line 28 of file MEDfamMaaCr.cxx.

{
  med_err ret;
  med_int i;
  med_int natt,ngro;
  med_int numf;
  char nomfam[MED_TAILLE_NOM+1];

  /* La famille de numero 0 n'a aucun attribut, ni aucun groupe
     Les familles de numero > 0 sont des familles de noeuds
     Les familles de numero < 0 sont des familles d'elements */
  for (i=0;i<nfamilles;i++)
    {
      numf = *(numfam+i);
      if (numf == 0)
        strcpy(nomfam,"FAMILLE_0");
      if (numf > 0)
        {
          strcpy(nomfam,"FAMILLE_NOEUD_");
          sprintf(nomfam,"%s%d",nomfam,numf);
          nomfam[MED_TAILLE_NOM] = '\0';
        }
      if (numf < 0)
        {
          strcpy(nomfam,"FAMILLE_ELEMENT_");
          sprintf(nomfam,"%s%d",nomfam,-numf);
          nomfam[MED_TAILLE_NOM] = '\0';
        }       
      natt = *(indatt+i+1) - *(indatt+i);
      ngro = (*(indgro+i+1) - *(indgro+i))/MED_TAILLE_LNOM;
      if ((ret = MEDfamCr(fid,maa,nomfam,numf,
                          attide+*(indatt+i),
                          attval+*(indatt+i),
                          attdes+*(indatt+i)*MED_TAILLE_DESC,natt,
                          gro+*(indgro+i),ngro)) < 0)
        return -1;
    }
    
  return 0;
}

Here is the call graph for this function:

med_err med_2_1::MEDfamMaaInfo ( med_idt  fid,
char *  maa,
med_int *  nfam,
med_int *  nattc,
med_int *  ngroc 
)

Definition at line 25 of file MEDfamMaaInfo.cxx.

{
  med_int ret;
  med_int i;

  /* Lecture du nombre de familles */
  if ((*nfam = MEDnFam(fid,maa,0,(med_dim_famille)0)) < 0)
    return -1;

  /* Lecture des nombres cumules de groupes et d'attributs dans toutes
     les familles du maillage */
  *nattc = 0;
  *ngroc = 0;
  for (i=0;i<*nfam;i++)
    {
      if ((ret = MEDnFam(fid,maa,i+1,MED_ATTR)) < 0)
        return -1;
      *nattc += ret;
      if ((ret = MEDnFam(fid,maa,i+1,MED_GROUPE)) < 0)
        return -1;
      *ngroc += ret;
    }

  return 0;
}

Here is the call graph for this function:

med_err med_2_1::MEDfamMaaLire ( med_idt  fid,
char *  maa,
med_int *  numfam,
med_int *  attide,
med_int *  attval,
char *  attdes,
int *  indatt,
char *  gro,
int *  indgro,
med_int  nfamilles 
)

Definition at line 25 of file MEDfamMaaLire.cxx.

{
  med_err ret;
  med_int natt,ngro;
  med_int i;
  char nom[MED_TAILLE_NOM+1];

  *indatt = 0;
  *indgro = 0;
  for (i=0;i<nfamilles;i++)
    {
      if ((ret = MEDfamInfo(fid,maa,i+1,nom,numfam+i,attide+*(indatt+i),
                            attval+*(indatt+i),
                            attdes+*(indatt+i)*MED_TAILLE_DESC,
                            &natt,gro+*(indgro+i),&ngro)) < 0)
        return -1;
      *(indatt+i+1) = *(indatt+i)+natt;
      *(indgro+i+1) = *(indgro+i)+ngro*MED_TAILLE_LNOM;
    }
    
  return 0;
}

Here is the call graph for this function:

med_err med_2_1::MEDfermer ( med_idt  fid)

Definition at line 25 of file MEDfermer.cxx.

{
  /*
   * On inhibe le gestionnaire d'erreur
   */
   _MEDmodeErreurVerrouiller(); 

  /*
   * On ferme le fichier MED
   */
  if (_MEDfichierFermer(fid) < 0)
    return -1;
  else
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfichDesEcr ( med_idt  fid,
char *  des,
med_mode_acces  mode 
)

Definition at line 27 of file MEDfichDesEcr.cxx.

{ 
  med_idt root;
  med_err ret;
  char nom[] = MED_NOM_DESCRIPTEUR;
  char chemin[MED_TAILLE_MAA+1];

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On ouvre le Data Group racine
   * s'il n'existe pas on le cree
   */
  strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1);
  chemin[MED_TAILLE_MAA-1] = '\0';
  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
      return -1;

  /*
   * On regarde si l'attribut existe
   * Si oui on le met a jour en fonction
   * du mode d'ouverture, sinon on le cree
   */

  if ((ret = _MEDattrStringEcrire(root,nom,MED_TAILLE_DESC,des,mode)) < 0)
    return -1;

  /*
   * Fermetures 
   */

  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;
          
  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDfichEntete ( med_idt  fid,
med_fich_info  quoi,
char  str[] 
)

Definition at line 27 of file MEDfichEntete.cxx.

{
  med_idt root;
  med_err ret;
  char locale[MED_TAILLE_DESC+1];
  char chemin[MED_TAILLE_MAA+1];

  switch (quoi)
    {
    case MED_HDF_VERSION : 
      strcpy(str,HDF_VERSION_ACTUELLE);
      break;

    case MED_VERSION :
      strcpy(str,MED_VERSION_ACTUELLE); 
      break;

    case MED_FICH_DES :
      /*
       * On inhibe le gestionnaire d'erreur HDF
       */
      _MEDmodeErreurVerrouiller();
      
      /*
       * On ouvre le Data Group racine
       */
      strncpy(chemin,MED_MAA,strlen(MED_MAA)-1);
      chemin[MED_TAILLE_MAA-1] = '\0';
      if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
        return -1;

      /*
       * On regarde si l'attribut existe
       * Si non => erreur
       * Si oui => on le copie dans str
       */
      if ((ret = _MEDattrStringLire(root,(char*)MED_NOM_DESCRIPTEUR,
                                    MED_TAILLE_DESC,locale)) < 0)
        return -1;
      strcpy(str,locale);
      
      if ((ret = _MEDdatagroupFermer(root)) < 0)
        return -1;

      break;
      
    default :
      return -1;
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDformatConforme ( const char *  nomfich)

Definition at line 25 of file MEDformatConforme.cxx.

{

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();


  if  ( H5Fis_hdf5(nomfich) > 0 )
        return 0;
  else
        return -1;
}

Here is the call graph for this function:

med_err med_2_1::MEDgridCr ( med_idt  fid,
char *  maillage,
med_int  dim,
med_grid_type  typ 
)

Definition at line 27 of file MEDgridCr.cxx.

{
    med_idt maaid, root;
    char    chemin[MED_TAILLE_MAA+1];

    /* On inhibe le gestionnaire d'erreur */
    _MEDmodeErreurVerrouiller();

    /* 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)
            return(-1);

    /* si le maillage existe deja => erreur */
    if (_MEDdatagroupOuvrir(root, maillage) > 0) {
        return(-1);
    };

    /* Creation du Data Group */
    maaid = _MEDdatagroupCreer(root, maillage);
    if (maaid < 0) return(-1);

    /* Creation de l'attribut dimension */
    if (_MEDattrEntierEcrire(maaid, MED_NOM_DIM, &dim, MED_REMP) < 0) {
        return(-1);
    };

    /* Creation de l'attribut grille */
    if (_MEDattrEntierEcrire(maaid, MED_NOM_GRD, &typ, MED_REMP) < 0) {
        return(-1);
    };

    /* Nettoyages divers */
    if ( _MEDdatagroupFermer(maaid) < 0) return(-1);
    if (_MEDdatagroupFermer(root)   < 0) return(-1);
    return(0);
}

Here is the call graph for this function:

med_err med_2_1::MEDgridEcr ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coo,
med_int  nb,
med_int  dim,
med_mode_switch  mode_coo,
med_repere  repere,
char *  nomcoo,
char *  unicoo,
med_mode_acces  mode 
)

Definition at line 27 of file MEDgridEcr.cxx.

{
    /* ecriture des indices */

    med_idt  maaid, noeid, ds;
    char     chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
    med_size dimd[1];
    char     *dataset;
    med_int  type_rep_int;

    /* On inhibe le gestionnaire d'erreur HDF */
    _MEDmodeErreurVerrouiller();

    /* Si le maillage n'existe pas => erreur */
    strcpy(chemin, MED_MAA);
    strcat(chemin, maa);
    maaid = _MEDdatagroupOuvrir(fid, chemin);
    if (maaid < 0) return(-1);

    /* Si le Data Group "NOE" n'existe pas on le cree */
    if ((noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE)) < 0) {
        if ((noeid = _MEDdatagroupCreer(maaid, MED_NOM_NOE)) < 0) {
            return(-1);
        };
    };

    switch (dim) {
        case 0 : {
            dataset = MED_NOM_IN1;
            break;
        };
        case 1 : {
            dataset = MED_NOM_IN2;
            break;
        };
        case 2 : {
            dataset = MED_NOM_IN3;
            break;
        };
        default : {
            return(-1);
        };
    };

    /* Creation du Data Set "IN1" ou "IN2" ou "IN3" */
    dimd[0] = nb;
    if (_MEDdatasetNumEcrire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 0, dimd, (unsigned char*)coo, mode) < 0) {
        return(-1);
    };

    /* On re-ouvre le Data Set "IN1" ou "IN2" ou "IN3" pour y placer des attributs */
    if ((ds = _MEDdatasetOuvrir(noeid, dataset)) < 0) {
        return(-1);
    };

    /* Attribut NBR (nombre de noeuds) */
    if (_MEDattrEntierEcrire(ds, MED_NOM_NBR, &nb, mode) < 0) {
        return(-1);
    };

    /* L'attribut "REP" */
    type_rep_int = (med_int)repere;
    if (_MEDattrEntierEcrire(ds, MED_NOM_REP, &type_rep_int, mode) < 0) {
        return(-1);
    };

    /* Attribut "NOM" */
    if (_MEDattrStringEcrire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo, mode) < 0) {
        return(-1);
    };

    /* Attribut "UNI" */
    if (_MEDattrStringEcrire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo, mode) < 0) {
        return(-1);
    };

    /* On ferme tout */
    if (_MEDdatasetFermer(ds)      < 0) return(-1);
    if (_MEDdatagroupFermer(noeid) < 0) return(-1);
    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
    return(0);
}

Here is the call graph for this function:

med_err med_2_1::MEDgridInfo ( med_idt  fid,
int  indice,
med_int *  isAGrid,
med_grid_type *  typ 
)

Definition at line 28 of file MEDgridInfo.cxx.

{
    int     numero;
    med_idt maaid;
    char    maillage[MED_TAILLE_NOM+1];
    char    chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];

    /* On inhibe le gestionnaire d'erreur */
    _MEDmodeErreurVerrouiller();

    /* On recupere le nom du groupe de rang "indice" */
    numero = indice-1;
    if (_MEDobjetIdentifier(fid, MED_MAA, numero, maillage) < 0) {
        return(-1);
    };

    /* On va chercher l'attribut dimension */
    strcpy(chemin, MED_MAA);
    strcat(chemin, maillage);
    maaid = _MEDdatagroupOuvrir(fid, chemin);
    if (maaid < 0) return(-1);

    med_int aTmpType; // MPV bug IPAL 13621: for 64bits platform read 64 bits (not 32 - as for type)
    if (_MEDattrEntierLire(maaid, MED_NOM_GRD, &aTmpType) < 0) {
        *isAGrid = 0;
    } else {
        *isAGrid = 1;
    };
    *typ = (med_grid_type)aTmpType;// MPV bug IPAL 13621: now use this 64bits value to set enumeration

    if (_MEDdatagroupFermer(maaid) < 0) return(-1);
    return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDgridLire ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coo,
med_int  dim,
med_mode_switch  mode_coo,
med_repere *  repere,
char *  nomcoo,
char *  unicoo 
)

Definition at line 9 of file MEDgridLire.cxx.

{
    med_idt   maaid, noeid, ds;
    char      chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
    char      *dataset;
    med_int   type_rep_int;

    /* On inhibe le gestionnaire d'erreur */
    _MEDmodeErreurVerrouiller();

    /* Si le maillage n'existe pas => erreur */
    strcpy(chemin, MED_MAA);
    strcat(chemin, maa);
    maaid = _MEDdatagroupOuvrir(fid, chemin);
    if (maaid < 0) return(-1);

    /* Si le Data Group "NOE" n'existe pas => erreur */
    noeid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
    if (noeid < 0) return(-1);

    switch (dim) {
        case 0 : {
            dataset = MED_NOM_IN1;
            break;
        };
        case 1 : {
            dataset = MED_NOM_IN2;
            break;
        };
        case 2 : {
            dataset = MED_NOM_IN3;
            break;
        };
        default : {
            return(-1);
        };
    };

    /* Lecture du Data Set "IN1" ou "IN2" ou "IN3" */
    if (_MEDdatasetNumLire(noeid, dataset, MED_REEL64, mode_coo, 1, MED_ALL, MED_NOPF, 0, 1, (unsigned char*)coo) < 0) {
        return(-1);
    };

    /* On re-ouvre le Data Set precedant pour y lire des attributs */
    ds = _MEDdatasetOuvrir(noeid, dataset);
    if (ds < 0) return(-1);

    /* L'attribut "REP" */
    if (_MEDattrEntierLire(ds, MED_NOM_REP, &type_rep_int) < 0) {
        return(-1);
    } else {
        *repere = (med_repere)type_rep_int;
    };

    /* Attribut "NOM" */
    if (_MEDattrStringLire(ds, MED_NOM_NOM, mdim*MED_TAILLE_PNOM, nomcoo) < 0) {
        return(-1);
    };

    /* Attribut "UNI" */
    if (_MEDattrStringLire(ds, MED_NOM_UNI, mdim*MED_TAILLE_PNOM, unicoo) < 0) {
        return(-1);
    };

    /* On ferme tout */
    if (_MEDdatasetFermer(ds) < 0) {
        return(-1);
    };
    if (_MEDdatagroupFermer(noeid) < 0) {
        return(-1);
    };
    if (_MEDdatagroupFermer(maaid) < 0) {
        return(-1);
    };
    return(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDgro2famA ( med_int  nnoe,
med_int  nele,
med_int *  numnoe,
med_int *  numele,
med_int  ngn,
med_int  nge,
med_int  nindn,
med_int  ninde,
int *  indgronoe,
int *  indgroele,
med_int *  tabgronoe,
med_int *  tabgroele,
med_int *  nfamg,
med_int *  nindf 
)

Definition at line 75 of file MEDgro2famA.cxx.

{
  int i,j,k;
  int *famnoe,*famele,*tmp;
  int *p;
  int flag, num,exist;
  int nfamn, nfame;
  int fam01 = 0;
  int fam02 = 0;

  /* initialisations */
  famnoe = NULL;
  famele = NULL;

  *nfamg = 0;
  *nindf = 0;
  nfamn = 0;
  nfame = 0;

  if ((ngn > 0) || (nge > 0))
    {
      /* pour chaque noeud :
         1 - on dresse la liste des groupes de noeuds auquel il appartient
         2 - en la comparant avec les listes pre-existantes, on
         estime s'il est necessaire de creer une nouvelle famille de noeuds.
         Si oui => on incremente le compteur local nfamn (nombre de familles
                   de noeuds)
                   on incremente le parametre nindf du nombre de groupes
                   que devra compter cette famille de noeuds
         Si non => on ne fait rien */
      for (i=0;i<nnoe;i++)
        {
          if ((tmp = (int*) malloc(sizeof(int)*ngn)) == NULL)
            return -1;
          num = *(numnoe+i);
          for (j=0;j<ngn;j++)
            {
              flag = 0;
              /* on regarde si le noeud appartient au groupe */
              for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
                if (num == *(tabgronoe+*(indgronoe+j)+k))
                  flag = 1;
              /* on met le flag a jour dans tmp */
              *(tmp+j) = flag;
            }
          /* on note la creation de la famille 0 */
          if (fam01 == 0)
            {
              flag = 1;
              for (j=0;j<ngn;j++)
                if (*(tmp+j) == 1)
                  flag = 0;
              if (flag == 1)
                fam01 = 1;
            }
          /* faut-il creer une nouvelle famille ? */
          if (famnoe == NULL)
            {
              exist = 0;
              if ((famnoe = (int *) malloc (sizeof(int)*ngn)) == NULL)
                return -1;
              for (j=0;j<ngn;j++)
                {
                  *(famnoe+j) = *(tmp+j);
                  if (*(famnoe+j) == 1)
                    *nindf = *nindf + 1;
                }
              nfamn = 1;
            }
          else
            {
              for (j=0;j<nfamn;j++)
                {
                  p = famnoe + ngn*j;
                  for (k=0;k<ngn;k++)
                    {
                      if (*(p+k) != *(tmp+k))
                        {
                          exist = 0;
                          break;
                        }
                      else
                        exist = 1;
                    }
                  if (exist == 1)
                    break;
                }
              if (exist == 0)
                {
                  nfamn = nfamn + 1;
                  p = famnoe;
                  if ((famnoe = (int*) malloc(sizeof(int)*ngn*nfamn)) == NULL)
                    return -1;
                  for (j=0;j<nfamn-1;j++)
                    for (k=0;k<ngn;k++)
                      *(famnoe+j*ngn+k) = *(p+j*ngn+k);
                  free(p);
                  p = famnoe+(nfamn-1)*ngn;
                  for (j=0;j<ngn;j++)
                    {
                      *(p+j) = *(tmp+j);
                      if (*(p+j) == 1)
                        *nindf = *nindf + 1;
                    }
                }
            }
          free(tmp);
        }
      
      /* pour chaque element : idem que pour les noeuds */
      for (i=0;i<nele;i++)
        {
          if ((tmp = (int*) malloc(sizeof(int)*nge)) == NULL)
            return -1;
          num = *(numele+i);
          for (j=0;j<nge;j++)
            {
              flag = 0;
              /* on regarde si l'element appartient au groupe */
              for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
                if (num == *(tabgroele+*(indgroele+j)+k))
                  flag = 1;
              /* on met le flag a jour dans tmp */
              *(tmp+j) = flag;
            }
          /* on note la creation de la famille 0 */
          if (fam02 == 0)
            {
              flag = 1;
              for (j=0;j<nge;j++)
                if (*(tmp+j) == 1)
                  flag = 0;
              if (flag == 1)
                fam02 = 1;
            }
          /* faut-il creer une nouvelle famille ? */
          if (famele == NULL)
            {
              exist = 0;
              if ((famele = (int *) malloc (sizeof(int)*nge)) == NULL)
                return -1;
              for (j=0;j<nge;j++)
                {
                  *(famele+j) = *(tmp+j);
                  if (*(famele+j) == 1)
                    *nindf = *nindf + 1;
                }
              nfame = 1;
            }
          else
            {
              for (j=0;j<nfame;j++)
                {
                  p = famele + nge*j;
                  for (k=0;k<nge;k++)
                    {
                      if (*(p+k) != *(tmp+k))
                        {
                          exist = 0;
                          break;
                        }
                      else
                        exist = 1;
                    }
                  if (exist == 1)
                    break;
                }
              if (exist == 0)
                {
                  nfame = nfame + 1;
                  p = famele;
                  if ((famele = (int*) malloc(sizeof(int)*nge*nfame)) == NULL)
                    return -1;
                  for (j=0;j<nfame-1;j++)
                    for (k=0;k<nge;k++)
                      *(famele+j*nge+k) = *(p+j*nge+k);
                  free(p);
                  p = famele+(nfame-1)*nge;
                  for (j=0;j<nge;j++)
                    {
                      *(p+j) = *(tmp+j);
                      if (*(p+j) == 1)
                        *nindf = *nindf + 1;
                    }
                }
            }
          free(tmp);
        }
      
      /* la famille 0 existe pour les noeuds et les elements, on 
         ne la compte qu'une fois */
      if (fam01 && fam02)
        nfamn = nfamn - 1;
      
      /* le nombre de familles a creer est egal au nombre de familles
         de noeuds + nombre de familles d'elements */
      *nfamg = nfamn + nfame;
      
      
      /* Nettoyage memoire */
      free(famnoe);
      free(famele);
    }  
  else
    {
      /* on a aucun groupes de noeuds ou d'elements */
      *nfamg = 1; /* on a au moins la famille 0 */
      *nindf = 0;
    }

  return 0;
}
med_err med_2_1::MEDgro2famB ( med_int  nnoe,
med_int  nele,
med_int *  numnoe,
med_int *  numele,
med_int  ngn,
med_int  nge,
med_int  nindn,
med_int  ninde,
char *  nomgronoe,
char *  nomgroele,
int *  indgronoe,
int *  indgroele,
med_int *  tabgronoe,
med_int *  tabgroele,
med_int  nfamg,
med_int  nindf,
med_int *  newnumfam,
med_int *  newnumfamele,
med_int *  newnumfamnoe,
int *  newindfamgro,
char *  newfamgro 
)

Definition at line 77 of file MEDgro2famB.cxx.

{
  int i,j,k;

  med_int *famnoe, *famele, *tmp;
  med_int *p;
  med_int num;
  int flag,exist;
  int nfamn, nfame;
  int estfam0 = 1;
  int newnumnoe, newnumele;
  int tmp1;
  int existfam0 = 0;
  // int ind = 0;

  famnoe = NULL;
  famele = NULL;

  nfamn = 0;
  nfame = 0;
  newnumnoe = 0;
  newnumele = 0;

  *newindfamgro = 0;

  if (nfamg > 1)
    {
      /* pour chaque noeud :
         1 - on dresse la liste des groupes de noeuds auquel il appartient
         2 - en la comparant avec les listes pre-existantes, on
         estime s'il est necessaire de creer une nouvelle famille de noeuds.
         Si oui => - on cree le numero de famille que l'on reporte 
                     dans newnumfam
                   - on reporte ce numero dans newnumnoe
                   - on met a jour la table des noms des groupes des familles
                     ainsi que sa table d'index  
         Si non => on ne fait rien 
         ATTENTION : pour la famille 0, on ne met a jour que les numeros */
      for (i=0;i<nnoe;i++)
        {
          if ((tmp = (med_int*) malloc(sizeof(med_int)*ngn)) == NULL)
            return -1;
          num = *(numnoe+i);
          for (j=0;j<ngn;j++)
            {
              flag = 0;
              /* on regarde si le noeud appartient au groupe */
              for (k=0;k<*(indgronoe+j+1)-*(indgronoe+j);k++)
                if (num == *(tabgronoe+*(indgronoe+j)+k))
                  flag = 1;
              /* on met le flag a jour dans tmp */
              *(tmp+j) = flag;
            }
          /* on regarde si le numero de famille est 0 */
          estfam0 = 0;
          flag = 1;
          for (j=0;j<ngn;j++)
            if (*(tmp+j) == 1)
              flag = 0;
          if (flag == 1)
            {
              estfam0 = 1;
              *(newnumfamnoe+i) = 0;
            }
          if (flag == 1 && existfam0 == 0)
            existfam0 = 1;
          /* faut-il creer une nouvelle famille ? */
          if (famnoe == NULL)
            {
              exist = 0;
              if ((famnoe = (med_int *) malloc (sizeof(med_int)*ngn)) == NULL)
                return -1;
              /* on met a jour la table d'indices */
              nfamn = 1;
              *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
              for (j=0;j<ngn;j++)
                {
                  tmp1 = *(tmp+j);
                  *(famnoe+j) = tmp1;
                  if (tmp1 == 1)
                    {
                      strncpy(newfamgro+*(newindfamgro+nfamn),
                              nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
                      *(newindfamgro+nfamn) = *(newindfamgro+nfamn) + 
                        MED_TAILLE_LNOM;
                    }
                }
              if (estfam0 == 0)
                {
                  newnumnoe = 1;
                  *newnumfamnoe = newnumnoe;
                  *newnumfam = newnumnoe;
                }
              else
                *newnumfam = 0;
            }
          else
            {
              for (j=0;j<nfamn;j++)
                {
                  p = famnoe + ngn*j;
                  for (k=0;k<ngn;k++)
                    {
                      if (*(p+k) != *(tmp+k))
                        {
                          exist = 0;
                          break;
                        }
                      else
                        exist = 1;
                    }
                  if (exist == 1)
                    {
                      if (estfam0 == 0)
                        *(newnumfamnoe+i) = *(newnumfam+j);
                      break;
                    }
                }
              if (exist == 0)
                {
                  nfamn = nfamn + 1;
                  *(newindfamgro+nfamn) = *(newindfamgro+nfamn-1);
                  p = famnoe;
                  if ((famnoe = (med_int*) malloc(sizeof(med_int)*ngn*nfamn))
                      == NULL)
                    return -1;
                  for (j=0;j<nfamn-1;j++)
                    for (k=0;k<ngn;k++)
                      *(famnoe+j*ngn+k) = *(p+j*ngn+k);
                  free(p);
                  p = famnoe+(nfamn-1)*ngn;
                  for (j=0;j<ngn;j++)
                    {
                      tmp1 = *(tmp+j);
                      *(p+j) = tmp1;
                      if (tmp1 == 1)
                        {
                          strncpy(newfamgro+*(newindfamgro+nfamn), 
                                  nomgronoe+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
                      *(newindfamgro+nfamn) = *(newindfamgro + nfamn) 
                        + MED_TAILLE_LNOM;
                        }
                    }
                  if (estfam0 == 0)
                    {
                      newnumnoe = newnumnoe + 1;
                      *(newnumfamnoe+i) = newnumnoe;
                      *(newnumfam+nfamn-1) = newnumnoe;
                    }
                  else
                    *(newnumfam+nfamn-1) = 0;
                }
            }
          free(tmp);
        }
      
      /* pour chaque element :
         1 - on dresse la liste des groupes de noeuds auquel il appartient
         2 - en la comparant avec les listes pre-existantes, on
         estime s'il est necessaire de creer une nouvelle famille d'elements.
         Si oui => - on cree le numero de famille que l'on reporte 
                     dans newnumfam
                   - on reporte ce numero dans newnumele
                   - on met a jour la table des noms des groupes des familles
                     ainsi que sa table d'index  
         Si non => on ne fait rien 
         ATTENTION : pour la famille 0, on ne met a jour que les numeros */
      for (i=0;i<nele;i++)
        {
          if ((tmp = (med_int*) malloc(sizeof(med_int)*nge)) == NULL)
            return -1;
          num = *(numele+i);
          for (j=0;j<nge;j++)
            {
              flag = 0;
              /* on regarde si l'element appartient au groupe */
              for (k=0;k<*(indgroele+j+1)-*(indgroele+j);k++)
                if (num == *(tabgroele+*(indgroele+j)+k))
                  flag = 1;
              /* on met le flag a jour dans tmp */
              *(tmp+j) = flag;
            }
          /* on regarde si le numero de famille est 0 */
          estfam0 = 0;
          flag = 1;
          for (j=0;j<nge;j++)
            if (*(tmp+j) == 1)
              flag = 0;
          if (flag == 1)
            {
              estfam0 = 1;
              *(newnumfamele+i) = 0;
            }
          /* faut-il creer une nouvelle famille ? */
          if (famele == NULL)
            {
              if (!(estfam0&&existfam0))
                {
                  exist = 0;
                  if ((famele = (med_int *) malloc (sizeof(med_int)*nge))
                      == NULL)
                    return -1;
                  nfame = 1;
                  *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
                  for (j=0;j<nge;j++)
                    {
                      tmp1 = *(tmp+j);
                      *(famele+j) = tmp1;
                      if (tmp1 == 1)
                        {
                          strncpy(newfamgro+*(newindfamgro+nfamn+nfame),
                                  nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
                          *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame)
                            + MED_TAILLE_LNOM;
                        }
                    }
                  if (estfam0 == 0)
                    {
                      newnumele = -1;
                      *(newnumfamele+i) = newnumele;
                      *(newnumfam+nfamn+nfame-1) = newnumele;
                    }
                  else
                    {
                      newnumele = 0;
                      *(newnumfam+nfamn+nfame-1) = newnumele;
                      existfam0 = 1;
                    }
                }
            }
          else
            {
              for (j=0;j<nfame;j++)
                {
                  p = famele + nge*j;
                  for (k=0;k<nge;k++)
                    {
                      if (*(p+k) != *(tmp+k))
                        {
                          exist = 0;
                          break;
                        }
                      else
                        exist = 1;
                    }
                  if (exist == 1)
                    {
                      if (estfam0 == 0)
                        *(newnumfamele+i) = *(newnumfam+nfamn+j);
                      break;
                    }
                }
              if (exist == 0 && !(estfam0 && existfam0))
                /* on cree une nouvelle famille */
                {
                  nfame = nfame + 1;
                  *(newindfamgro+nfamn+nfame) = *(newindfamgro+nfamn+nfame-1);
                  p = famele;
                  if ((famele = (med_int*) malloc(sizeof(med_int)*nge*nfame))
                      == NULL)
                    return -1;
                  for (j=0;j<nfame-1;j++)
                    for (k=0;k<nge;k++)
                      *(famele+j*nge+k) = *(p+j*nge+k);
                  free(p);
                  p = famele+(nfame-1)*nge;
                  for (j=0;j<nge;j++)
                    {
                      tmp1 = *(tmp+j);
                      *(p+j) = tmp1;
                      if (tmp1 == 1)
                        {
                          strncpy((newfamgro+*(newindfamgro+nfamn+nfame)), 
                                  nomgroele+j*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
                          *(newindfamgro+nfamn+nfame) =
                            *(newindfamgro+nfamn+nfame) + MED_TAILLE_LNOM;
                        }
                    }
                  if (estfam0 == 0)
                    {
                      newnumele = newnumele - 1;
                      *(newnumfamele+i) = newnumele;
                      *(newnumfam+nfamn+nfame-1) = newnumele;
                    }
                  else
                    if (existfam0 == 0)
                      {
                        *(newnumfam+nfamn+nfame-1) = 0;
                        existfam0 =1;
                      }
                }
            }
          free(tmp);
        }
      
      *(newfamgro+MED_TAILLE_LNOM*nindf) = '\0';

      free(famnoe);
      free(famele);
    }
  else
    {
      *newnumfam = 0;
      for (i=0;i<nele;i++)
        *(newnumfamele+i) = 0;
      for (i=0;i<nnoe;i++)
        *(newnumfamnoe+i) = 0;
    }
  
  return 0;
}
med_int med_2_1::MEDlFichDes ( med_idt  fid)

Definition at line 26 of file MEDlFichDes.cxx.

{
  med_idt attr, root;
  med_err ret=0;
  char des[MED_TAILLE_DESC+1];
  med_int longueur=0;
  char nom[MED_TAILLE_NOM+1];
  char chemin[MED_TAILLE_MAA+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On ouvre le Data Group racine
   */
  strncpy(chemin,MED_MAA,MED_TAILLE_MAA-1);
  chemin[MED_TAILLE_MAA-1] = '\0';
  if ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On regarde si l'attribut existe
   * Si non => erreur
   * Si oui => on retourne sa longueur
   */
  strcpy(nom,MED_NOM_DESCRIPTEUR);
 
  if ((attr = _MEDattrOuvrir(root,nom)) < 0) {
    _MEDdatagroupFermer(root);
    longueur=0;
    return 0;
  }
 
  if ((ret = _MEDattrFermer(attr)) < 0) {
    _MEDdatagroupFermer(root);
    return -1;
  }
  
  if ((ret = _MEDattrStringLire(root,nom,MED_TAILLE_DESC,des)) < 0) {
    _MEDdatagroupFermer(root);
    return -1;
  }
  
  longueur = (med_int)strlen(des);

  /*
   * fermetures 
   */
  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;

  return longueur;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDmaaCr ( med_idt  fid,
char *  maillage,
med_int  dim 
)

Definition at line 28 of file MEDmaaCr.cxx.

{
  med_idt maaid, root;
  char chemin[MED_TAILLE_MAA+1];
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * 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)
      return -1;

  /*
   * si le maillage existe deja => erreur
   */
  if ((maaid = _MEDdatagroupOuvrir(root,maillage)) > 0)
    return -1;

  /*
   * Creation du Data Group
   */
  if ((maaid = _MEDdatagroupCreer(root,maillage)) < 0)
    return -1;

  /*
   * Creation de l'attribut dimension
   */
  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_DIM,&dim,MED_REMP)) < 0)
    return -1;

  /* 
   * Nettoyages divers
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDmaaInfo ( med_idt  fid,
int  indice,
char *  maillage,
med_int *  dim 
)

Definition at line 28 of file MEDmaaInfo.cxx.

{
  int numero;
  med_idt maaid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On recupere le nom du groupe de rang "indice"
   */ 
  numero = indice-1;
  if ((ret = _MEDobjetIdentifier(fid,MED_MAA,numero,maillage)) < 0)
    return -1;

  /*
   * On va chercher l'attribut dimension 
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maillage);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;   
  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_DIM,dim)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDnbnoisEcr ( med_idt  fid,
char *  nom_maillage,
med_int  n 
)

Definition at line 28 of file MEDnbnoisEcr.cxx.

{
  med_idt maaid;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,nom_maillage);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Creation de l'attribut "Nombre de Noeuds Isoles"
   */
  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNI,&n,MED_REMP)) < 0)
    return -1;

  /* 
   * Fermetures des objets
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

med_int med_2_1::MEDnbnoisLire ( med_idt  fid,
char *  nom_maillage 
)

Definition at line 28 of file MEDnbnoisLire.cxx.

{
  med_idt maaid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_int n;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On regarde si le maillage existe => erreur si non 
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,nom_maillage);  
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On va lire l'attribut "NNI"
   */
  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNI,&n)) < 0)
    return -1;

  /*
   * Fermetures des objets HDF 
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return n;
}

Here is the call graph for this function:

med_err med_2_1::MEDnbnomaEcr ( med_idt  fid,
char *  nom_maillage,
med_int  n 
)

Definition at line 28 of file MEDnbnomaEcr.cxx.

{
  med_idt maaid;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,nom_maillage);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Creation de l'attribut "Nombre de Noeuds Max par maille"
   */
  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNM,&n,MED_REMP)) < 0)
    return -1;

  /* 
   * Nettoyages divers
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

med_int med_2_1::MEDnbnomaLire ( med_idt  fid,
char *  nom_maillage 
)

Definition at line 28 of file MEDnbnomaLire.cxx.

{
  med_idt maaid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_int n;

  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On regarde si le maillage existe => erreur si non 
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,nom_maillage);  
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On va lire l'attribut "NNM"
   */
  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNM,&n)) < 0)
    return -1;

  /*
   * Fermetures des objets HDF 
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return n;
}

Here is the call graph for this function:

med_err med_2_1::MEDnbnosoEcr ( med_idt  fid,
char *  nom_maillage,
med_int  n 
)

Definition at line 28 of file MEDnbnosoEcr.cxx.

{
  med_idt maaid;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,nom_maillage);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Creation de l'attribut "Nombre de Noeuds Sommets"
   */
  if ((ret = _MEDattrEntierEcrire(maaid,MED_NOM_NNS,&n,MED_REMP)) < 0)
    return -1;

  /* 
   * Fermetures
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

med_int med_2_1::MEDnbnosoLire ( med_idt  fid,
char *  nom_maillage 
)

Definition at line 28 of file MEDnbnosoLire.cxx.

{
  med_idt maaid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_int n;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On regarde si le maillage existe => erreur si non 
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,nom_maillage);  
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On va lire l'attribut "NNS"
   */
  if ((ret = _MEDattrEntierLire(maaid,MED_NOM_NNS,&n)) < 0)
    return -1;

  /*
   * Fermetures des objets HDF 
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;

  return n;
}

Here is the call graph for this function:

med_int med_2_1::MEDnChamp ( med_idt  fid,
int  indice 
)

Definition at line 27 of file MEDnChamp.cxx.

{
  int n1;
  med_int n2;
  med_idt datagroup;
  med_err ret;
  char nomdatagroup[MED_TAILLE_NOM+1];
  int num;
  char chemin[MED_TAILLE_CHA+MED_TAILLE_NOM+1];

  if (indice < 0)
    return -1;

  /*
   * On inhibe le gestionnaire d'erreur HDF 
   */
  _MEDmodeErreurVerrouiller();
  
  /* 
   * Si le Data Group cha n'existe pas et indice == 0 => 0
   * sinon erreur => erreur
   */
  strcpy(chemin,MED_CHA);

  /*
   * Si indice == 0 => nombre de champs
   */
  if (indice == 0)
    {
      n1 = 0;
      _MEDnObjets(fid,chemin,&n1);
      n2 = n1;
    }

  /*
   * Si indice > 0 => nbre de composants
   */
  if (indice > 0)
    {
      /*
       * On recupere le nom du champ 
       */
      num = indice-1;
      if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup)) < 0)
        return -1;
      strcat(chemin,nomdatagroup);
      /*
       * On recupere le nombre de composants
       */
      if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) 
        return -1;
      if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NCO,&n2)) < 0)
        return -1;
      if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
        return -1;
    }

  return n2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnCorres ( med_idt  fid,
char *  maa,
char *  eq,
med_entite_maillage  typ_ent,
med_geometrie_element  typ_geo 
)

Definition at line 28 of file MEDnCorres.cxx.

{
  med_idt eqid, datagroup;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_EQS+2*MED_TAILLE_NOM+1]; 
  char nomdatagroup[MED_TAILLE_NOM+1];
  char tmp[MED_TAILLE_NOM_ENTITE+1];
  med_int n;

  if (typ_geo == MED_TETRA4 || typ_geo == MED_TETRA10 ||
      typ_geo == MED_HEXA8  || typ_geo == MED_HEXA20  ||
      typ_geo == MED_PENTA6 || typ_geo == MED_PENTA15 ||
      typ_geo == MED_PYRA5  || typ_geo == MED_PYRA13)
    return -1;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
   _MEDmodeErreurVerrouiller();

  /* 
   * Si le Data Group de "eq" n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_EQS);
  strcat(chemin,eq);
  if ((eqid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;  
  if ((ret = _MEDnomEntite(nomdatagroup,typ_ent)) < 0)
    return -1;
  if ((typ_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp,typ_geo)) < 0)
        return -1;
      strcat(nomdatagroup,".");
      strcat(nomdatagroup,tmp);
    }
  if ((datagroup = _MEDdatagroupOuvrir(eqid,nomdatagroup)) < 0)
    return 0;
  if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
    return -1;

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(eqid)) < 0)
    return -1;

  return n;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnEntites ( med_idt  fid,
char *  maa,
med_entite_maillage  typ_ent,
med_connectivite  typ_con 
)

Definition at line 24 of file MEDnEntites.cxx.

{
  med_int total = 0;
  int i;  
  med_geometrie_element typ_mai[MED_NBR_GEOMETRIE_MAILLE] = {MED_POINT1,MED_SEG2, 
                                                    MED_SEG3,MED_TRIA3,
                                                    MED_TRIA6,MED_QUAD4,
                                                    MED_QUAD8,MED_TETRA4,
                                                    MED_TETRA10,MED_HEXA8,
                                                    MED_HEXA20,MED_PENTA6,
                                                    MED_PENTA15,MED_PYRA5,
                                                    MED_PYRA13};
  med_geometrie_element typ_fac[MED_NBR_GEOMETRIE_FACE] = {MED_TRIA3,MED_TRIA6,
                                                    MED_QUAD4,MED_QUAD8};
  med_geometrie_element typ_are[MED_NBR_GEOMETRIE_ARETE] = {MED_SEG2,MED_SEG3};  

  switch (typ_ent)
  {
     case MED_MAILLE :
        for (i=0;i<MED_NBR_GEOMETRIE_MAILLE;i++)
          total += MEDnEntMaa(fid,maa,MED_CONN,MED_MAILLE,typ_mai[i],typ_con);
        break;

     case MED_FACE :
        for (i=0;i<MED_NBR_GEOMETRIE_FACE;i++)
          total += MEDnEntMaa(fid,maa,MED_CONN,MED_FACE,typ_fac[i],typ_con);
        break;

     case MED_ARETE :
        for (i=0;i<MED_NBR_GEOMETRIE_ARETE;i++)
          total += MEDnEntMaa(fid,maa,MED_CONN,MED_ARETE,typ_are[i],typ_con);
        break;

     case MED_NOEUD :
        total = MEDnEntMaa(fid,maa,MED_COOR,MED_NOEUD,(med_geometrie_element)0,(med_connectivite)0);
        break;

     default :
        total = -1;
  }

  return total;
}

Here is the call graph for this function:

med_int med_2_1::MEDnEntMaa ( med_idt  fid,
char *  maa,
med_table  quoi,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
med_connectivite  type_conn 
)

Definition at line 28 of file MEDnEntMaa.cxx.

{
  med_idt root, maaid, entid,geoid, dataset=0;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];
  char nom_dataset[MED_TAILLE_NOM_ENTITE+1];
  med_int res = 0;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
  if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
    return -1;

   /*
    * Si le Data Group des entites n'existe pas => res = 0
    */
  entid = _MEDdatagroupOuvrir(maaid,nom_ent);

   /*
    * Pour les mailles, les faces et le aretes
    * si le Data Group du type geometrique n'existe pas => res = 0
    */
  if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
    {
      if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
        return -1;
      geoid = _MEDdatagroupOuvrir(entid,nom_geo);
    }
  else
    geoid = -1;
  
   /*
    * Ouverture du Data Set renvoye par _MEDnomDataset()
    * S'il n'existe pas => erreur
    * Sinon lecture de l'attribut NBR
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
   if ((ret = _MEDnomDataset(nom_dataset,quoi,type_conn)) < 0)
     return -1;
   dataset = _MEDdatasetOuvrir(root,nom_dataset);
   if (dataset > 0)
     if ((ret = _MEDattrEntierLire(dataset,MED_NOM_NBR,&res)) < 0)
       return -1;

   /*
    * On ferme tout
    */
   if (dataset > 0)
     if ((ret = _MEDdatasetFermer(dataset)) < 0)
       return -1;
   if (geoid > 0)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if (entid > 0)
     if ((ret = _MEDdatagroupFermer(entid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1; 

  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnEquiv ( med_idt  fid,
char *  maa 
)

Definition at line 28 of file MEDnEquiv.cxx.

{
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+MED_TAILLE_EQS+1];
  int n;

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_EQS);
  n = 0;
  _MEDnObjets(fid,chemin,&n);

  return (med_int) n;  
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnFam ( med_idt  fid,
char *  maa,
int  indice,
med_dim_famille  quoi 
)

Definition at line 28 of file MEDnFam.cxx.

{
  med_idt datagroup,famid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_FAS+2*MED_TAILLE_NOM+1];
  med_int n;
  int n_tmp;
  int num;
  char famille[MED_TAILLE_NOM+1];


  /* 
   * On inhibe le gestionnaire d'erreur HDF 
   */
  _MEDmodeErreurVerrouiller();

  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  strcat(chemin,MED_FAS);
  if (indice == 0)
    {
      n_tmp = 0;
      _MEDnObjets(fid,chemin,&n_tmp);
      n = (med_int ) n_tmp;
    }
  else
    {
      /*
       * On recupere le nom de la famille
       */
      num = indice - 1;
      if ((ret = _MEDobjetIdentifier(fid,chemin,num,
                            famille)) < 0)
        return -1;
      
  /* 
   * Si le Data Group de la famille n'existe pas => erreur
   */
      strcat(chemin,famille);
      if ((famid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
        return -1;

      switch (quoi)
        {
        case MED_GROUPE :
          if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_GRO)) < 0)
            n = 0;
          else
            {
              if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
                return -1;
              if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
                return -1;
            }
          break;

        case MED_ATTR :
          if ((datagroup = _MEDdatagroupOuvrir(famid,MED_NOM_ATT)) < 0)
            n = 0;
          else
            {
              if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
                return -1;
              if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
                return -1;
            }
          break;

        default :
          return -1;
        }

      if ((ret = _MEDdatagroupFermer(famid)) < 0)
        return -1;

    }

  return (med_int) n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnGrid ( med_idt  fid,
char *  maa,
med_grid  n 
)

Definition at line 27 of file MEDnGrid.cxx.

{
    med_idt maaid, entid, geoid, dataset;
    char    chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
    char    nom_ent[MED_TAILLE_NOM_ENTITE+1];
    char    *nom_dataset;
    med_int  res = (-1);

    /* On inhibe le gestionnaire d'erreur HDF 5 */
    _MEDmodeErreurVerrouiller();

    /* Si le maillage n'existe pas => erreur */
    strcpy(chemin, MED_MAA);
    strcat(chemin, maa);
    maaid = _MEDdatagroupOuvrir(fid, chemin);
    if (maaid < 0) return(-1);

    switch (n) {
        case MED_FAM_NOEUD : {
            nom_dataset = MED_NOM_FAM;
            if (_MEDnomEntite(nom_ent, MED_NOEUD) < 0) return(-1);
            entid = _MEDdatagroupOuvrir(maaid, nom_ent);
            break;
        };
        case MED_FAM_ARETE : {
            nom_dataset = MED_NOM_FAM;
            if (_MEDnomEntite(nom_ent, MED_ARETE) < 0) return(-1);
            geoid = _MEDdatagroupOuvrir(maaid, nom_ent);
            if (geoid < 0) return(-1);
            if (_MEDnomGeometrie(nom_ent, MED_SEG2) < 0) return(-1);
            entid = _MEDdatagroupOuvrir(geoid, nom_ent);
            break;
        };
        case MED_FAM_FACE : {
            nom_dataset = MED_NOM_FAM;
            if (_MEDnomEntite(nom_ent, MED_FACE) < 0) return(-1);
            geoid = _MEDdatagroupOuvrir(maaid, nom_ent);
            if (geoid < 0) return(-1);
            if (_MEDnomGeometrie(nom_ent, MED_QUAD4) < 0) return(-1);
            entid = _MEDdatagroupOuvrir(geoid, nom_ent);
            break;
        };
        case MED_FAM_MAILLE : {
            nom_dataset = MED_NOM_FAM;
            if (_MEDnomEntite(nom_ent, MED_MAILLE) < 0) return(-1);
            geoid = _MEDdatagroupOuvrir(maaid, nom_ent);
            if (geoid < 0) return(-1);
            if (_MEDnomGeometrie(nom_ent, MED_HEXA8) < 0) return(-1);
            entid = _MEDdatagroupOuvrir(geoid, nom_ent);
            break;
        };
        case MED_GRID_NOEUD : {
            nom_dataset = MED_NOM_BOF;
            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
            break;
        };
        case MED_GRID_D1 : {
            nom_dataset = MED_NOM_IN1;
            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
            break;
        };
        case MED_GRID_D2 : {
            nom_dataset = MED_NOM_IN2;
            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
            break;
        };
        case MED_GRID_D3 : {
            nom_dataset = MED_NOM_IN3;
            entid = _MEDdatagroupOuvrir(maaid, MED_NOM_NOE);
            break;
        };
        default : {
            return(-1);
        };
    };

    if (entid < 0) return(-1);
    dataset = _MEDdatasetOuvrir(entid, nom_dataset);
    if (dataset < 0) return(-1);
    if (_MEDattrEntierLire(dataset, MED_NOM_NBR, &res) < 0) return(-1);

    /* On ferme tout */
    if (_MEDdatasetFermer(dataset) < 0) return(-1);
    if (_MEDdatagroupFermer(entid) < 0) return(-1);
    if (_MEDdatagroupFermer(maaid) < 0) return(-1);

    return(res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnMaa ( med_idt  fid)

Definition at line 27 of file MEDnMaa.cxx.

{
  int n;

  _MEDmodeErreurVerrouiller();
  
  n = 0;
  _MEDnObjets(fid,MED_MAA,&n);

  return (med_int) n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDnoeudsEcr ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coord,
med_mode_switch  mode_coo,
med_repere  repere,
char *  nomcoo,
char *  unicoo,
char *  nom,
med_booleen  inom,
med_int *  num,
med_booleen  inum,
med_int *  fam,
med_int  nnoeuds,
med_mode_acces  mode 
)

Definition at line 24 of file MEDnoeudsEcr.cxx.

{
  med_err ret;

  /* ecriture des coordonnees */
  if ((ret = MEDcoordEcr(fid,maa,mdim,coord,mode_coo,
                         nnoeuds,mode,repere,nomcoo,
                         unicoo)) < 0)
    return -1;

  /* ecriture des noms (facultatifs) */
  if (inom == MED_VRAI)
    if ((ret = MEDnomEcr(fid,maa,nom,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0)
      return -1;

  /* ecriture des numeros (facultatifs) */
  if (inum == MED_VRAI)
    if ((ret = MEDnumEcr(fid,maa,num,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0)
      return -1;

  /* ecriture des numeros de familles */
  if ((ret = MEDfamEcr(fid,maa,fam,nnoeuds,mode,MED_NOEUD,MED_POINT1)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDnoeudsLire ( med_idt  fid,
char *  maa,
med_int  mdim,
med_float *  coord,
med_mode_switch  mode_coo,
med_repere *  repere,
char *  nomcoo,
char *  unicoo,
char *  nom,
med_booleen *  inom,
med_int *  num,
med_booleen *  inum,
med_int *  fam,
med_int  nnoeuds 
)

Definition at line 25 of file MEDnoeudsLire.cxx.

{
  med_err ret;

  /* lecture des coordonnees */
  if ((ret = MEDcoordLire(fid,maa,mdim,coord,mode_coo,MED_ALL,0,MED_NOPF,repere,nomcoo,
                          unicoo)) < 0)
    return -1;

  /* lecture des noms (facultatifs) */
  if ((ret = MEDnomLire(fid,maa,nom,nnoeuds,MED_NOEUD,MED_POINT1)) < 0)
    *inom = MED_FAUX;
  else
    *inom = MED_VRAI;

  /* lecture des numeros (facultatifs) */
  if ((ret = MEDnumLire(fid,maa,num,nnoeuds,MED_NOEUD,MED_POINT1)) < 0)
    *inum = MED_FAUX;
  else
    *inum = MED_VRAI;  

  /* lecture des numeros de familles */
  if ((ret = MEDfamLire(fid,maa,fam,nnoeuds,MED_NOEUD,MED_POINT1)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDnomEcr ( med_idt  fid,
char *  maa,
char *  nom,
med_int  n,
med_mode_acces  mode,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 28 of file MEDnomEcr.cxx.

{
  med_idt root, maaid, entid, geoid, dataset;
  med_err ret;
  med_size dimd[1];
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;

   /*
    * Si le Data Group des entites n'existe pas on le cree
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     if ((entid = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
       return -1;

   /*
    * Pour les mailles, les faces et le aretes, on cree
    * s'il n'existe pas le Data Group du type geometrique
    */
   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
     {
       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
         return -1;

       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
         if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
           return -1;
     }
   else
     geoid = -1;

   /*
    * Creation du Data Set "NOM" 
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
   dimd[0] = n*MED_TAILLE_PNOM+1;
   if ((ret = _MEDdatasetStringEcrire(root,MED_NOM_NOM,dimd,nom,mode)) < 0)
     return -1;

  /*
   * Attribut NBR (nombre de noeuds)
   */
   if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NOM)) < 0)
     return -1;
   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
     return -1;

   /*
    * On ferme tout
    */
   if ((ret = _MEDdatasetFermer(dataset)) < 0)
     return -1;
   if (geoid > 0)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDnomLire ( med_idt  fid,
char *  maa,
char *  nom,
med_int  n,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 28 of file MEDnomLire.cxx.

{
  med_idt root, maaid, entid, geoid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;

   /*
    * Si le Data Group des entites n'existe pas => erreur
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     return -1;

   /*
    * Pour les mailles, les faces et le aretes,
    * on ouvre le Data Group du type geometrique
    */
   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
     {
       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
         return -1;
       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
           return -1;
     }
   else
     geoid = -1;

   /*
    * lecture du Data Set "NOM" 
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
   if ((ret = _MEDdatasetStringLire(root,MED_NOM_NOM,nom)) < 0)
     return -1;

   /*
    * On ferme tout
    */
   if (geoid > 0)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnPasdetemps ( med_idt  fid,
char *  cha,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 33 of file MEDnPasdetemps.cxx.

{
  med_err ret;
  int n1;
  char nomdatagroup1[MED_TAILLE_NOM+1];
  char tmp1         [MED_TAILLE_NOM_ENTITE+1];
  char chemin       [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+MED_TAILLE_NOM+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();
  
  /* 
   * Creation du chemin d'accès aux différents (PDT,NOR) pour les différents <type_ent>[.<type_geo>]
   */
  strcpy(chemin,MED_CHA);
  strcat(chemin,cha);
  strcat(chemin,"/");
 
  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
    return -1;
  if ((type_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
        return -1;
      strcat(nomdatagroup1,".");
      strcat(nomdatagroup1,tmp1);
    }
  strcat(chemin,nomdatagroup1);

  n1 =0;
  _MEDnObjets(fid,chemin,&n1);
      
  return (med_int) n1;

}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnProfil ( med_idt  fid)

Definition at line 25 of file MEDnProfil.cxx.

{
  int n;

  _MEDmodeErreurVerrouiller();

  n = 0;
  _MEDnObjets(fid,MED_PROFILS,&n);

  return (med_int) n;
}

Here is the call graph for this function:

med_err med_2_1::MEDnumEcr ( med_idt  fid,
char *  maa,
med_int *  num,
med_int  n,
med_mode_acces  mode,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 28 of file MEDnumEcr.cxx.

{
  med_idt root, maaid, entid, geoid, dataset;
  med_err ret;
  med_size dimd[1];
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller(); 

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;

   /*
    * Si le Data Group des entites n'existe pas on le cree
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     if ((root = _MEDdatagroupCreer(maaid,nom_ent)) < 0)
       return -1;

   /*
    * Pour les mailles, les faces et le aretes, on cree
    * s'il n'existe pas le Data Group du type geometrique
    */
   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
     {
       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
         return -1;

       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
         if ((geoid = _MEDdatagroupCreer(entid,nom_geo)) < 0)
           return -1;
     }
   else 
     geoid = -1;

   /*
    * Creation du Data Set "NUM" 
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
   dimd[0] = n;
#if defined(HAVE_F77INT64)
   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*) num,mode)) < 0)
     return -1;
#else
   if ((ret = _MEDdatasetNumEcrire(root,MED_NOM_NUM,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*) num,mode)) < 0)
     return -1;
#endif

  /*
   * Attribut NBR (nombre de noeuds)
   */
   if ((dataset = _MEDdatasetOuvrir(root,MED_NOM_NUM)) < 0)
     return -1;
   if ((ret = _MEDattrEntierEcrire(dataset,MED_NOM_NBR,&n,mode)) < 0)
     return -1;

   /*
    * On ferme tout
    */
   if ((ret = _MEDdatasetFermer(dataset)) < 0)
     return -1;
   if (geoid != -1)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1; 

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDnumLire ( med_idt  fid,
char *  maa,
med_int *  num,
med_int  n,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo 
)

Definition at line 28 of file MEDnumLire.cxx.

{
  med_idt root,maaid,entid,geoid;
  med_err ret;
  char chemin[MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nom_ent[MED_TAILLE_NOM_ENTITE+1];
  char nom_geo[MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller(); 

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * On met a jour le nom du Data Group representant
   * le type des entites
   */
   if ((ret = _MEDnomEntite(nom_ent,type_ent)) < 0)
     return -1;

   /*
    * Si le Data Group des entites n'existe pas => erreur
    */
   if ((entid = _MEDdatagroupOuvrir(maaid,nom_ent)) < 0)
     return -1;

   /*
    * Pour les mailles, les faces et le aretes, 
    * si le Data Group du type geometrique => erreur
    */
   if ((type_ent==MED_MAILLE)||(type_ent==MED_FACE)||(type_ent==MED_ARETE))
     {
       if ((ret = _MEDnomGeometrie(nom_geo,type_geo)) < 0)
         return -1;
       if ((geoid = _MEDdatagroupOuvrir(entid,nom_geo)) < 0)
         return -1;
     }
   else 
     geoid = -1;

   /*
    * lecture du Data Set "NUM" 
    */
   if (geoid == -1)
     root = entid;
   else
     root = geoid;
#if defined(HAVE_F77INT64)
   if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT64,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char*) num)) < 0)
     return -1;
#else
   if ((ret = _MEDdatasetNumLire(root,MED_NOM_NUM,MED_INT32,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char*) num)) < 0)
     return -1;
#endif

   /*
    * On ferme tout
    */
   if (geoid != -1)
     if ((ret = _MEDdatagroupFermer(geoid)) < 0)
       return -1;
   if ((ret = _MEDdatagroupFermer(entid)) < 0)
     return -1;
   if ((ret = _MEDdatagroupFermer(maaid)) < 0)
     return -1;

  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnVal ( med_idt  fid,
char *  champ,
med_entite_maillage  typ_ent,
med_geometrie_element  typ_geo,
med_int  numdt,
med_int  numo 
)

Definition at line 27 of file MEDnVal.cxx.

{
  med_int n;
  med_idt datagroup;
  med_err ret;
  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
  char tmp1   [MED_TAILLE_NOM_ENTITE+1];
  char chemin [MED_TAILLE_CHA+(MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+(2*MED_MAX_PARA)+1+100];

  /*
   * On inhibe le gestionnaire d'erreur HDF 
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On cree le chemin d'accès
   */
  strcpy(chemin,MED_CHA);
  strcat(chemin,champ);
  strcat(chemin,"/");

  /* On cree le nom du datagroup de niveau 1 */
  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
    return -1;
  if ((type_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
        return -1;
      strcat(nomdatagroup1,".");
      strcat(nomdatagroup1,tmp1);
    }
  strcat(chemin,nomdatagroup1);
  strcat(chemin,"/");

  /* Creation du datagroup de niveau 2 <numdt>.<numoo> */
  sprintf(nomdatagroup2,"%*li%*li",MED_MAX_PARA,(long ) numdt,MED_MAX_PARA,(long ) numo);
  strcat(chemin,nomdatagroup2);
 
 /*
   * Acces au champ
  */
  if ((datagroup = _MEDdatagroupOuvrir(fid,chemin)) < 0) 
    return 0;
  if ((ret = _MEDattrEntierLire(datagroup,MED_NOM_NBR,&n)) < 0)
    return -1;

  /*
   * fermetures 
   */
  if ((ret = _MEDdatagroupFermer(datagroup)) < 0)
    return -1;
 
  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_int med_2_1::MEDnValProfil ( med_idt  fid,
char *  nom 
)

Definition at line 28 of file MEDnValProfil.cxx.

{
  med_int n = 0;
  med_idt pid;
  char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; 
  med_err ret;
  
  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * ouverture du groupe /PROFILS/"nom"
   */  
  strcpy(chemin,MED_PROFILS);
  strcat(chemin,nom); 
  if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  if ((ret = _MEDattrEntierLire(pid,MED_NOM_N,&n)) < 0)
    return ret;

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatagroupFermer(pid)) < 0)
    return -1; 

  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_idt med_2_1::MEDouvrir ( char *  nom,
med_mode_acces  mode_acces 
)

Definition at line 34 of file MEDouvrir.cxx.

{
  med_idt fid; 

  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On ouvre le fichier MED sous HDF
   */
  switch(mode_acces)
    {
    case MED_LECT :
      if (access(nom,F_OK))
              return -1;
      else 
              if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0)
                return -1;
      break;

    case MED_ECRI :
      if (access(nom,F_OK))
        {
          if ((fid = _MEDfichierCreer(nom)) < 0)
            return -1;
        }
      else
        if ((fid = _MEDfichierOuvrir(nom,mode_acces)) < 0)
          return -1;
      break;

    case MED_REMP :
      if ((fid = _MEDfichierCreer(nom)) < 0)
        return -1;
      break;

    default :
      return -1;
    }

  return fid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDpasdetempsInfo ( med_idt  fid,
char *  champ,
med_entite_maillage  type_ent,
med_geometrie_element  type_geo,
int  indice,
char *  maa,
med_int *  ngauss,
med_int *  numdt,
char *  dt_unit,
med_float *  dt,
med_int *  numo 
)

Definition at line 29 of file MEDpasdetempsInfo.cxx.

{

  med_err ret=0;
  med_idt gid;
  char chemin[(MED_TAILLE_CHA+MED_TAILLE_NOM+1)+(2*MED_TAILLE_NOM_ENTITE+2)+2*MED_MAX_PARA+1];
  int num;
  char nomdatagroup1[2*MED_TAILLE_NOM_ENTITE+2],nomdatagroup2[2*MED_MAX_PARA+1];
  char tmp1         [MED_TAILLE_NOM_ENTITE+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On recupere le nom du datagroup <numdtt>.<numoo>
   */
  strcpy(chemin,MED_CHA);
  strcat(chemin,champ);
  strcat(chemin,"/");

  if ((ret = _MEDnomEntite(nomdatagroup1,type_ent)) < 0)
    return -1;
  if ((type_ent != MED_NOEUD))
    {
      if ((ret = _MEDnomGeometrie(tmp1,type_geo)) < 0)
        return -1;
      strcat(nomdatagroup1,".");
      strcat(nomdatagroup1,tmp1);
    }
  strcat(chemin,nomdatagroup1);
  strcat(chemin,"/");

  num = indice - 1;
  if ((ret = _MEDobjetIdentifier(fid,chemin,num,nomdatagroup2)) < 0)
    return -1;
  strcat(chemin,nomdatagroup2);
  if ((gid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * La liste des attributs
   */
 if ((ret = _MEDattrStringLire(gid,MED_NOM_MAI,MED_TAILLE_NOM,maa)) < 0)
    return -1;
  
 if ((ret = _MEDattrEntierLire(gid,MED_NOM_NDT,(med_int*) numdt)) < 0)
   return -1;

 if ((ret = _MEDattrFloatLire(gid,MED_NOM_PDT,(med_float*) dt)) < 0)
   return -1;

 if ((ret = _MEDattrStringLire(gid,MED_NOM_UNI,MED_TAILLE_PNOM,dt_unit)) < 0)
   return -1;
 
 if ((ret = _MEDattrEntierLire(gid,MED_NOM_NOR,(med_int*) numo)) < 0)
   return -1;

 if ( (ret = _MEDattrEntierLire(gid,MED_NOM_NGA,ngauss)) < 0 )
   return -1;


 if ((ret = _MEDdatagroupFermer(gid)) < 0)
   return -1;
 
  return 0; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDprofilEcr ( med_idt  fid,
med_int *  pflval,
med_int  n,
char *  nom 
)

Definition at line 28 of file MEDprofilEcr.cxx.

{
  med_idt root, pid;
  med_size dimd[1];
  med_err ret;
  char chemin[MED_TAILLE_PROFILS+1];

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * 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 ((root = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    if ((root = _MEDdatagroupCreer(fid,chemin)) < 0)
      return -1;

  /* 
   * Si le groupe "nom" n'existe pas, on le cree
   * Sinon => erreur
   */
  if ((pid = _MEDdatagroupOuvrir(root,nom)) >= 0)
    return -1;
  if ((pid = _MEDdatagroupCreer(root,nom)) < 0)
    return -1;

  /*
   * On stocke "n" sous forme d'attribut
   */
  if ((ret = _MEDattrEntierEcrire(pid,MED_NOM_N,&n,MED_REMP)) < 0)
    return -1;

  /*
   * On stocke le profil dans un dataset
   */
  dimd[0] = n;
#if defined(HAVE_F77INT64)
  if ((ret =  _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT64,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*) pflval,MED_REMP)) < 0)
    return -1;
#else
  if ((ret =  _MEDdatasetNumEcrire(pid,MED_NOM_PFL,MED_INT32,MED_NO_INTERLACE,MED_DIM1,MED_ALL,MED_NOPF,0,MED_NOPG,dimd,
                                (unsigned char*) pflval,MED_REMP)) < 0)
    return -1;
#endif

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatagroupFermer(pid)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(root)) < 0)
    return -1;

  return 0; 
}

Here is the call graph for this function:

med_err med_2_1::MEDprofilInfo ( med_idt  fid,
int  indice,
char *  profil,
med_int *  n 
)

Definition at line 28 of file MEDprofilInfo.cxx.

{
  int numero;
  med_idt proid;
  med_err ret;
  char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1];

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On recupere le nom du groupe de rang "indice"
   */ 
  numero = indice-1;
  if ((ret = _MEDobjetIdentifier(fid,MED_PROFILS,numero,profil)) < 0)
    return -1;

  /*
   * On va chercher l'attribut taille du profil 
   */
  strcpy(chemin,MED_PROFILS);
  strcat(chemin,profil);
  if ((proid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;   
  if ((ret = _MEDattrEntierLire(proid,MED_NOM_N,n)) < 0)
    return -1;
  if ((ret = _MEDdatagroupFermer(proid)) < 0)
    return -1;

  return 0;
}

Here is the call graph for this function:

med_err med_2_1::MEDprofilLire ( med_idt  fid,
med_int *  pflval,
char *  nom 
)

Definition at line 28 of file MEDprofilLire.cxx.

{
  med_err ret = 0;
  med_idt pid;
  char chemin[MED_TAILLE_PROFILS+MED_TAILLE_NOM+1]; 

  /*
   * On inhibe le gestionnaire d'erreur HDF 5
   */
  _MEDmodeErreurVerrouiller();

  /* 
   * ouverture du groupe /PROFILS/"nom"
   */  
  strcpy(chemin,MED_PROFILS);
  strcat(chemin,nom); 
  if ((pid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
    return -1;

  /*
   * Lecture du profil
   */
#if defined(HAVE_F77INT64)
  if ((ret =  _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT64,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char *) pflval)) < 0)
    return -1;
#else
  if ((ret =  _MEDdatasetNumLire(pid,MED_NOM_PFL,MED_INT32,
                                 MED_NO_INTERLACE,1,MED_ALL,
                                 MED_NOPF,0,MED_NOPG,
                                 (unsigned char *) pflval)) < 0)
    return -1;
#endif

  /*
   * On ferme tout
   */
  if ((ret = _MEDdatagroupFermer(pid)) < 0)
    return -1; 

  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDunvCr ( med_idt  fid,
char *  maa 
)

Definition at line 41 of file MEDunvCr.cxx.

{
  med_idt maaid;
  char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  char nomu   [MED_TAILLE_LNOM+1];    
  time_t  temps;
//#ifdef PPRO_NT
#ifdef WIN32
  struct timeb   tp;
  char   lpBuffer [UNLEN+1];
  long   nSize   = UNLEN+1;
#else
  struct timeval tp;
#endif 
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Creation/Ecriture de l'attribut nom universel 
   */
  
//#ifdef PPRO_NT
#ifdef WIN32
  if ( GetUserName(lpBuffer,LPDWORD(&nSize)) == 0 ) return -1;
  if ( nSize > MED_TAILLE_NOM ) nSize = MED_TAILLE_NOM;
  strncpy(nomu,lpBuffer,nSize);
  strcat(nomu," ");
  temps=time(&temps);
  strcat(nomu,ctime(&temps));
  ftime(&tp);
  nSize = (long)strlen(nomu)-1;
  if ( sprintf(&nomu[nSize]," %hu",tp.millitm) < 0 ) return -1;
#else
  if (cuserid(nomu) == (void*) NULL) return -1;
  strcat(nomu," ");
  temps=time(&temps);
  strcat(nomu,ctime(&temps));
  if ( gettimeofday(&tp,NULL) < 0 ) return -1;
  if ( sprintf(&nomu[strlen(nomu)-1]," %li",tp.tv_usec) < 0 ) return -1;
#endif
  if ((ret = _MEDattrStringEcrire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,nomu,MED_REMP)) < 0) 
    return -1;

  /* 
   * Nettoyages divers
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDunvLire ( med_idt  fid,
char *  maa,
char *  nomu 
)

Definition at line 31 of file MEDunvLire.cxx.

{
  med_idt maaid;
  char chemin [MED_TAILLE_MAA+MED_TAILLE_NOM+1];
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur
   */
  _MEDmodeErreurVerrouiller();

  /*
   * Si le maillage n'existe pas => erreur
   */
  strcpy(chemin,MED_MAA);
  strcat(chemin,maa);
  if ((maaid = _MEDdatagroupOuvrir(fid,chemin)) < 0)
      return -1;

  /*
   * Creation/Ecriture de l'attribut nom universel 
   */
  if ((ret = _MEDattrStringLire(maaid,MED_NOM_UNV,MED_TAILLE_LNOM,
                               nomu )) < 0)
    return -1;

  /* 
   * Nettoyages divers
   */
  if ((ret = _MEDdatagroupFermer(maaid)) < 0)
    return -1;
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

med_err med_2_1::MEDversionConforme ( const char *  nom)

Definition at line 25 of file MEDversionConforme.cxx.

                                    {
  med_int majeur, mineur;
  med_idt fid, gid;
  med_err ret;

  /*
   * On inhibe le gestionnaire d'erreur HDF
   */
  _MEDmodeErreurVerrouiller();

  /*
   * On ouvre le fichier MED en mode MED_LECT
   */     
  if ((fid = _MEDfichierOuvrir((char *)nom,MED_LECT)) < 0)
    return -1;
  
  /*
   * Lecture du numero de version 
   */
  if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) 
    return -1;
  
  if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,&majeur)) < 0)
    return -1;
  
  if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,&mineur)) < 0)
    return -1;                                                  
  
  /* 
   * On ferme tout 
   */
  if ((ret = _MEDdatagroupFermer(gid)) < 0)
    return -1;
  
  if ((ret = _MEDfichierFermer(fid)) < 0)
    return -1;
  
  if ((majeur == MED_NUM_MAJEUR) && (mineur == MED_NUM_MINEUR))
    return 0;
  else
    return -1;
}

Here is the call graph for this function:

void med_2_1::MEDversionDonner ( med_int *  majeur,
med_int *  mineur,
med_int *  release 
)

Definition at line 25 of file MEDversionDonner.cxx.

                                                                     {
  *majeur = MED_NUM_MAJEUR;
  *mineur = MED_NUM_MINEUR;
  *release = MED_NUM_RELEASE;
}

Here is the caller graph for this function:

med_err med_2_1::MEDversionLire ( med_idt  fid,
med_int *  majeur,
med_int *  mineur,
med_int *  release 
)

Definition at line 25 of file MEDversionLire.cxx.

{
  med_err ret = 0;
  med_idt gid;  

  /* On ouvre le group ou se trouvent les infos */
  if ((gid = _MEDdatagroupOuvrir(fid,MED_NOM_INFOS)) < 0) {
    *majeur = 2;
    *mineur = -1;
    *release = -1;
    ret = 0;
  }
  else {
    if ((ret = _MEDattrEntierLire(gid,MED_NOM_MAJEUR,majeur)) < 0)
      return -1;

    if ((ret = _MEDattrEntierLire(gid,MED_NOM_MINEUR,mineur)) < 0)
      return -1;

    if ((ret = _MEDattrEntierLire(gid,MED_NOM_RELEASE,release)) < 0)
      return -1;

    /* On ferme tout */
    if ((ret = _MEDdatagroupFermer(gid)) < 0)
      return -1;
  }                                                     

  return ret;
}

Here is the call graph for this function: