Back to index

salome-med  6.5.0
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
MED Namespace Reference

Namespaces

namespace  TShapeFun
namespace  V2_1
namespace  V2_2

Classes

protocol  MEDWRAPPER_EXPORT
 Define a helper class to handle Gauss Points coordinates. More...
struct  TGaussDef
 Description of family of integration points. More...
struct  TSeg2a
struct  TSeg3a
struct  TTria3a
struct  TTria6a
struct  TTria3b
struct  TTria6b
struct  TQuad4a
struct  TQuad8a
struct  TQuad9a
struct  TQuad4b
struct  TQuad8b
struct  TQuad9b
struct  TTetra4a
struct  TTetra10a
struct  TTetra4b
struct  TTetra10b
struct  THexa8a
struct  THexa20a
struct  THexa27a
struct  THexa8b
struct  THexa20b
struct  TPenta6a
struct  TPenta6b
struct  TPenta15a
struct  TPenta15b
struct  TPyra5a
struct  TPyra5b
struct  TPyra13a
struct  TPyra13b
class  SharedPtr
 To extend the boost::shared_ptr to support such features automatic dynamic cast. More...
class  TCSlice
 This class intends to provide an uniform way to handle multy-dimention data (const version) More...
class  TSlice
 This class extend TCSlice functionality for non-constant case. More...
struct  TTMeshValue
 The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp. More...
struct  TTimeStampValue
 The class implements a container for MED TimeStamp values. More...
struct  TValueHolder
 To provide a common way to handle values of MEDWrapper types as native MED types. More...
struct  TValueHolder< TVector< TVal >, TRepresentation >
 To customize TValueHolder common template definition for TVector. More...
struct  TTNameInfo
struct  TTMeshInfo
struct  TTFamilyInfo
struct  TTElemInfo
struct  TTNodeInfo
struct  TTPolygoneInfo
struct  TTPolyedreInfo
struct  TTCellInfo
struct  TTFieldInfo
struct  TTGaussInfo
struct  TTTimeStampInfo
struct  TTProfileInfo
struct  TTTimeStampValue
struct  TTGrilleInfo
class  TTWrapper
class  TVector
 Main purpose to introduce the class was to customize operator []. More...
protocol  MEDWRAPPER_EXPORT< TWrapper >
 To specialize the SharedPtr for TWrapper. More...

Typedefs

typedef std::map
< EGeometrieElement, PElemInfo
TGeom2ElemInfo
typedef std::map
< EEntiteMaillage,
TGeom2ElemInfo
TEntity2TGeom2ElemInfo
typedef std::set< PFamilyInfoTFamilyInfoSet
typedef boost::tuple
< PFamilyInfo, TInt
TFamilyTSize
typedef std::set< TFamilyTSizeTFamilyTSizeSet
typedef std::map
< EEntiteMaillage,
TFamilyTSizeSet
TEntity2FamilySet
typedef std::map< std::string,
TFamilyInfoSet
TGroupInfo
typedef std::set< PTimeStampInfoTTimeStampInfoSet
typedef std::map< PFieldInfo,
TTimeStampInfoSet
TFieldInfo2TimeStampInfoSet
typedef std::map
< EEntiteMaillage,
TFieldInfo2TimeStampInfoSet
TEntite2TFieldInfo2TimeStampInfoSet
typedef std::map
< TGaussInfo::TKey, PGaussInfo,
TGaussInfo::TLess > 
TKey2Gauss
typedef std::map
< TProfileInfo::TKey,
PProfileInfo
TKey2Profile
typedef boost::tuple
< EModeProfil, TKey2Profile
TMKey2Profile
typedef std::map< TInt, TIntTFamilyID2NbCells
typedef double TFloat
typedef int TInt
typedef hid_t TIdt
typedef herr_t TErr
typedef TVector< TFloatTFloatVector
typedef TVector< std::string > TStringVector
typedef TVector< TIntTIntVector
typedef std::set< std::string > TStringSet
typedef std::map
< EGeometrieElement, TInt
TGeom2Size
typedef std::map
< EEntiteMaillage, TGeom2Size
TEntityInfo
typedef std::set
< EGeometrieElement
TGeomSet
typedef std::map
< EEntiteMaillage, TGeomSet
TEntity2GeomSet
typedef SharedPtr< TNameInfo > PNameInfo
typedef SharedPtr< TMeshInfo > PMeshInfo
typedef SharedPtr< TFamilyInfo > PFamilyInfo
typedef SharedPtr< TElemInfo > PElemInfo
typedef SharedPtr< TNodeInfo > PNodeInfo
typedef SharedPtr< TPolygoneInfo > PPolygoneInfo
typedef SharedPtr< TPolyedreInfo > PPolyedreInfo
typedef SharedPtr< TCellInfo > PCellInfo
typedef SharedPtr< TFieldInfo > PFieldInfo
typedef SharedPtr< TTimeStampInfo > PTimeStampInfo
typedef SharedPtr< TProfileInfo > PProfileInfo
typedef SharedPtr< TGaussInfo > PGaussInfo
typedef SharedPtr< TGrilleInfo > PGrilleInfo
typedef SharedPtr
< TTimeStampValueBase > 
PTimeStampValueBase
typedef SharedPtr< TWrapperPWrapper
typedef TFloat(* TGetCoord )(const TCCoordSlice &theCoordSlice)
typedef SharedPtr< TCoordHelper > PCoordHelper
typedef std::vector< double > TDoubleVector
typedef TVector< TCCoordSliceTCCoordSliceArr
typedef TVector< TCoordSliceTCoordSliceArr
typedef SharedPtr< TGaussCoord > PGaussCoord
typedef TVector< char > TString
 Defines a type for managing sequence of strings.
typedef SharedPtr< TStringPString
typedef TSlice< TIntTIntVecSlice
typedef TCSlice< TIntTCIntVecSlice
typedef TIntVector TFamAttr
typedef TIntVector TElemNum
typedef SharedPtr< TElemNumPElemNum
typedef TSlice< TFloatTFloatVecSlice
typedef TCSlice< TFloatTCFloatVecSlice
typedef TFloatVector TNodeCoord
typedef SharedPtr< TNodeCoordPNodeCoord
typedef TFloatVecSlice TCoordSlice
typedef TCFloatVecSlice TCCoordSlice
typedef TIntVecSlice TConnSlice
typedef TCIntVecSlice TCConnSlice
typedef TVector< TCConnSliceTCConnSliceArr
typedef TVector< TConnSliceTConnSliceArr
typedef TFloatVector TWeight
typedef std::map
< EGeometrieElement,
PGaussInfo
TGeom2Gauss
typedef std::map
< EGeometrieElement, TInt
TGeom2NbGauss
typedef TTMeshValue< TFloatVectorTFloatMeshValue
typedef TTMeshValue< TIntVectorTIntMeshValue
typedef TFloatVector TValue
typedef TSlice< TFloatTValueSlice
typedef TCSlice< TFloatTCValueSlice
typedef TVector< TCValueSliceTCValueSliceArr
typedef TVector< TValueSliceTValueSliceArr
typedef TFloatMeshValue TMeshValue
typedef std::map
< EGeometrieElement,
TMeshValue
TGeom2Value
typedef std::map
< EGeometrieElement,
PProfileInfo
TGeom2Profile
typedef std::set
< EGeometrieElement
TGeom
typedef TTimeStampValue
< TFloatMeshValue
TFloatTimeStampValue
typedef SharedPtr
< TFloatTimeStampValue
PFloatTimeStampValue
typedef TTimeStampValue
< TIntMeshValue
TIntTimeStampValue
typedef SharedPtr
< TIntTimeStampValue
PIntTimeStampValue
typedef TFloatTimeStampValue TTimeStampVal
typedef PFloatTimeStampValue PTimeStampVal
typedef std::map< TInt,
TFloatVector
TIndexes
typedef std::map< TInt, TStringTNames

Enumerations

enum  EVersion { eVUnknown = -1, eV2_1, eV2_2 }
enum  EBooleen { eFAUX, eVRAI }
enum  EModeSwitch { eFULL_INTERLACE, eNO_INTERLACE }
enum  ETypeChamp { eFLOAT64 = 6, eINT = 26 }
enum  EMaillage { eNON_STRUCTURE, eSTRUCTURE }
enum  ERepere { eCART, eCYL, eSPHER }
enum  EConnectivite { eNOD, eDESC }
enum  EGeometrieElement {
  ePOINT1 = 1, eSEG2 = 102, eSEG3 = 103, eTRIA3 = 203,
  eQUAD4 = 204, eTRIA6 = 206, eQUAD8 = 208, eQUAD9 = 209,
  eTETRA4 = 304, ePYRA5 = 305, ePENTA6 = 306, eHEXA8 = 308,
  eOCTA12 = 312, eTETRA10 = 310, ePYRA13 = 313, ePENTA15 = 315,
  eHEXA20 = 320, eHEXA27 = 327, ePOLYGONE = 400, ePOLYEDRE = 500,
  eNONE = 0
}
enum  EEntiteMaillage {
  eMAILLE, eFACE, eARETE, eNOEUD,
  eNOEUD_ELEMENT
}
enum  EModeProfil { eNO_PFLMOD, eGLOBAL, eCOMPACT }
enum  EGrilleType { eGRILLE_CARTESIENNE, eGRILLE_POLAIRE, eGRILLE_STANDARD }
enum  ETable {
  eCOOR, eCONN, eNOM, eNUM,
  eFAM, eCOOR_IND1, eCOOR_IND2, eCOOR_IND3
}
enum  ECoordName { eX, eY, eZ, eNone }

Functions

TEntity2TGeom2ElemInfo GetEntity2TGeom2ElemInfo (const PWrapper &theWrapper, const PMeshInfo &theMeshInfo, const MED::TEntityInfo &theEntityInfo)
 Get set of TElemInfo by its geometrical type and corresponding MED ENTITY.
TFamilyInfoSet GetFamilyInfoSet (const PWrapper &theWrapper, const PMeshInfo &theMeshInfo)
 Read set of MED FAMILIES for defined MED file.
TGroupInfo GetGroupInfo (const TFamilyInfoSet &theFamilyInfoSet)
 Split the input set of MED FAMILIES by corresponding MED GROUPS.
TFieldInfo2TimeStampInfoSet GetFieldInfo2TimeStampInfoSet (const PWrapper &theWrapper, const PMeshInfo &theMeshInfo, const MED::TEntityInfo &theEntityInfo)
 Read set of MED TIMESTAMPS groupped by corresponding MED FIELDS.
TEntite2TFieldInfo2TimeStampInfoSet GetEntite2TFieldInfo2TimeStampInfoSet (const TFieldInfo2TimeStampInfoSet &theFieldInfo2TimeStampInfoSet)
 Split the input set of MED TIMESTAMPS by corresponding MED FIELDS and MED ENTITIES.
bool operator< (const TFamilyTSize &theLeft, const TFamilyTSize &theRight)
TEntity2FamilySet GetEntity2FamilySet (const PWrapper &theWrapper, const TEntity2TGeom2ElemInfo &theEntity2TGeom2ElemInfo, const TFamilyInfoSet &theFamilyInfoSet)
 Split set of MED FAMILIES by corresponding MED ENTITY.
TKey2Gauss GetKey2Gauss (const PWrapper &theWrapper, TErr *theErr=NULL, EModeSwitch theMode=eFULL_INTERLACE)
 Read set of MED GAUSS.
PProfileInfo GetProfileInfo (const PWrapper &theWrapper, const std::string &theProfileName, TErr *theErr=NULL, EModeProfil theMode=eCOMPACT)
 Get MED PROFILE by its name.
TMKey2Profile GetMKey2Profile (const PWrapper &theWrapper, TErr *theErr=NULL, EModeProfil theMode=eCOMPACT)
 Read set of MED PROFILES.
EEntiteMaillage GetEntityByFamilyId (PGrilleInfo &theInfo, TInt theId)
 Get Entity for Grille by family id.
TFamilyID2NbCells GetFamilyID2NbCells (PGrilleInfo &theInfo)
 Get Number of cells for theId family, for Grille.
EEntiteMaillage ConvertEntity (const EEntiteMaillage &aEntity)
 Convert eNOEUD_ELEMENT to eMAILLE.
MEDWRAPPER_EXPORT const
TEntity2GeomSet
GetEntity2GeomSet ()
template<EVersion >
TInt MEDWRAPPER_EXPORT GetDESCLength ()
template<EVersion >
TInt MEDWRAPPER_EXPORT GetIDENTLength ()
template<EVersion >
TInt MEDWRAPPER_EXPORT GetNOMLength ()
template<EVersion >
TInt MEDWRAPPER_EXPORT GetLNOMLength ()
template<EVersion >
TInt MEDWRAPPER_EXPORT GetPNOMLength ()
template<EVersion >
void MEDWRAPPER_EXPORT GetVersionRelease (TInt &majeur, TInt &mineur, TInt &release)
template<EVersion >
MEDWRAPPER_EXPORT TInt GetNbConn (EGeometrieElement typmai, EEntiteMaillage typent, TInt mdim)
MEDWRAPPER_EXPORT TInt GetNbNodes (EGeometrieElement typmai)
template<ECoordName TCoordId>
TFloat GetCoord (const TCCoordSlice &theCoordSlice)
template<>
TFloat GetCoord< eNone > (const TCCoordSlice &theCoordSlice)
PCoordHelper GetCoordHelper (PNodeInfo theNodeInfo)
bool IsEqual (TFloat theLeft, TFloat theRight)
bool GetGaussCoord3D (const TGaussInfo &theGaussInfo, const TCellInfo &theCellInfo, const TNodeInfo &theNodeInfo, TGaussCoord &theGaussCoord, const TElemNum &theElemNum=TElemNum(), EModeSwitch theMode=eFULL_INTERLACE)
 To calculate Gauss Points coordinates.
bool GetBaryCenter (const TCellInfo &theCellInfo, const TNodeInfo &theNodeInfo, TGaussCoord &theGaussCoord, const TElemNum &theElemNum=TElemNum(), EModeSwitch theMode=eFULL_INTERLACE)
 To calculate Gauss Points coordinates for defined TCellInfo as its bary center.
bool GetBaryCenter (const TPolygoneInfo &thePolygoneInfo, const TNodeInfo &theNodeInfo, TGaussCoord &theGaussCoord, const TElemNum &theElemNum=TElemNum(), EModeSwitch theMode=eFULL_INTERLACE)
 To calculate Gauss Points coordinates for defined TPolygoneInfo as its bary center.
bool GetBaryCenter (const TPolyedreInfo &thePolyedreInfo, const TNodeInfo &theNodeInfo, TGaussCoord &theGaussCoord, const TElemNum &theElemNum=TElemNum(), EModeSwitch theMode=eFULL_INTERLACE)
 To calculate Gauss Points coordinates for defined TPolyedreInfo as its bary center.
std::string GetString (TInt theId, TInt theStep, const TString &theString)
 Extract a substring from the sequence of the strings.
void SetString (TInt theId, TInt theStep, TString &theString, const std::string &theValue)
 Set a substring in the sequence of the strings.
void SetString (TInt theId, TInt theStep, TString &theString, const TString &theValue)
 Set a substring in the sequence of the strings.
TInt GetDimGaussCoord (EGeometrieElement theGeom)
 Get dimension of the Gauss coordinates for the defined type of mesh cell.
TInt GetNbRefCoord (EGeometrieElement theGeom)
 Get number of referenced nodes for the defined type of mesh cell.
PFloatTimeStampValue CastToFloatTimeStampValue (const PTimeStampValueBase &theTimeStampValue)
PIntTimeStampValue CastToIntTimeStampValue (const PTimeStampValueBase &theTimeStampValue)
template<class TMeshValueTypeFrom , class TMeshValueTypeTo >
void CopyTimeStampValue (SharedPtr< TTimeStampValue< TMeshValueTypeFrom > > theTimeStampValueFrom, SharedPtr< TTimeStampValue< TMeshValueTypeTo > > theTimeStampValueTo)
template<class TMeshValueType >
void CopyTimeStampValue (SharedPtr< TTimeStampValue< TMeshValueType > > theTimeStampValueFrom, SharedPtr< TTimeStampValue< TMeshValueType > > theTimeStampValueTo)
void CopyTimeStampValueBase (const PTimeStampValueBase &theValueFrom, const PTimeStampValueBase &theValueTo)
template<class TimeStampValueType >
void Print (SharedPtr< TimeStampValueType > theTimeStampValue)
EVersion GetVersionId (const std::string &theFileName, bool theDoPreCheckInSeparateProcess)
bool getMEDVersion (const std::string &fname, int &major, int &minor, int &release)
PWrapper CrWrapper (const std::string &theFileName, bool theDoPreCheckInSeparateProcess)
PWrapper CrWrapper (const std::string &theFileName, EVersion theId)
template<>
TInt GetDESCLength< eV2_1 > ()
template<>
TInt GetIDENTLength< eV2_1 > ()
template<>
TInt GetLNOMLength< eV2_1 > ()
template<>
TInt GetNOMLength< eV2_1 > ()
template<>
TInt GetPNOMLength< eV2_1 > ()
template<>
void GetVersionRelease< eV2_1 > (TInt &majeur, TInt &mineur, TInt &release)
template<>
TInt GetNbConn< eV2_1 > (EGeometrieElement typmai, EEntiteMaillage typent, TInt mdim)
template<>
TInt GetDESCLength< eV2_2 > ()
template<>
TInt GetIDENTLength< eV2_2 > ()
template<>
TInt GetNOMLength< eV2_2 > ()
template<>
TInt GetLNOMLength< eV2_2 > ()
template<>
TInt GetPNOMLength< eV2_2 > ()
template<>
void GetVersionRelease< eV2_2 > (TInt &majeur, TInt &mineur, TInt &release)
template<>
TInt GetNbConn< eV2_2 > (EGeometrieElement typmai, EEntiteMaillage typent, TInt mdim)

Variables

TGetCoord aXYZGetCoord [3]
TGetCoord aXYGetCoord [3]
TGetCoord aYZGetCoord [3]
TGetCoord aXZGetCoord [3]
TGetCoord aXGetCoord [3]
TGetCoord aYGetCoord [3]
TGetCoord aZGetCoord [3]

Typedef Documentation

typedef SharedPtr<TCellInfo> MED::PCellInfo

Definition at line 160 of file MED_Common.hxx.

typedef SharedPtr<TCoordHelper> MED::PCoordHelper

Definition at line 52 of file MED_CoordUtils.hxx.

typedef SharedPtr<TElemInfo> MED::PElemInfo

Definition at line 148 of file MED_Common.hxx.

Definition at line 187 of file MED_Structures.hxx.

typedef SharedPtr<TFamilyInfo> MED::PFamilyInfo

Definition at line 145 of file MED_Common.hxx.

typedef SharedPtr<TFieldInfo> MED::PFieldInfo

Definition at line 163 of file MED_Common.hxx.

Definition at line 884 of file MED_Structures.hxx.

typedef SharedPtr<TGaussCoord> MED::PGaussCoord

Definition at line 84 of file MED_GaussUtils.hxx.

typedef SharedPtr<TGaussInfo> MED::PGaussInfo

Definition at line 172 of file MED_Common.hxx.

typedef SharedPtr<TGrilleInfo> MED::PGrilleInfo

Definition at line 175 of file MED_Common.hxx.

Definition at line 890 of file MED_Structures.hxx.

typedef SharedPtr<TMeshInfo> MED::PMeshInfo

Definition at line 142 of file MED_Common.hxx.

typedef SharedPtr<TNameInfo> MED::PNameInfo

Definition at line 139 of file MED_Common.hxx.

Definition at line 244 of file MED_Structures.hxx.

typedef SharedPtr<TNodeInfo> MED::PNodeInfo

Definition at line 151 of file MED_Common.hxx.

typedef SharedPtr<TPolyedreInfo> MED::PPolyedreInfo

Definition at line 157 of file MED_Common.hxx.

typedef SharedPtr<TPolygoneInfo> MED::PPolygoneInfo

Definition at line 154 of file MED_Common.hxx.

typedef SharedPtr<TProfileInfo> MED::PProfileInfo

Definition at line 169 of file MED_Common.hxx.

Definition at line 44 of file MED_Structures.hxx.

typedef SharedPtr<TTimeStampInfo> MED::PTimeStampInfo

Definition at line 166 of file MED_Common.hxx.

Definition at line 963 of file MED_Structures.hxx.

typedef SharedPtr<TTimeStampValueBase> MED::PTimeStampValueBase

Definition at line 178 of file MED_Common.hxx.

Definition at line 181 of file MED_Common.hxx.

Definition at line 283 of file MED_Structures.hxx.

Definition at line 345 of file MED_Structures.hxx.

Definition at line 247 of file MED_Structures.hxx.

Definition at line 38 of file MED_GaussUtils.hxx.

Definition at line 241 of file MED_Structures.hxx.

Definition at line 132 of file MED_Structures.hxx.

Definition at line 282 of file MED_Structures.hxx.

Definition at line 346 of file MED_Structures.hxx.

Definition at line 246 of file MED_Structures.hxx.

Definition at line 39 of file MED_GaussUtils.hxx.

Definition at line 752 of file MED_Structures.hxx.

Definition at line 754 of file MED_Structures.hxx.

typedef std::vector<double> MED::TDoubleVector

Definition at line 35 of file MED_GaussDef.hxx.

Definition at line 186 of file MED_Structures.hxx.

Definition at line 101 of file MED_Algorithm.hxx.

Definition at line 69 of file MED_Algorithm.hxx.

Definition at line 98 of file MED_Common.hxx.

Definition at line 40 of file MED_Algorithm.hxx.

Definition at line 95 of file MED_Common.hxx.

typedef herr_t MED::TErr

Definition at line 63 of file MED_Common.hxx.

Definition at line 134 of file MED_Structures.hxx.

typedef std::map<TInt,TInt> MED::TFamilyID2NbCells

Definition at line 148 of file MED_Algorithm.hxx.

typedef std::set<PFamilyInfo> MED::TFamilyInfoSet

Definition at line 51 of file MED_Algorithm.hxx.

typedef boost::tuple<PFamilyInfo,TInt> MED::TFamilyTSize

Definition at line 61 of file MED_Algorithm.hxx.

Definition at line 65 of file MED_Algorithm.hxx.

Definition at line 90 of file MED_Algorithm.hxx.

typedef double MED::TFloat

Definition at line 56 of file MED_Common.hxx.

Definition at line 745 of file MED_Structures.hxx.

Definition at line 883 of file MED_Structures.hxx.

Definition at line 240 of file MED_Structures.hxx.

Definition at line 89 of file MED_Common.hxx.

typedef std::set<EGeometrieElement> MED::TGeom

Definition at line 762 of file MED_Structures.hxx.

Definition at line 39 of file MED_Algorithm.hxx.

Definition at line 487 of file MED_Structures.hxx.

Definition at line 488 of file MED_Structures.hxx.

Definition at line 761 of file MED_Structures.hxx.

Definition at line 94 of file MED_Common.hxx.

Definition at line 758 of file MED_Structures.hxx.

typedef std::set<EGeometrieElement> MED::TGeomSet

Definition at line 97 of file MED_Common.hxx.

typedef TFloat(* MED::TGetCoord)(const TCCoordSlice &theCoordSlice)

Definition at line 37 of file MED_CoordUtils.hxx.

typedef std::map<std::string,TFamilyInfoSet> MED::TGroupInfo

Definition at line 80 of file MED_Algorithm.hxx.

typedef hid_t MED::TIdt

Definition at line 62 of file MED_Common.hxx.

typedef std::map<TInt,TFloatVector> MED::TIndexes

Definition at line 966 of file MED_Structures.hxx.

typedef int MED::TInt

Definition at line 60 of file MED_Common.hxx.

Definition at line 746 of file MED_Structures.hxx.

Definition at line 889 of file MED_Structures.hxx.

Definition at line 131 of file MED_Structures.hxx.

Definition at line 91 of file MED_Common.hxx.

typedef std::map<TGaussInfo::TKey,PGaussInfo,TGaussInfo::TLess> MED::TKey2Gauss

Definition at line 110 of file MED_Algorithm.hxx.

typedef std::map<TProfileInfo::TKey,PProfileInfo> MED::TKey2Profile

Definition at line 131 of file MED_Algorithm.hxx.

Definition at line 757 of file MED_Structures.hxx.

Definition at line 132 of file MED_Algorithm.hxx.

typedef std::map<TInt,TString> MED::TNames

Definition at line 967 of file MED_Structures.hxx.

Definition at line 243 of file MED_Structures.hxx.

typedef TVector<char> MED::TString

Defines a type for managing sequence of strings.

Definition at line 43 of file MED_Structures.hxx.

typedef std::set<std::string> MED::TStringSet

Definition at line 92 of file MED_Common.hxx.

typedef TVector<std::string> MED::TStringVector

Definition at line 90 of file MED_Common.hxx.

Definition at line 89 of file MED_Algorithm.hxx.

Definition at line 962 of file MED_Structures.hxx.

Definition at line 750 of file MED_Structures.hxx.

Definition at line 751 of file MED_Structures.hxx.

Definition at line 755 of file MED_Structures.hxx.

Definition at line 433 of file MED_Structures.hxx.


Enumeration Type Documentation

Enumerator:
eFAUX 
eVRAI 

Definition at line 55 of file MED_Common.hxx.

Enumerator:
eNOD 
eDESC 

Definition at line 73 of file MED_Common.hxx.

Enumerator:
eX 
eY 
eZ 
eNone 

Definition at line 34 of file MED_CoordUtils.cxx.

{eX, eY, eZ, eNone};
Enumerator:
eMAILLE 
eFACE 
eARETE 
eNOEUD 
eNOEUD_ELEMENT 

Definition at line 81 of file MED_Common.hxx.

Enumerator:
ePOINT1 
eSEG2 
eSEG3 
eTRIA3 
eQUAD4 
eTRIA6 
eQUAD8 
eQUAD9 
eTETRA4 
ePYRA5 
ePENTA6 
eHEXA8 
eOCTA12 
eTETRA10 
ePYRA13 
ePENTA15 
eHEXA20 
eHEXA27 
ePOLYGONE 
ePOLYEDRE 
eNONE 

Definition at line 75 of file MED_Common.hxx.

               {ePOINT1=1, eSEG2=102, eSEG3=103, eTRIA3=203,
                eQUAD4=204, eTRIA6=206,eQUAD8=208, eQUAD9=209,eTETRA4=304,
                ePYRA5=305, ePENTA6=306, eHEXA8=308, eOCTA12=312, eTETRA10=310, 
                ePYRA13=313, ePENTA15=315, eHEXA20=320, eHEXA27=327,
                ePOLYGONE=400, ePOLYEDRE=500, eNONE=0} EGeometrieElement;
Enumerator:
eGRILLE_CARTESIENNE 
eGRILLE_POLAIRE 
eGRILLE_STANDARD 

Definition at line 85 of file MED_Common.hxx.

Enumerator:
eNON_STRUCTURE 
eSTRUCTURE 

Definition at line 69 of file MED_Common.hxx.

Enumerator:
eNO_PFLMOD 
eGLOBAL 
eCOMPACT 

Definition at line 83 of file MED_Common.hxx.

Enumerator:
eFULL_INTERLACE 
eNO_INTERLACE 

Definition at line 65 of file MED_Common.hxx.

Enumerator:
eCART 
eCYL 
eSPHER 

Definition at line 71 of file MED_Common.hxx.

Enumerator:
eCOOR 
eCONN 
eNOM 
eNUM 
eFAM 
eCOOR_IND1 
eCOOR_IND2 
eCOOR_IND3 

Definition at line 87 of file MED_Common.hxx.

Enumerator:
eFLOAT64 
eINT 

Definition at line 67 of file MED_Common.hxx.

Enumerator:
eVUnknown 
eV2_1 
eV2_2 

Definition at line 53 of file MED_Common.hxx.

{eVUnknown = -1, eV2_1, eV2_2};

Function Documentation

Definition at line 89 of file MED_Structures.cxx.

  {
    return theTimeStampValue;
  }

Definition at line 95 of file MED_Structures.cxx.

  {
    return theTimeStampValue;
  }
MEDWRAPPER_EXPORT EEntiteMaillage MED::ConvertEntity ( const EEntiteMaillage &  aEntity)

Convert eNOEUD_ELEMENT to eMAILLE.

Definition at line 367 of file MED_Algorithm.cxx.

                                                               {
    switch( aEntity ){
      
    case eNOEUD_ELEMENT:
    case eMAILLE: return eMAILLE; //eNOEUD_ELEMENT it is eMAILLE
      
    case eFACE:
    case eARETE:
    case eNOEUD: return aEntity; break;
    default: return EEntiteMaillage(-1);
      
    }
  }

Here is the caller graph for this function:

template<class TMeshValueTypeFrom , class TMeshValueTypeTo >
void MED::CopyTimeStampValue ( SharedPtr< TTimeStampValue< TMeshValueTypeFrom > >  theTimeStampValueFrom,
SharedPtr< TTimeStampValue< TMeshValueTypeTo > >  theTimeStampValueTo 
)

Definition at line 899 of file MED_Structures.hxx.

  {
    typedef TTimeStampValue<TMeshValueTypeFrom> TimeStampValueTypeFrom;
    typedef TTimeStampValue<TMeshValueTypeTo> TimeStampValueTypeTo;
    typedef typename TMeshValueTypeTo::TElement TElementTo;

    typename TimeStampValueTypeFrom::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
    typename TimeStampValueTypeFrom::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
    for(; anIter != aGeom2Value.end(); anIter++){
      const EGeometrieElement& aGeom = anIter->first;
      const typename TimeStampValueTypeFrom::TTMeshValue& aMeshValue = *anIter->second;
      typename TimeStampValueTypeTo::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
      aMeshValue2.Allocate(aMeshValue.myNbElem, 
                           aMeshValue.myNbGauss, 
                           aMeshValue.myNbComp,
                           aMeshValue.myModeSwitch);
      const typename TimeStampValueTypeFrom::TTMeshValue::TValue& aValue = aMeshValue.myValue;
      typename TimeStampValueTypeTo::TTMeshValue::TValue& aValue2 = aMeshValue2.myValue;
      TInt aSize = aValue.size();
      for(TInt anId = 0; anId < aSize; anId++)
        aValue2[anId] = TElementTo(aValue[anId]);
    }
  }
template<class TMeshValueType >
void MED::CopyTimeStampValue ( SharedPtr< TTimeStampValue< TMeshValueType > >  theTimeStampValueFrom,
SharedPtr< TTimeStampValue< TMeshValueType > >  theTimeStampValueTo 
)

Definition at line 926 of file MED_Structures.hxx.

  {
    typedef TTimeStampValue<TMeshValueType> TimeStampValueType;
    typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValueFrom->myGeom2Value;
    typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
    for(; anIter != aGeom2Value.end(); anIter++){
      const EGeometrieElement& aGeom = anIter->first;
      const typename TimeStampValueType::TTMeshValue& aMeshValue = *anIter->second;
      typename TimeStampValueType::TTMeshValue& aMeshValue2 = theTimeStampValueTo->GetMeshValue(aGeom);
      aMeshValue2 = aMeshValue;
    }
  }
void MED::CopyTimeStampValueBase ( const PTimeStampValueBase &  theValueFrom,
const PTimeStampValueBase &  theValueTo 
) [inline]

Definition at line 943 of file MED_Structures.hxx.

  {
    if(theValueFrom->GetTypeChamp() == theValueTo->GetTypeChamp()){
      if(theValueFrom->GetTypeChamp() == eFLOAT64)
        CopyTimeStampValue<TFloatMeshValue>(theValueFrom, theValueTo);
      else if(theValueFrom->GetTypeChamp() == eINT)
        CopyTimeStampValue<TIntMeshValue>(theValueFrom, theValueTo);
    }else{
      if(theValueFrom->GetTypeChamp() == eFLOAT64 && theValueTo->GetTypeChamp() == eINT)
        CopyTimeStampValue<TFloatMeshValue, TIntMeshValue>(theValueFrom, theValueTo);
      else if(theValueFrom->GetTypeChamp() == eINT && theValueTo->GetTypeChamp() == eFLOAT64)
        CopyTimeStampValue<TIntMeshValue, TFloatMeshValue>(theValueFrom, theValueTo);
    }
  }
MEDWRAPPER_FACTORY_EXPORT PWrapper MED::CrWrapper ( const std::string &  theFileName,
bool  theDoPreCheckInSeparateProcess 
)

Definition at line 129 of file MED_Factory.cxx.

  {
    PWrapper aWrapper;
    EVersion aVersion = GetVersionId(theFileName,theDoPreCheckInSeparateProcess);
    switch(aVersion){
    case eV2_2:
      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
      break;
    case eV2_1:
      aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
      break;
    default:
      EXCEPTION(std::runtime_error,"MED::CrWrapper - theFileName = '"<<theFileName<<"'");
    }
    return aWrapper;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

MEDWRAPPER_FACTORY_EXPORT PWrapper MED::CrWrapper ( const std::string &  theFileName,
EVersion  theId 
)

Definition at line 147 of file MED_Factory.cxx.

  {
    EVersion aVersion = GetVersionId(theFileName);

    if(aVersion != theId)
      remove(theFileName.c_str());
    
    PWrapper aWrapper;
    switch(theId){
    case eV2_2:
      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
      break;
    case eV2_1:
      aWrapper.reset(new MED::V2_1::TVWrapper(theFileName));
      break;
    default:
      aWrapper.reset(new MED::V2_2::TVWrapper(theFileName));
    }
    return aWrapper;
  }

Here is the call graph for this function:

MEDWRAPPER_EXPORT bool MED::GetBaryCenter ( const TCellInfo &  theCellInfo,
const TNodeInfo &  theNodeInfo,
TGaussCoord &  theGaussCoord,
const TElemNum &  theElemNum,
EModeSwitch  theMode 
)

To calculate Gauss Points coordinates for defined TCellInfo as its bary center.

Definition at line 1986 of file MED_GaussUtils.cxx.

  {
    INITMSG(MYDEBUG,"GetBaryCenter\n");
    const PMeshInfo& aMeshInfo = theCellInfo.GetMeshInfo();
    TInt aDim = aMeshInfo->GetDim();
    static TInt aNbGauss = 1;

    bool anIsSubMesh = !theElemNum.empty();
    TInt aNbElem;
    if(anIsSubMesh)
      aNbElem = theElemNum.size();
    else
      aNbElem = theCellInfo.GetNbElem();

    theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);

    TInt aConnDim = theCellInfo.GetConnDim();

    INITMSGA(MYDEBUG,0,
             "- aDim = "<<aDim<<
             "; aNbGauss = "<<aNbGauss<<
             "; aNbElem = "<<aNbElem<<
             "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
             std::endl);

    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
      TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;
      TCConnSlice aConnSlice = theCellInfo.GetConnSlice(aCellId);
      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);

      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
        TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];

        for(TInt aConnId = 0; aConnId < aConnDim; aConnId++){
          TInt aNodeId = aConnSlice[aConnId] - 1;      
          TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);

          for(TInt aDimId = 0; aDimId < aDim; aDimId++){
            aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId];
          }
        }

        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
          aGaussCoordSlice[aDimId] /= aConnDim;
        }
      }
    }

#ifdef _DEBUG_
    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
      INITMSG(MYVALUEDEBUG,"");
      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
        TCoordSlice& aCoordSlice = aCoordSliceArr[aGaussId];
        ADDMSG(MYVALUEDEBUG,"{");
        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
          ADDMSG(MYVALUEDEBUG,aCoordSlice[aDimId]<<" ");
        }
        ADDMSG(MYVALUEDEBUG,"} ");
      }
      ADDMSG(MYVALUEDEBUG,std::endl);
    }
#endif

    return true;
  }
MEDWRAPPER_EXPORT bool MED::GetBaryCenter ( const TPolygoneInfo &  thePolygoneInfo,
const TNodeInfo &  theNodeInfo,
TGaussCoord &  theGaussCoord,
const TElemNum &  theElemNum,
EModeSwitch  theMode 
)

To calculate Gauss Points coordinates for defined TPolygoneInfo as its bary center.

Definition at line 2060 of file MED_GaussUtils.cxx.

  {
    INITMSG(MYDEBUG,"GetBaryCenter\n");
    const PMeshInfo& aMeshInfo = thePolygoneInfo.GetMeshInfo();
    TInt aDim = aMeshInfo->GetDim();
    static TInt aNbGauss = 1;

    bool anIsSubMesh = !theElemNum.empty();
    TInt aNbElem;
    if(anIsSubMesh)
      aNbElem = theElemNum.size();
    else
      aNbElem = thePolygoneInfo.GetNbElem();

    theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);

    INITMSGA(MYDEBUG,0,
             "- aDim = "<<aDim<<
             "; aNbGauss = "<<aNbGauss<<
             "; aNbElem = "<<aNbElem<<
             "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
             std::endl);

    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
      TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;

      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
      TCConnSlice aConnSlice = thePolygoneInfo.GetConnSlice(aCellId);
      TInt aNbConn = thePolygoneInfo.GetNbConn(aCellId);
      TInt aNbNodes = thePolygoneInfo.GetNbConn(aCellId);

      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
        TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];

        for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
          TInt aNodeId = aConnSlice[aConnId] - 1;      
          TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);

          for(TInt aDimId = 0; aDimId < aDim; aDimId++){
            aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId];
          }
        }

        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
          aGaussCoordSlice[aDimId] /= aNbNodes;
        }
      }
    }

    return true;
  }
MEDWRAPPER_EXPORT bool MED::GetBaryCenter ( const TPolyedreInfo &  thePolyedreInfo,
const TNodeInfo &  theNodeInfo,
TGaussCoord &  theGaussCoord,
const TElemNum &  theElemNum,
EModeSwitch  theMode 
)

To calculate Gauss Points coordinates for defined TPolyedreInfo as its bary center.

Definition at line 2119 of file MED_GaussUtils.cxx.

  {
    INITMSG(MYDEBUG,"GetBaryCenter\n");
    const PMeshInfo& aMeshInfo = thePolyedreInfo.GetMeshInfo();
    TInt aDim = aMeshInfo->GetDim();
    static TInt aNbGauss = 1;

    bool anIsSubMesh = !theElemNum.empty();
    TInt aNbElem;
    if(anIsSubMesh)
      aNbElem = theElemNum.size();
    else
      aNbElem = thePolyedreInfo.GetNbElem();

    theGaussCoord.Init(aNbElem,aNbGauss,aDim,theMode);

    INITMSGA(MYDEBUG,0,
             "- aDim = "<<aDim<<
             "; aNbGauss = "<<aNbGauss<<
             "; aNbElem = "<<aNbElem<<
             "; aNbNodes = "<<theNodeInfo.GetNbElem()<<
             std::endl);

    for(TInt anElemId = 0; anElemId < aNbElem; anElemId++){
      TInt aCellId = anIsSubMesh? theElemNum[anElemId]-1: anElemId;

      TCoordSliceArr aCoordSliceArr = theGaussCoord.GetCoordSliceArr(anElemId);
      TCConnSliceArr aConnSliceArr = thePolyedreInfo.GetConnSliceArr(aCellId);
      TInt aNbFaces = aConnSliceArr.size();

      TInt aNbNodes = thePolyedreInfo.GetNbNodes(aCellId);

      for(TInt aGaussId = 0; aGaussId < aNbGauss; aGaussId++){
        TCoordSlice& aGaussCoordSlice = aCoordSliceArr[aGaussId];

        for(TInt aFaceId = 0; aFaceId < aNbFaces; aFaceId++){
          TCConnSlice aConnSlice = aConnSliceArr[aFaceId];
          TInt aNbConn = aConnSlice.size();
          for(TInt aConnId = 0; aConnId < aNbConn; aConnId++){
            TInt aNodeId = aConnSlice[aConnId] - 1;      
            TCCoordSlice aNodeCoordSlice = theNodeInfo.GetCoordSlice(aNodeId);

            for(TInt aDimId = 0; aDimId < aDim; aDimId++){
              aGaussCoordSlice[aDimId] += aNodeCoordSlice[aDimId];
            }
          }
        }
        for(TInt aDimId = 0; aDimId < aDim; aDimId++){
          aGaussCoordSlice[aDimId] /= aNbNodes;
        }
      }
    }

    return true;
  }

Here is the call graph for this function:

template<ECoordName TCoordId>
TFloat MED::GetCoord ( const TCCoordSlice &  theCoordSlice)

Definition at line 38 of file MED_CoordUtils.cxx.

  {
    return theCoordSlice[TCoordId];
  }

Here is the caller graph for this function:

template<>
TFloat MED::GetCoord< eNone > ( const TCCoordSlice &  theCoordSlice)

Definition at line 45 of file MED_CoordUtils.cxx.

  {
    return 0.0;
  }

Definition at line 118 of file MED_CoordUtils.cxx.

  {
    PCoordHelper aCoordHelper;
    {
      PMeshInfo aMeshInfo = theNodeInfo->GetMeshInfo();
      TInt aMeshDimension = aMeshInfo->GetDim();
      bool anIsDimPresent[3] = {false, false, false};
      for(int iDim = 0; iDim < aMeshDimension; iDim++){
        // PAL16857(SMESH not conform to the MED convention) ->
        // 1D - always along X
        // 2D - always in XOY plane
        anIsDimPresent[iDim] = iDim < aMeshDimension;
//      std::string aName = theNodeInfo->GetCoordName(iDim);
//         if ( aName.size() > 1 ) // PAL12148, aName has size 8 or 16
//           aName = aName.substr(0,1);
//      if(aName == "x" || aName == "X")
//        anIsDimPresent[eX] = true;
//      else if(aName == "y" || aName == "Y")
//        anIsDimPresent[eY] = true;
//      else if(aName == "z" || aName == "Z")
//        anIsDimPresent[eZ] = true;
      }

      switch(aMeshDimension){
      case 3:
        aCoordHelper.reset(new TCoordHelper(aXYZGetCoord));
        break;
      case 2:
        if(anIsDimPresent[eY] && anIsDimPresent[eZ])
          aCoordHelper.reset(new TCoordHelper(aYZGetCoord));
        else if(anIsDimPresent[eX] && anIsDimPresent[eZ])
          aCoordHelper.reset(new TCoordHelper(aXZGetCoord));
        else
          aCoordHelper.reset(new TCoordHelper(aXYGetCoord));
        break;
      case 1:
        if(anIsDimPresent[eY])
          aCoordHelper.reset(new TCoordHelper(aYGetCoord));
        else if(anIsDimPresent[eZ])
          aCoordHelper.reset(new TCoordHelper(aZGetCoord));
        else
          aCoordHelper.reset(new TCoordHelper(aXGetCoord));
        break;
      }
    }
    return aCoordHelper;
  }
template<EVersion >
TInt MEDWRAPPER_EXPORT MED::GetDESCLength ( )

Definition at line 48 of file MED_V2_1_Wrapper.cxx.

  {
    return 200;
  }

Definition at line 50 of file MED_V2_2_Wrapper.cxx.

  {
    return 200;
  }

Get dimension of the Gauss coordinates for the defined type of mesh cell.

Definition at line 76 of file MED_Structures.cxx.

  {
    return theGeom/100;
  }

Here is the caller graph for this function:

MEDWRAPPER_EXPORT TEntite2TFieldInfo2TimeStampInfoSet MED::GetEntite2TFieldInfo2TimeStampInfoSet ( const TFieldInfo2TimeStampInfoSet &  theFieldInfo2TimeStampInfoSet)

Split the input set of MED TIMESTAMPS by corresponding MED FIELDS and MED ENTITIES.

Definition at line 165 of file MED_Algorithm.cxx.

  {
    TEntite2TFieldInfo2TimeStampInfoSet anEntite2TFieldInfo2TimeStampInfoSet;
    TFieldInfo2TimeStampInfoSet::const_iterator anIter = theFieldInfo2TimeStampInfoSet.begin();
    for(; anIter != theFieldInfo2TimeStampInfoSet.end(); anIter++){
      const TTimeStampInfoSet& aTimeStampInfoSet = anIter->second;
      //const PFieldInfo& aFieldInfo = anIter->first;
      if(aTimeStampInfoSet.empty()) 
        continue;
      const PTimeStampInfo& aTimeStampInfo = *aTimeStampInfoSet.begin();
      anEntite2TFieldInfo2TimeStampInfoSet[ConvertEntity(aTimeStampInfo->GetEntity())].insert(*anIter);
    }
    return anEntite2TFieldInfo2TimeStampInfoSet;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

MEDWRAPPER_EXPORT TEntity2FamilySet MED::GetEntity2FamilySet ( const PWrapper &  theWrapper,
const TEntity2TGeom2ElemInfo &  theEntity2TGeom2ElemInfo,
const TFamilyInfoSet &  theFamilyInfoSet 
)

Split set of MED FAMILIES by corresponding MED ENTITY.

Definition at line 193 of file MED_Algorithm.cxx.

  {
    MSG(MYDEBUG,"GetFamiliesByEntity(...)");
    TEntity2FamilySet anEntity2FamilySet;
    
    typedef std::map<TInt,PFamilyInfo> TId2Family;
    TId2Family anId2Family;
    TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
    for(; anIter != theFamilyInfoSet.end(); anIter++){
      const PFamilyInfo& aFamilyInfo = *anIter;
      anId2Family.insert(TId2Family::value_type(aFamilyInfo->GetId(),aFamilyInfo));
    }
    
    if(!anId2Family.empty()){
      typedef std::map<TInt,TInt> TFamilyID2Size;
      typedef std::map<EEntiteMaillage,TFamilyID2Size> TEntity2FamilyID;
      TEntity2FamilyID anEntity2FamilyID;
      
      if(!theEntity2TGeom2ElemInfo.empty()){
        TEntity2TGeom2ElemInfo::const_iterator anIter = theEntity2TGeom2ElemInfo.begin();
        for(; anIter != theEntity2TGeom2ElemInfo.end(); anIter++){
          const EEntiteMaillage& anEntity = anIter->first;
          TFamilyID2Size& aFamilyID2Size = anEntity2FamilyID[anEntity];
          const TGeom2ElemInfo& aGeom2ElemInfo = anIter->second;
          TGeom2ElemInfo::const_iterator aGeom2ElemInfoIter = aGeom2ElemInfo.begin();
          for(; aGeom2ElemInfoIter != aGeom2ElemInfo.end(); aGeom2ElemInfoIter++){
            const PElemInfo& aElemInfo = aGeom2ElemInfoIter->second;
            if(TInt aNbElem = aElemInfo->GetNbElem()){
              for(TInt i = 0; i < aNbElem; i++){
                aFamilyID2Size[aElemInfo->GetFamNum(i)] += 1;
              }
            }
          }
        }
      }
      
      if(!anEntity2FamilyID.empty()){
        TEntity2FamilyID::const_iterator anIter = anEntity2FamilyID.begin();
        for(; anIter != anEntity2FamilyID.end(); anIter++){
          const EEntiteMaillage& anEntity = anIter->first;
          INITMSG(MYDEBUG,"anEntity = "<<anEntity<<":\n");
          const TFamilyID2Size& aFamilyID2Size = anIter->second;
          TFamilyID2Size::const_iterator anIter2 = aFamilyID2Size.begin();
          for(; anIter2 != aFamilyID2Size.end(); anIter2++){
            TInt anId = anIter2->first;
            TInt aSize = anIter2->second;
            TId2Family::const_iterator anIter3 = anId2Family.find(anId);
            if(anIter3 != anId2Family.end()){
              const PFamilyInfo& aFamilyInfo = anIter3->second;
              anEntity2FamilySet[anEntity].insert(TFamilyTSize(aFamilyInfo,aSize));
              INITMSG(MYDEBUG,
                      "aFamilyName = '"<<aFamilyInfo->GetName()<<
                      "' anId = "<<aFamilyInfo->GetId()<<"\n");
            }
          }
        }
      }
    }    
    ADDMSG(MYDEBUG,"\n");
    return anEntity2FamilySet;
  }

Here is the caller graph for this function:

Definition at line 109 of file MED_Utilities.cxx.

{
  return Entity2GeomSet;
}
MEDWRAPPER_EXPORT TEntity2TGeom2ElemInfo MED::GetEntity2TGeom2ElemInfo ( const PWrapper &  theWrapper,
const PMeshInfo &  theMeshInfo,
const MED::TEntityInfo theEntityInfo 
)

Get set of TElemInfo by its geometrical type and corresponding MED ENTITY.

Definition at line 45 of file MED_Algorithm.cxx.

  {
    MSG(MYDEBUG,"GetElemsByEntity(...)");
    TEntity2TGeom2ElemInfo anEntity2TGeom2ElemInfo;
    MED::TEntityInfo::const_iterator anIter = theEntityInfo.begin();
    PElemInfo anElemInfo;
    TErr anErr;
    for(; anIter != theEntityInfo.end(); anIter++){
      const EEntiteMaillage& anEntity = anIter->first;
      const TGeom2Size& aGeom2Size = anIter->second;
      TGeom2ElemInfo& aGeom2ElemInfo = anEntity2TGeom2ElemInfo[anEntity];

      if(anEntity == eNOEUD){
        aGeom2ElemInfo[ePOINT1] = theWrapper->GetPElemInfo(theMeshInfo);
        continue;
      }

      TGeom2Size::const_iterator anIter2 = aGeom2Size.begin();
      for(; anIter2 != aGeom2Size.end(); anIter2++){
        const EGeometrieElement& aGeom = anIter2->first;
        aGeom2ElemInfo[aGeom] = theWrapper->GetPElemInfo(theMeshInfo,anEntity,aGeom,MED::eNOD,&anErr);
      }
    }
    ADDMSG(MYDEBUG,"\n");
    return anEntity2TGeom2ElemInfo;
  }

Here is the caller graph for this function:

MEDWRAPPER_EXPORT EEntiteMaillage MED::GetEntityByFamilyId ( PGrilleInfo &  theInfo,
TInt  theId 
)

Get Entity for Grille by family id.

Definition at line 340 of file MED_Algorithm.cxx.

                                                      {
    TElemNum::iterator aNodeFamIter = (theInfo->myFamNumNode).begin();
    for(;aNodeFamIter != (theInfo->myFamNumNode).end(); aNodeFamIter++){
      if(theId == *aNodeFamIter)
        return eNOEUD;
    }
    TElemNum::iterator aCellFamIter = (theInfo->myFamNum).begin();
    for(;aCellFamIter != (theInfo->myFamNum).end(); aCellFamIter++){
      if(theId == *aCellFamIter)
        return eMAILLE;
    }
    EXCEPTION(std::runtime_error, "GetEntityByFamilyId - fails");
    return EEntiteMaillage(-1);
  }

Get Number of cells for theId family, for Grille.

Definition at line 356 of file MED_Algorithm.cxx.

                                           {
    TFamilyID2NbCells aFamily2NbCells;
    TInt aNbNodes = theInfo->myFamNumNode.size();
    TInt aNbCells = theInfo->myFamNum.size();
    for(TInt i=0; i<aNbNodes; i++) aFamily2NbCells[theInfo->GetFamNumNode(i)] = 0;
    for(TInt i=0; i<aNbCells; i++) aFamily2NbCells[theInfo->GetFamNum(i)] = 0;
    for(TInt i=0; i<aNbNodes; i++) aFamily2NbCells[theInfo->GetFamNumNode(i)] += 1;
    for(TInt i=0; i<aNbCells; i++) aFamily2NbCells[theInfo->GetFamNum(i)] += 1;
    return aFamily2NbCells;
  }
MEDWRAPPER_EXPORT TFamilyInfoSet MED::GetFamilyInfoSet ( const PWrapper &  theWrapper,
const PMeshInfo &  theMeshInfo 
)

Read set of MED FAMILIES for defined MED file.

Definition at line 77 of file MED_Algorithm.cxx.

  {
    MSG(MYDEBUG,"GetFamilies(...)");
    TErr anErr;
    TFamilyInfoSet aFamilyInfoSet;
    TInt aNbFam = theWrapper->GetNbFamilies(*theMeshInfo);
    INITMSG(MYDEBUG,"GetNbFamilies() = "<<aNbFam<<"\n");
    for(TInt iFam = 1; iFam <= aNbFam; iFam++){
      PFamilyInfo aFamilyInfo = theWrapper->GetPFamilyInfo(theMeshInfo,iFam,&anErr);
      if(anErr >= 0)
        aFamilyInfoSet.insert(aFamilyInfo);
    }
    ADDMSG(MYDEBUG,"\n");
    return aFamilyInfoSet;
  }

Here is the caller graph for this function:

MEDWRAPPER_EXPORT TFieldInfo2TimeStampInfoSet MED::GetFieldInfo2TimeStampInfoSet ( const PWrapper &  theWrapper,
const PMeshInfo &  theMeshInfo,
const MED::TEntityInfo theEntityInfo 
)

Read set of MED TIMESTAMPS groupped by corresponding MED FIELDS.

Definition at line 133 of file MED_Algorithm.cxx.

  {
    MSG(MYDEBUG,"GetFieldsByEntity(...)");
    TFieldInfo2TimeStampInfoSet aFieldInfo2TimeStampInfoSet;
    TInt aNbFields = theWrapper->GetNbFields();
    INITMSG(MYDEBUG,"GetNbFields() = "<<aNbFields<<"\n");
    for(TInt iField = 1; iField <= aNbFields; iField++){
      PFieldInfo aFieldInfo = theWrapper->GetPFieldInfo(theMeshInfo,iField);
      INITMSG(MYDEBUG,"aFieldName = '"<<aFieldInfo->GetName()<<
              "'; aNbComp = "<<aFieldInfo->GetNbComp()<<"; ");
      TGeom2Size aGeom2Size;
      EEntiteMaillage anEntity = EEntiteMaillage(-1);
      TInt aNbTimeStamps = theWrapper->GetNbTimeStamps(aFieldInfo,theEntityInfo,anEntity,aGeom2Size);
      ADDMSG(MYDEBUG,"anEntity = "<<anEntity<<"; GetNbTimeStamps = "<<aNbTimeStamps<<"\n");
      for(TInt iTimeStamp = 1; iTimeStamp <= aNbTimeStamps; iTimeStamp++){
        PTimeStampInfo aTimeStamp = 
          theWrapper->GetPTimeStampInfo(aFieldInfo,anEntity,aGeom2Size,iTimeStamp);
        aFieldInfo2TimeStampInfoSet[aFieldInfo].insert(aTimeStamp);
        INITMSG(MYDEBUG,
                "aDt = "<<aTimeStamp->GetDt()<<
                ", Unit = \'"<<aTimeStamp->GetUnitDt()<<"\n");
      }
    }
    ADDMSG(MYDEBUG,"\n");
    return aFieldInfo2TimeStampInfoSet;
  }

Here is the caller graph for this function:

MEDWRAPPER_EXPORT bool MED::GetGaussCoord3D ( const TGaussInfo &  theGaussInfo,
const TCellInfo &  theCellInfo,
const TNodeInfo &  theNodeInfo,
TGaussCoord &  theGaussCoord,
const TElemNum &  theElemNum,
EModeSwitch  theMode 
)

To calculate Gauss Points coordinates.

Definition at line 1793 of file MED_GaussUtils.cxx.

  {
    INITMSG(MYDEBUG,"GetGaussCoord3D\n");

    if(theGaussInfo.myGeom == theCellInfo.myGeom){
      EGeometrieElement aGeom = theGaussInfo.myGeom;

      TInt aNbRef = theGaussInfo.GetNbRef();
      TCCoordSliceArr aRefSlice(aNbRef);
      for(TInt anId = 0; anId < aNbRef; anId++)
        aRefSlice[anId] = theGaussInfo.GetRefCoordSlice(anId);

      TInt aNbGauss = theGaussInfo.GetNbGauss();
      TCCoordSliceArr aGaussSlice(aNbGauss);
      for(TInt anId = 0; anId < aNbGauss; anId++)
        aGaussSlice[anId] = theGaussInfo.GetGaussCoordSlice(anId);

      switch(aGeom){
      case eSEG2: {
        INITMSG(MYDEBUG,"eSEG2"<<std::endl);

        if(TSeg2a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eSEG3: {
        INITMSG(MYDEBUG,"eSEG3"<<std::endl);

        if(TSeg3a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eTRIA3: {
        INITMSG(MYDEBUG,"eTRIA3"<<std::endl);

        if(TTria3a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TTria3b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eTRIA6: {
        INITMSG(MYDEBUG,"eTRIA6"<<std::endl);

        if(TTria6a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TTria6b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eQUAD4: {
        INITMSG(MYDEBUG,"eQUAD4"<<std::endl);

        if(TQuad4a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TQuad4b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eQUAD8: {
        INITMSG(MYDEBUG,"eQUAD8"<<std::endl);

        if(TQuad8a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TQuad8b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eQUAD9: {
        INITMSG(MYDEBUG,"eQUAD9"<<std::endl);

        if(TQuad9a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TQuad9b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eTETRA4: {
        INITMSG(MYDEBUG,"eTETRA4"<<std::endl);

        if(TTetra4a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TTetra4b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case ePYRA5: {
        INITMSG(MYDEBUG,"ePYRA5"<<std::endl);

        if(TPyra5a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TPyra5b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case ePENTA6: {
        INITMSG(MYDEBUG,"ePENTA6"<<std::endl);

        if(TPenta6a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TPenta6b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eHEXA8: {
        INITMSG(MYDEBUG,"eHEXA8"<<std::endl);

        if(THexa8a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(THexa8b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eTETRA10: {
        INITMSG(MYDEBUG,"eTETRA10"<<std::endl);

        if(TTetra10a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TTetra10b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case ePYRA13: {
        INITMSG(MYDEBUG,"ePYRA13"<<std::endl);

        if(TPyra13a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TPyra13b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case ePENTA15: {
        INITMSG(MYDEBUG,"ePENTA15"<<std::endl);

        if(TPenta15a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(TPenta15b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      case eHEXA20: {
        INITMSG(MYDEBUG,"eHEXA20"<<std::endl);

        if(THexa20a().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        if(THexa20b().Eval(theCellInfo,theNodeInfo,theElemNum,aRefSlice,aGaussSlice,theGaussCoord,theMode))
          return true;

        break;
      }
      default: 
        INITMSG(MYDEBUG,"eNONE"<<std::endl);
        return false;
      }
    }

    return false;
  }

Here is the caller graph for this function:

MEDWRAPPER_EXPORT TGroupInfo MED::GetGroupInfo ( const TFamilyInfoSet &  theFamilyInfoSet)

Split the input set of MED FAMILIES by corresponding MED GROUPS.

Definition at line 97 of file MED_Algorithm.cxx.

  {
    MSG(MYDEBUG,"GetFamiliesByGroup(...)");
    TGroupInfo aGroup;
    TFamilyInfoSet::const_iterator anIter = theFamilyInfoSet.begin();
    for(; anIter != theFamilyInfoSet.end(); anIter++){
      const PFamilyInfo& aFamilyInfo = *anIter;
      TInt aNbGroup = aFamilyInfo->GetNbGroup();
      for(TInt iGroup = 0; iGroup < aNbGroup; iGroup++){
        aGroup[aFamilyInfo->GetGroupName(iGroup)].insert(aFamilyInfo);
      } 
    }

#ifdef _DEBUG_
    if(MYDEBUG){
      TGroupInfo::const_iterator anIter = aGroup.begin();
      for(; anIter != aGroup.end(); anIter++){
        const std::string& aName = anIter->first;
        INITMSG(MYDEBUG,"aGroupName = '"<<aName<<"'\n");
        const TFamilyInfoSet& aFamilyInfoSet = anIter->second;
        TFamilyInfoSet::const_iterator anFamIter = aFamilyInfoSet.begin();
        for(; anFamIter != aFamilyInfoSet.end(); anFamIter++){
          const PFamilyInfo& aFamilyInfo = *anFamIter;
          INITMSG(MYDEBUG,"aFamilyName = '"<<aFamilyInfo->GetName()<<"'\n");
        }
      }
      ADDMSG(MYDEBUG,"\n");
    }
#endif

    return aGroup;
  }

Here is the caller graph for this function:

template<EVersion >
TInt MEDWRAPPER_EXPORT MED::GetIDENTLength ( )

Definition at line 55 of file MED_V2_1_Wrapper.cxx.

  {
    return 8;
  }

Definition at line 57 of file MED_V2_2_Wrapper.cxx.

  {
    return 8;
  }
MEDWRAPPER_EXPORT TKey2Gauss MED::GetKey2Gauss ( const PWrapper &  theWrapper,
TErr *  theErr,
EModeSwitch  theMode 
)

Read set of MED GAUSS.

Definition at line 260 of file MED_Algorithm.cxx.

  {
    INITMSG(MYDEBUG,"GetKey2Gauss - theMode = "<<theMode<<std::endl);
    TKey2Gauss aKey2Gauss;
    TInt aNbGauss = theWrapper->GetNbGauss(theErr);
    for(TInt anId = 1; anId <= aNbGauss; anId++){
      TGaussInfo::TInfo aPreInfo = theWrapper->GetGaussPreInfo(anId);
      PGaussInfo anInfo = theWrapper->CrGaussInfo(aPreInfo,theMode);
      theWrapper->GetGaussInfo(anId,anInfo,theErr);
      TGaussInfo::TKey aKey = boost::get<0>(aPreInfo);
      aKey2Gauss[aKey] = anInfo;

#ifdef _DEBUG_
      const EGeometrieElement& aGeom = boost::get<0>(aKey);
      const std::string& aName = boost::get<1>(aKey);
      INITMSG(MYDEBUG,
              "- aGeom = "<<aGeom<<
              "; aName = '"<<aName<<"'"<<
              std::endl);
#endif

    }
    return aKey2Gauss;
  }

Here is the caller graph for this function:

template<EVersion >
TInt MEDWRAPPER_EXPORT MED::GetLNOMLength ( )

Definition at line 62 of file MED_V2_1_Wrapper.cxx.

  {
    return 80;
  }

Definition at line 71 of file MED_V2_2_Wrapper.cxx.

  {
    return 80;
  }
MEDWRAPPER_FACTORY_EXPORT bool MED::getMEDVersion ( const std::string &  fname,
int &  major,
int &  minor,
int &  release 
)

Definition at line 109 of file MED_Factory.cxx.

  {
    med_idt f = MEDfileOpen(fname.c_str(), MED_ACC_RDONLY );
    if( f<0 )
      return false;

    med_int aMajor, aMinor, aRelease;
    med_err aRet = MEDfileNumVersionRd( f, &aMajor, &aMinor, &aRelease );
    major = aMajor;
    minor = aMinor;
    release = aRelease;
    MEDfileClose( f );
    if( aRet<0 ) {
      // VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
      major = 2; minor = release = -1;
      //return false;
    }
    return true;
  }
MEDWRAPPER_EXPORT TMKey2Profile MED::GetMKey2Profile ( const PWrapper &  theWrapper,
TErr *  theErr,
EModeProfil  theMode 
)

Read set of MED PROFILES.

Definition at line 309 of file MED_Algorithm.cxx.

  {
    INITMSG(MYDEBUG,"GetMKey2Profile - theMode = "<<theMode<<std::endl);
    TKey2Profile aKey2Profile;
    TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
    for(TInt anId = 1; anId <= aNbProfiles; anId++){
      TProfileInfo::TInfo aPreInfo = theWrapper->GetProfilePreInfo(anId);
      PProfileInfo anInfo = theWrapper->GetPProfileInfo(anId,theMode,theErr);
      const std::string& aName = boost::get<0>(aPreInfo);
      aKey2Profile[aName] = anInfo;
      
#ifdef _DEBUG_
      INITMSG(MYDEBUG,
              "- aName = '"<<aName<<"'"<<
              " : "<<
              std::endl);
      TInt aNbElem = anInfo->GetSize();
      for(TInt iElem = 0; iElem < aNbElem; iElem++){
        ADDMSG(MYVALUEDEBUG,anInfo->GetElemNum(iElem)<<", ");
      }
      ADDMSG(MYVALUEDEBUG, std::endl);
#endif
      
    }
    return TMKey2Profile(theMode,aKey2Profile);
  }

Here is the caller graph for this function:

template<EVersion >
MEDWRAPPER_EXPORT TInt MED::GetNbConn ( EGeometrieElement  typmai,
EEntiteMaillage  typent,
TInt  mdim 
)
template<>
TInt MED_V21_WRAPPER_EXPORT MED::GetNbConn< eV2_1 > ( EGeometrieElement  typmai,
EEntiteMaillage  typent,
TInt  mdim 
)

Definition at line 90 of file MED_V2_1_Wrapper.cxx.

  {
    TInt nsup = 0;

    if(typent == eMAILLE){
      TInt edim = typmai / 100;
      if(mdim  == 2 || mdim == 3)
        if(edim == 1)
          nsup = 1;
      
      if(mdim == 3)
        if (edim == 2)
          nsup = 1;
    }

    return nsup + typmai%100;
  }
template<>
TInt MED_V22_WRAPPER_EXPORT MED::GetNbConn< eV2_2 > ( EGeometrieElement  typmai,
EEntiteMaillage  typent,
TInt  mdim 
)

Definition at line 94 of file MED_V2_2_Wrapper.cxx.

  {
    return typmai%100;
  }

Definition at line 37 of file MED_Structures.cxx.

  {
    return typmai%100;
  }

Here is the caller graph for this function:

Get number of referenced nodes for the defined type of mesh cell.

Definition at line 82 of file MED_Structures.cxx.

  {
    return (theGeom%100);
  }

Here is the caller graph for this function:

template<EVersion >
TInt MEDWRAPPER_EXPORT MED::GetNOMLength ( )

Definition at line 69 of file MED_V2_1_Wrapper.cxx.

  {
    return 32;
  }

Definition at line 64 of file MED_V2_2_Wrapper.cxx.

  {
    return 64;
  }
template<EVersion >
TInt MEDWRAPPER_EXPORT MED::GetPNOMLength ( )

Definition at line 76 of file MED_V2_1_Wrapper.cxx.

  {
    return 8;
  }

Definition at line 78 of file MED_V2_2_Wrapper.cxx.

  {
    return 16;
  }
MEDWRAPPER_EXPORT PProfileInfo MED::GetProfileInfo ( const PWrapper &  theWrapper,
const std::string &  theProfileName,
TErr *  theErr,
EModeProfil  theMode 
)

Get MED PROFILE by its name.

Definition at line 290 of file MED_Algorithm.cxx.

  {
    PProfileInfo anInfo;
    TInt aNbProfiles = theWrapper->GetNbProfiles(theErr);
    for(TInt anId = 1; anId <= aNbProfiles; anId++){
      TProfileInfo::TInfo aPreInfo = theWrapper->GetProfilePreInfo(anId);
      const std::string& aName = boost::get<0>(aPreInfo);
      if(aName == theProfileName)
        return theWrapper->GetPProfileInfo(anId,theMode,theErr);
    }
    return anInfo;
  }
MEDWRAPPER_EXPORT std::string MED::GetString ( TInt  theId,
TInt  theStep,
const TString theString 
)

Extract a substring from the sequence of the strings.

Definition at line 43 of file MED_Structures.cxx.

  {
    const char* aPos = &theString[theId*theStep];
    TInt aSize = std::min(TInt(strlen(aPos)),theStep);
    return std::string(aPos,aSize);
  }

Here is the caller graph for this function:

MEDWRAPPER_FACTORY_EXPORT EVersion MED::GetVersionId ( const std::string &  theFileName,
bool  theDoPreCheckInSeparateProcess 
)

Definition at line 52 of file MED_Factory.cxx.

  {
    INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'"<<std::endl);
    EVersion aVersion = eVUnknown;    

#ifndef WIN32
    if (access(theFileName.c_str(),F_OK))
      return aVersion;
    if(theDoPreCheckInSeparateProcess){
      // First check, is it possible to deal with the file
      std::ostringstream aStr;
      // File name is in quotes for the case of space(s) inside it (PAL13009)
      aStr<<"bash -c \""<<getenv("MED_ROOT_DIR")<<"/bin/salome/mprint_version \'"<<theFileName<<"\'\"";
      if(!MYDEBUG)
        aStr<<" 2>&1 > /dev/null";

      std::string aCommand = aStr.str();
      int aStatus = system(aCommand.c_str());

      BEGMSG(MYDEBUG,"aCommand = '"<<aCommand<<"'; aStatus = "<<aStatus<<std::endl);
      if(aStatus != 0)
        return aVersion;
    }
#endif
    // check compatibility of hdf and med versions
    med_bool hdfok, medok;
    MEDfileCompatibility(theFileName.c_str(), &hdfok, &medok);
    if ((!hdfok) /*|| (!medok)*/) // med-2.1 is KO since med-3.0.0
      return aVersion;

    // Next, try to open the file trough the MED API
    const char* aFileName = theFileName.c_str();
    med_idt aFid = MEDfileOpen(aFileName,MED_ACC_RDONLY);

    MSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aFid = "<<aFid<<std::endl);
    if(aFid >= 0){
      med_int aMajor, aMinor, aRelease;
      med_err aRet = MEDfileNumVersionRd(aFid,&aMajor,&aMinor,&aRelease);
      INITMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aRet = "<<aRet<<std::endl);
      if(aRet >= 0){
        if(aMajor == 2 && aMinor == 1)
          aVersion = eV2_1;
        else
          aVersion = eV2_2;
      }
      else {
        // VSR: simulate med 2.3.6 behavior, med file version is assumed to 2.1
        aVersion = eV2_1;
      }
    }
    MEDfileClose(aFid);

    BEGMSG(MYDEBUG,"GetVersionId - theFileName = '"<<theFileName<<"'; aVersion = "<<aVersion<<std::endl);
    return aVersion;
  }

Here is the caller graph for this function:

template<EVersion >
void MEDWRAPPER_EXPORT MED::GetVersionRelease ( TInt &  majeur,
TInt &  mineur,
TInt &  release 
)
template<>
void MED_V21_WRAPPER_EXPORT MED::GetVersionRelease< eV2_1 > ( TInt &  majeur,
TInt &  mineur,
TInt &  release 
)

Definition at line 83 of file MED_V2_1_Wrapper.cxx.

  {
    MEDversionDonner(&majeur, &mineur, &release);
  }

Here is the call graph for this function:

template<>
void MED_V22_WRAPPER_EXPORT MED::GetVersionRelease< eV2_2 > ( TInt &  majeur,
TInt &  mineur,
TInt &  release 
)

Definition at line 85 of file MED_V2_2_Wrapper.cxx.

  {
    majeur=MED_MAJOR_NUM;
    mineur=MED_MINOR_NUM;
    release=MED_RELEASE_NUM;
  }
bool MED::IsEqual ( TFloat  theLeft,
TFloat  theRight 
) [inline]

Definition at line 151 of file MED_GaussUtils.cxx.

  {
    static TFloat EPS = 1.0E-3;
    if(fabs(theLeft) + fabs(theRight) > EPS)
      return fabs(theLeft-theRight)/(fabs(theLeft)+fabs(theRight)) < EPS;
    return true;
  }
bool MED::operator< ( const TFamilyTSize &  theLeft,
const TFamilyTSize &  theRight 
)

Definition at line 183 of file MED_Algorithm.cxx.

  {
    const MED::PFamilyInfo& aLeftInfo = boost::get<0>(theLeft);
    const MED::PFamilyInfo& aRightInfo = boost::get<0>(theRight);
    return aLeftInfo->GetId() < aRightInfo->GetId();
  }
template<class TimeStampValueType >
void MED::Print ( SharedPtr< TimeStampValueType >  theTimeStampValue)

Definition at line 478 of file MED_Wrapper.cxx.

  {
    INITMSG(MYDEBUG,"Print - TimeStampValue\n");
    typename TimeStampValueType::TTGeom2Value& aGeom2Value = theTimeStampValue->myGeom2Value;
    typename TimeStampValueType::TTGeom2Value::const_iterator anIter = aGeom2Value.begin();
    for(; anIter != aGeom2Value.end(); anIter++){
      const EGeometrieElement& aGeom = anIter->first;
      const typename TimeStampValueType::TTMeshValue& aMeshValue = anIter->second;
      TInt aNbElem = aMeshValue.myNbElem;
      TInt aNbGauss = aMeshValue.myNbGauss;
      TInt aNbComp = aMeshValue.myNbComp;
      INITMSG(MYDEBUG,"aGeom = "<<aGeom<<" - "<<aNbElem<<": ");
      for(TInt iElem = 0; iElem < aNbElem; iElem++){
        typename TimeStampValueType::TTMeshValue::TCValueSliceArr aValueSliceArr = aMeshValue.GetGaussValueSliceArr(iElem);
        ADDMSG(MYVALUEDEBUG,"{");
        for(TInt iGauss = 0; iGauss < aNbGauss; iGauss++){
          const typename TimeStampValueType::TTMeshValue::TCValueSlice& aValueSlice = aValueSliceArr[iGauss];
          for(TInt iComp = 0; iComp < aNbComp; iComp++){
            ADDMSG(MYVALUEDEBUG,aValueSlice[iComp]<<" ");
          }
          ADDMSG(MYVALUEDEBUG,"| ");
        }
        ADDMSG(MYVALUEDEBUG,"} ");
      }
      ADDMSG(MYDEBUG,"\n");
    }
  }
MEDWRAPPER_EXPORT void MED::SetString ( TInt  theId,
TInt  theStep,
TString theString,
const std::string &  theValue 
)

Set a substring in the sequence of the strings.

Definition at line 53 of file MED_Structures.cxx.

  {
    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
    char* aPos = &theString[theId*theStep];
    strncpy(aPos,theValue.c_str(),aSize);
  }

Here is the caller graph for this function:

MEDWRAPPER_EXPORT void MED::SetString ( TInt  theId,
TInt  theStep,
TString theString,
const TString theValue 
)

Set a substring in the sequence of the strings.

Definition at line 64 of file MED_Structures.cxx.

  {
    TInt aSize = std::min(TInt(theValue.size()+1),theStep);
    char* aPos = &theString[theId*theStep];
    const char* aValue = &theValue[0];
    strncpy(aPos,aValue,aSize);
  }

Variable Documentation

Initial value:
 {
    &GetCoord<eX>, 
    &GetCoord<eNone>,
    &GetCoord<eNone>
  }

Definition at line 80 of file MED_CoordUtils.cxx.

Initial value:
 {
    &GetCoord<eX>, 
    &GetCoord<eY>, 
    &GetCoord<eNone>
  }

Definition at line 58 of file MED_CoordUtils.cxx.

Initial value:
 {
    &GetCoord<eX>, 
    &GetCoord<eY>, 
    &GetCoord<eZ>
  }

Definition at line 51 of file MED_CoordUtils.cxx.

Initial value:
 {
    &GetCoord<eX>, 
    &GetCoord<eNone>,
    &GetCoord<eY>
  }

Definition at line 72 of file MED_CoordUtils.cxx.

Initial value:
 {
    &GetCoord<eNone>,
    &GetCoord<eX>, 
    &GetCoord<eNone>
  }

Definition at line 87 of file MED_CoordUtils.cxx.

Initial value:
 {
    &GetCoord<eNone>,
    &GetCoord<eX>, 
    &GetCoord<eY>
  }

Definition at line 65 of file MED_CoordUtils.cxx.

Initial value:
 {
    &GetCoord<eNone>,
    &GetCoord<eNone>,
    &GetCoord<eX>
  }

Definition at line 94 of file MED_CoordUtils.cxx.