ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-25 17:00:34 +05:00
Code Issues Packages Projects Releases Wiki Activity
2a1407f46f
smesh/src/MEDWrapper/MED_Structures.hxx

1073 lines
40 KiB
C++
Raw Blame History

// Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#ifndef MED_Structures_HeaderFile
#define MED_Structures_HeaderFile
#include "MED_WrapperDef.hxx"
#include "MED_Common.hxx"
#include "MED_Utilities.hxx"
#include "MED_SliceArray.hxx"
#include <boost/tuple/tuple.hpp>
#ifdef WIN32
#pragma warning(disable:4251)
#endif
namespace MED
{
//---------------------------------------------------------------
//! Defines a type for managing sequence of strings
typedef TVector<char> TString;
typedef SharedPtr<TString> PString;
//---------------------------------------------------------------
//! Extract a substring from the sequence of the strings
MEDWRAPPER_EXPORT
std::string
GetString(TInt theId,
TInt theStep,
const TString& theString);
//---------------------------------------------------------------
//! Set a substring in the sequence of the strings
MEDWRAPPER_EXPORT
void
SetString(TInt theId,
TInt theStep,
TString& theString,
const std::string& theValue);
//---------------------------------------------------------------
//! Set a substring in the sequence of the strings
MEDWRAPPER_EXPORT
void
SetString(TInt theId,
TInt theStep,
TString& theString,
const TString& theValue);
//---------------------------------------------------------------
//! Define a parent class for all MEDWrapper classes
struct MEDWRAPPER_EXPORT TBase
{
virtual ~TBase() {}
};
//---------------------------------------------------------------
//! Define a parent class for all named MED entities
struct MEDWRAPPER_EXPORT TNameInfo: virtual TBase
{
TString myName; //!< Keeps its name
virtual std::string GetName() const = 0; //!< Gets its name
virtual void SetName(const std::string& theValue) = 0; //!< Set a new name
virtual void SetName(const TString& theValue) = 0; //!< Set a new name
};
//---------------------------------------------------------------
//! Define a parent class for all MED entities that contains a sequence of numbers
/*!
It defines through corresponding enumeration (EModeSwitch) how the sequence
should be interpreted in C or Fortran mode (eFULL_INTERLACE or eNON_INTERLACE).
*/
struct MEDWRAPPER_EXPORT TModeSwitchInfo: virtual TBase
{
//! To construct instance of the class by default
TModeSwitchInfo():
myModeSwitch(eFULL_INTERLACE)
{}
//! To construct instance of the class
TModeSwitchInfo(EModeSwitch theModeSwitch):
myModeSwitch(theModeSwitch)
{}
EModeSwitch myModeSwitch; //!< Keeps the interlace mode
EModeSwitch GetModeSwitch() const { return myModeSwitch; }
};
//---------------------------------------------------------------
//! Define a base class which represents MED Mesh entity
struct MEDWRAPPER_EXPORT TMeshInfo: virtual TNameInfo
{
TInt myDim; //!< Dimension of the mesh (0, 1, 2 or 3)
TInt GetDim() const { return myDim; } //!< Gets dimension of the mesh
TInt mySpaceDim;
TInt GetSpaceDim() const { return mySpaceDim; }
EMaillage myType; //!< Type of the mesh
EMaillage GetType() const { return myType; } //!< Gets type of the mesh
TString myDesc; //!< Description of the mesh
virtual std::string GetDesc() const = 0; //!< Get description for the mesh
virtual void SetDesc(const std::string& theValue) = 0; //!< Sets description for the mesh
};
//---------------------------------------------------------------
typedef TSlice<TInt> TIntVecSlice;
typedef TCSlice<TInt> TCIntVecSlice;
typedef TIntVector TFamAttr;
//---------------------------------------------------------------
//! Define a base class which represents MED Family entity
struct MEDWRAPPER_EXPORT TFamilyInfo: virtual TNameInfo
{
PMeshInfo myMeshInfo; //!< A reference to corresponding MED Mesh
//! Get a reference to corresponding MED Mesh
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
TInt myId; //!< An unique index of the MED FAMILY
TInt GetId() const { return myId; } //!< Gets number of the MED FAMILY
void SetId(TInt theId) { myId = theId; } //! Define number of the MED FAMILY
TInt myNbGroup; //!< Defines number MED Groups connected to
//! Gets number of MED GROUPS the MED FAMILY is bound to
TInt GetNbGroup() const { return myNbGroup; }
//! Contains sequence of the names for the MED Groups connected to
TString myGroupNames;
//! Gets name of a bound MED GROUP by its number
virtual std::string GetGroupName(TInt theId) const = 0;
//! Sets name of the defined MED GROUP by its number
virtual void SetGroupName(TInt theId, const std::string& theValue) = 0;
TInt myNbAttr; //!< Defines number of the MED Family attributes
//! Gets number of attached attributes for the MED FAMILY
TInt GetNbAttr() const { return myNbAttr; }
//! Defines sequence of the indexes of the MED Family attributes
TFamAttr myAttrId;
//! Get MED FAMILY attribute by its number
TInt GetAttrId(TInt theId) const;
//! Set MED FAMILY attribute by its number
void SetAttrId(TInt theId, TInt theVal);
//! Defines sequence of the values of the MED Family attributes
TFamAttr myAttrVal;
//! Get MED FAMILY attribute by its number
TInt GetAttrVal(TInt theId) const;
//! Set MED FAMILY attribute by its number
void SetAttrVal(TInt theId, TInt theVal);
//! Defines sequence of the names of the MED Family attributes
TString myAttrDesc;
//! Get value of the MED FAMILY attribute by its number
virtual std::string GetAttrDesc(TInt theId) const = 0;
//! Set value of the MED FAMILY attribute by its number
virtual void SetAttrDesc(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
typedef TIntVector TElemNum;
typedef SharedPtr<TElemNum> PElemNum;
//---------------------------------------------------------------
//! Define a parent class for all MED entities that describes mesh entities such as nodes and cells.
struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase
{
PMeshInfo myMeshInfo; //!< A reference to corresponding MED Mesh
//! Get a reference to corresponding MED Mesh
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
TInt myNbElem; //<! Number of corresponding mesh entities
TInt GetNbElem() const { return myNbElem; } //! Get number of mesh elements
//! Defines sequence MED Family indexes for corresponding mesh entities
PElemNum myFamNum;
//! Get number of a MED FAMILY by order number of the mesh element
TInt GetFamNum(TInt theId) const;
//! Set number of a MED FAMILY for the mesh element with the order number
void SetFamNum(TInt theId, TInt theVal);
//! Defines if the mesh elements are indexed
EBooleen myIsElemNum;
//! Let know if the mesh elements are indexed
EBooleen IsElemNum() const { return myIsElemNum; }
//! Defines if the mesh elements family are indexed
EBooleen myIsFamNum;
//! Let know if the mesh elements family are indexed
EBooleen IsFamNum() const { return myIsFamNum; }
//! Contains sequence of the indexes for the mesh elements
PElemNum myElemNum;
//! Get a reference number of the mesh element by its order number
TInt GetElemNum(TInt theId) const;
//! Set a reference number for the mesh element by its order number
void SetElemNum(TInt theId, TInt theVal);
//! Defines if the mesh elements are named
EBooleen myIsElemNames;
//! Let know if the mesh elements have names
EBooleen IsElemNames() const { return myIsElemNames; }
//! Contains sequence of the names for the mesh elements
PString myElemNames;
//! Get name of the mesh element by its order number
virtual std::string GetElemName(TInt theId) const = 0;
//! Set name of the mesh element by its order number
virtual void SetElemName(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
typedef TSlice<TFloat> TFloatVecSlice;
typedef TCSlice<TFloat> TCFloatVecSlice;
typedef TFloatVector TNodeCoord;
typedef SharedPtr<TNodeCoord> PNodeCoord;
typedef TFloatVecSlice TCoordSlice;
typedef TCFloatVecSlice TCCoordSlice;
//---------------------------------------------------------------
//! Define a base class which represents MED Nodes entity
struct MEDWRAPPER_EXPORT TNodeInfo:
virtual TElemInfo,
virtual TModeSwitchInfo
{
PNodeCoord myCoord; //!< Contains all nodal coordinates
//! Gives coordinates for mesh node by its number (const version)
TCCoordSlice GetCoordSlice(TInt theId) const;
//! Gives coordinates for mesh node by its number
TCoordSlice GetCoordSlice(TInt theId);
ERepere mySystem; //!< Defines, which coordinate system is used
//! Get which coordinate system is used for the node describing
ERepere GetSystem() const { return mySystem; }
//! Set coordinate system to be used for the node describing
void SetSystem(ERepere theSystem) { mySystem = theSystem; }
TString myCoordNames; //!< Contains names for the coordinate dimensions
//! Get name of the coordinate dimension by its order number
virtual std::string GetCoordName(TInt theId) const = 0;
//! Set name of the coordinate dimension by its order number
virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
TString myCoordUnits; //!< Contains units for the coordinate dimensions
//! Get name of unit for the coordinate dimension by its order number
virtual std::string GetCoordUnit(TInt theId) const = 0;
//! Set name of unit for the coordinate dimension by its order number
virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
typedef TIntVecSlice TConnSlice;
typedef TCIntVecSlice TCConnSlice;
//---------------------------------------------------------------
//! Define a base class which represents MED Cells entity
struct MEDWRAPPER_EXPORT TCellInfo:
virtual TElemInfo,
virtual TModeSwitchInfo
{
EEntiteMaillage myEntity; //!< Defines the MED Entity where the mesh cells belongs to
//! Find out what MED ENTITY the cells belong to
EEntiteMaillage GetEntity() const { return myEntity; }
EGeometrieElement myGeom; //!< Defines the MED Geometric type of the instance
//! Find out what MED geometrical type the cells belong to
EGeometrieElement GetGeom() const { return myGeom; }
EConnectivite myConnMode; //!< Defines connectivity mode
//! Find out in what connectivity the cells are written
EConnectivite GetConnMode() const { return myConnMode; }
virtual TInt GetConnDim() const = 0; //!< Gives step in the connectivity sequence
PElemNum myConn; //!< Defines sequence which describe connectivity for each of mesh cell
//! Gives connectivities for mesh cell by its number (const version)
TCConnSlice GetConnSlice(TInt theElemId) const;
//! Gives connectivities for mesh cell by its number
TConnSlice GetConnSlice(TInt theElemId);
};
//---------------------------------------------------------------
//! Define a base class which represents MED Polygon entity
struct MEDWRAPPER_EXPORT TPolygoneInfo:
virtual TElemInfo
{
//! Defines the MED Entity where the polygons belongs to
EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
//! Find out what MED ENTITY the MED Polygons belong to
EEntiteMaillage GetEntity() const { return myEntity; }
//! Defines the MED Geometric type of the instance
EGeometrieElement myGeom; // ePOLYGONE
//! Find out what MED geometrical type the MED Polygons belong to
EGeometrieElement GetGeom() const { return ePOLYGONE; }
//! Defines connectivity mode
EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
//! Find out in what connectivity the cells are written
EConnectivite GetConnMode() const { return myConnMode; }
PElemNum myConn; //!< Table de connectivities
PElemNum myIndex; //!< Table de indexes
//! Gives number of the connectivities for the defined polygon
TInt GetNbConn(TInt theElemId) const;
//! Gives connectivities for polygon by its number (const version)
TCConnSlice GetConnSlice(TInt theElemId) const;
//! Gives connectivities for polygon by its number
TConnSlice GetConnSlice(TInt theElemId);
};
//---------------------------------------------------------------
//! Define a class representing MED_BALL structure element.
/*!
This could be a generic class for any structure element
holding any number of constant and variable attributes
but it's too hard to implement
*/
struct MEDWRAPPER_EXPORT TBallInfo:
virtual TCellInfo
{
TFloatVector myDiameters;
};
//---------------------------------------------------------------
typedef TVector<TCConnSlice> TCConnSliceArr;
typedef TVector<TConnSlice> TConnSliceArr;
//---------------------------------------------------------------
//! Define a base class which represents MED Polyedre entity
struct MEDWRAPPER_EXPORT TPolyedreInfo:
virtual TElemInfo
{
//! Defines the MED Entity where the polyedres belongs to
EEntiteMaillage myEntity; // MED_FACE|MED_MAILLE
//! Find out what MED ENTITY the MED Polyedres belong to
EEntiteMaillage GetEntity() const { return myEntity; }
//! Defines the MED Geometric type of the instance
EGeometrieElement myGeom; // ePOLYEDRE
//! Find out what MED geometrical type the MED Polyedres belong to
EGeometrieElement GetGeom() const { return ePOLYEDRE; }
//! Defines connectivity mode
EConnectivite myConnMode; // eNOD|eDESC(eDESC not used)
//! Find out in what connectivity the cells are written
EConnectivite GetConnMode() const { return myConnMode; }
PElemNum myConn; //!< Table de connectivities
PElemNum myFaces; //!< Table de faces indexes
PElemNum myIndex; //!< Table de indexes
//! Gives number of the faces for the defined polyedre (const version)
TInt GetNbFaces(TInt theElemId) const;
//! Gives number of the nodes for the defined polyedre
TInt GetNbNodes(TInt theElemId) const;
//! Gives sequence of the face connectivities for polyedre by its number (const version)
TCConnSliceArr GetConnSliceArr(TInt theElemId) const;
//! Gives sequence of the face connectivities for polyedre by its number
TConnSliceArr GetConnSliceArr(TInt theElemId);
};
//---------------------------------------------------------------
//! Define a base class which represents MED Field entity
struct MEDWRAPPER_EXPORT TFieldInfo:
virtual TNameInfo
{
PMeshInfo myMeshInfo; //!< A reference to corresponding MED Mesh
//! Get a reference to corresponding MED Mesh
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
ETypeChamp myType; //!< Defines type of MED Field
//! Find out what type of MED FIELD is used
ETypeChamp GetType() const { return myType; }
TInt myNbComp; //!< Defines number of components stored in the field
//! Get number of components for MED FIELD
TInt GetNbComp() const { return myNbComp; }
EBooleen myIsLocal; //!< Defines if the MED Field is local
//! Find out if MED FIELD is local or not
EBooleen GetIsLocal() const { return myIsLocal; }
TInt myNbRef; //!< Defines number of references of the field
//! Find out number of references for the MED FIELD
TInt GetNbRef() const { return myNbRef; }
TString myCompNames; //!< Contains names for each of MED Field components
//! Get name of the component by its order number
virtual std::string GetCompName(TInt theId) const = 0;
//! Set name for the component by its order number
virtual void SetCompName(TInt theId, const std::string& theValue) = 0;
TString myUnitNames; //!< Contains units for each of MED Field components
//! Get unit of the component by its order number
virtual std::string GetUnitName(TInt theId) const = 0;
//! Set unit for the component by its order number
virtual void SetUnitName(TInt theId, const std::string& theValue) = 0;
};
//---------------------------------------------------------------
//! Get dimension of the Gauss coordinates for the defined type of mesh cell
MEDWRAPPER_EXPORT
TInt
GetDimGaussCoord(EGeometrieElement theGeom);
//---------------------------------------------------------------
//! Get number of referenced nodes for the defined type of mesh cell
MEDWRAPPER_EXPORT
TInt
GetNbRefCoord(EGeometrieElement theGeom);
//---------------------------------------------------------------
typedef TFloatVector TWeight;
//---------------------------------------------------------------
//! The class represents MED Gauss entity
struct MEDWRAPPER_EXPORT TGaussInfo:
virtual TNameInfo,
virtual TModeSwitchInfo
{
typedef boost::tuple<EGeometrieElement,std::string> TKey;
typedef boost::tuple<TKey,TInt> TInfo;
struct MEDWRAPPER_EXPORT TLess
{
bool
operator()(const TKey& theLeft, const TKey& theRight) const;
bool
operator()(const TGaussInfo& theLeft, const TGaussInfo& theRight) const;
};
//! Defines, which geometrical type the MED Gauss entity belongs to
EGeometrieElement myGeom;
//! Find out what MED geometrical type the MED GAUSS entity belong to
EGeometrieElement GetGeom() const { return myGeom; }
//! Contains coordinates for the refereced nodes
TNodeCoord myRefCoord;
//! Gives coordinates for the referenced node by its number
TCCoordSlice GetRefCoordSlice(TInt theId) const;
//! Gives coordinates for the referenced node by its number
TCoordSlice GetRefCoordSlice(TInt theId);
//! Contains coordinates for the Gauss points
TNodeCoord myGaussCoord;
//! Gives coordinates for the Gauss points by its number
TCCoordSlice GetGaussCoordSlice(TInt theId) const;
//! Gives coordinates for the Gauss points by its number
TCoordSlice GetGaussCoordSlice(TInt theId);
//! Contains wheights for the Gauss points
TWeight myWeight;
//! Gives number of the referenced nodes
TInt GetNbRef() const { return GetNbRefCoord(GetGeom()); }
//! Gives dimension of the referenced nodes
TInt GetDim() const { return GetDimGaussCoord(GetGeom()); }
//! Gives number of the Gauss Points
TInt GetNbGauss() const { return (TInt)(myGaussCoord.size() / GetDim()); }
};
//---------------------------------------------------------------
typedef std::map<EGeometrieElement,PGaussInfo> TGeom2Gauss;
typedef std::map<EGeometrieElement,TInt> TGeom2NbGauss;
//---------------------------------------------------------------
//! Define a base class which represents MED TimeStamp
struct MEDWRAPPER_EXPORT TTimeStampInfo:
virtual TBase
{
PFieldInfo myFieldInfo; //!< A reference to corresponding MED Field
//! Get a reference to corresponding MED Field
const PFieldInfo& GetFieldInfo() const { return myFieldInfo; }
//! Defines the MED Entity where the MED TimeStamp belongs to
EEntiteMaillage myEntity;
//! Find out to what MED Entity the MED TimeStamp belong to
EEntiteMaillage GetEntity() const { return myEntity; }
//! Keeps map of number of cells per geometric type where the MED TimeStamp belongs to
TGeom2Size myGeom2Size;
//! Get map of number of cells per geometric type where the MED TimeStamp belongs to
const TGeom2Size& GetGeom2Size() const { return myGeom2Size; }
TGeom2NbGauss myGeom2NbGauss; //!< Keeps number of the Gauss Points for the MED TimeStamp
TInt GetNbGauss(EGeometrieElement theGeom) const; //!< Gives number of the Gauss Points for the MED TimeStamp
TInt myNumDt; //!< Keeps number in time for the MED TimeStamp
TInt GetNumDt() const { return myNumDt; } //!< Defines number in time for the MED TimeStamp
TInt myNumOrd; //!< Keeps number for the MED TimeStamp
TInt GetNumOrd() const { return myNumOrd; } //!< Defines number for the MED TimeStamp
TFloat myDt; //!< Keeps time for the MED TimeStamp
TFloat GetDt() const { return myDt; } //!< Defines time for the MED TimeStamp
//! Keeps map of MED Gauss entityes per geometric type
TGeom2Gauss myGeom2Gauss;
//! Gets a map of MED Gauss entityes per geometric type
const TGeom2Gauss& GetGeom2Gauss() const { return myGeom2Gauss; }
TString myUnitDt; //!< Defines unit for the time for the MED TimeStamp
//! Get unit of time for the MED TimeStamp
virtual std::string GetUnitDt() const = 0;
//! Set unit of time for the MED TimeStamp
virtual void SetUnitDt(const std::string& theValue) = 0;
};
//---------------------------------------------------------------
//! The class represents MED Profile entity
struct MEDWRAPPER_EXPORT TProfileInfo:
virtual TNameInfo
{
typedef std::string TKey;
typedef boost::tuple<TKey,TInt> TInfo;
EModeProfil myMode; //!< Keeps mode for the MED Profile
//! Find out what mode of MED Profile is used
EModeProfil GetMode() const { return myMode; }
//! Set mode for the MED Profile
void SetMode(EModeProfil theMode) { myMode = theMode; }
PElemNum myElemNum; //!< Keeps sequence of cell by its number which belong to the profile
//! Get number of mesh elelemts by its order number
TInt GetElemNum(TInt theId) const;
//! Set number of mesh elelemts by its order number
void SetElemNum(TInt theId, TInt theVal);
//! Find out if the MED Profile defined
bool IsPresent() const { return GetName() != ""; }
//! Find out size of the MED Profile
TInt GetSize() const { return (TInt)myElemNum->size(); }
};
//---------------------------------------------------------------
//! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp
struct MEDWRAPPER_EXPORT TMeshValueBase:
virtual TModeSwitchInfo
{
TInt myNbElem;
TInt myNbComp;
TInt myNbGauss;
TInt myStep;
TMeshValueBase();
//! Initialize the class
void
Allocate(TInt theNbElem,
TInt theNbGauss,
TInt theNbComp,
EModeSwitch theMode = eFULL_INTERLACE);
//! Returns size of the value container
size_t
GetSize() const;
//! Returns MED interpretation of the value size
size_t
GetNbVal() const;
//! Returns number of Gauss Points bounded with the value
size_t
GetNbGauss() const;
//! Returns step inside of the data array
size_t
GetStep() const;
//! Returns bare pointer on the internal value representation
virtual
unsigned char*
GetValuePtr() = 0;
};
//---------------------------------------------------------------
//! The class is a helper one. It provide safe and flexible way to get access to values for a MED TimeStamp
template<class TValueType>
struct TTMeshValue:
virtual TMeshValueBase
{
typedef TValueType TValue;
typedef typename TValueType::value_type TElement;
typedef TSlice<TElement> TValueSlice;
typedef TCSlice<TElement> TCValueSlice;
typedef TVector<TCValueSlice> TCValueSliceArr;
typedef TVector<TValueSlice> TValueSliceArr;
TValue myValue;
//! Initialize the class
void
Allocate(TInt theNbElem,
TInt theNbGauss,
TInt theNbComp,
EModeSwitch theMode = eFULL_INTERLACE)
{
TMeshValueBase::Allocate(theNbElem, theNbGauss, theNbComp, theMode);
myValue.resize(theNbElem * this->GetStep());
}
//! Returns bare pointer on the internal value representation
virtual
unsigned char*
GetValuePtr()
{
return (unsigned char*)&myValue[0];
}
//! Returns bare pointer on the internal value representation
virtual
TElement*
GetPointer()
{
return &myValue[0];
}
//! Returns bare pointer on the internal value representation
virtual
const TElement*
GetPointer() const
{
return &myValue[0];
}
//! Iteration through Gauss Points by their components
TCValueSliceArr
GetGaussValueSliceArr(TInt theElemId) const
{
TCValueSliceArr aValueSliceArr(myNbGauss);
if(GetModeSwitch() == eFULL_INTERLACE){
TInt anId = theElemId * myStep;
for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
aValueSliceArr[aGaussId] =
TCValueSlice(myValue, std::slice(anId, myNbComp, 1));
anId += myNbComp;
}
}
else{
for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
aValueSliceArr[aGaussId] =
TCValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
}
}
return aValueSliceArr;
}
//! Iteration through Gauss Points by their components
TValueSliceArr
GetGaussValueSliceArr(TInt theElemId)
{
TValueSliceArr aValueSliceArr(myNbGauss);
if(GetModeSwitch() == eFULL_INTERLACE){
TInt anId = theElemId*myStep;
for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
aValueSliceArr[aGaussId] =
TValueSlice(myValue, std::slice(anId, myNbComp, 1));
anId += myNbComp;
}
}
else{
for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
aValueSliceArr[aGaussId] =
TValueSlice(myValue, std::slice(theElemId, myNbComp, myStep));
}
}
return aValueSliceArr;
}
//! Iteration through components by corresponding Gauss Points
TCValueSliceArr
GetCompValueSliceArr(TInt theElemId) const
{
TCValueSliceArr aValueSliceArr(myNbComp);
if(GetModeSwitch() == eFULL_INTERLACE){
TInt anId = theElemId*myStep;
for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
aValueSliceArr[aCompId] =
TCValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
anId += 1;
}
}
else{
for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
aValueSliceArr[aCompId] =
TCValueSlice(myValue, std::slice(theElemId, myNbGauss, myStep));
}
}
return aValueSliceArr;
}
//! Iteration through components by corresponding Gauss Points
TValueSliceArr
GetCompValueSliceArr(TInt theElemId)
{
if(GetModeSwitch() == eFULL_INTERLACE){
TValueSliceArr aValueSliceArr(myNbComp);
TInt anId = theElemId*myStep;
for(TInt aCompId = 0; aCompId < myNbComp; aCompId++){
aValueSliceArr[aCompId] =
TValueSlice(myValue, std::slice(anId, myNbGauss, myNbComp));
anId += 1;
}
return aValueSliceArr;
}
else{
TValueSliceArr aValueSliceArr(myNbGauss);
for(TInt aGaussId = 0; aGaussId < myNbGauss; aGaussId++){
aValueSliceArr[aGaussId] =
TValueSlice(myValue,std::slice(theElemId, myNbComp, myStep));
}
return aValueSliceArr;
}
}
};
//---------------------------------------------------------------
typedef TTMeshValue<TFloatVector> TFloatMeshValue;
typedef TTMeshValue<TIntVector> TIntMeshValue;
//---------------------------------------------------------------
// Backward compatibility declarations
typedef TFloatVector TValue;
typedef TSlice<TFloat> TValueSlice;
typedef TCSlice<TFloat> TCValueSlice;
typedef TVector<TCValueSlice> TCValueSliceArr;
typedef TVector<TValueSlice> TValueSliceArr;
typedef TFloatMeshValue TMeshValue;
typedef std::map<EGeometrieElement,TMeshValue> TGeom2Value;
//---------------------------------------------------------------
typedef std::map<EGeometrieElement,PProfileInfo> TGeom2Profile;
typedef std::set<EGeometrieElement> TGeom;
//---------------------------------------------------------------
//! The class is a base class for MED TimeStamp values holder
struct MEDWRAPPER_EXPORT TTimeStampValueBase:
virtual TModeSwitchInfo
{
//! A reference to corresponding MED TimeStamp
PTimeStampInfo myTimeStampInfo;
//!< Get a reference to corresponding MED TimeStamp
const PTimeStampInfo& GetTimeStampInfo() const { return myTimeStampInfo; }
//! Keeps set of MED EGeometrieElement which contains values for the timestamp
TGeomSet myGeomSet;
const TGeomSet& GetGeomSet() const { return myGeomSet; }
//! Keeps map of MED Profiles per geometric type
TGeom2Profile myGeom2Profile;
//! Gets a map of MED Profiles per geometric type
const TGeom2Profile& GetGeom2Profile() const { return myGeom2Profile; }
//! Gets type of the champ
virtual
ETypeChamp
GetTypeChamp() const = 0;
//! Allocates values for the given geometry
virtual
void
AllocateValue(EGeometrieElement theGeom,
TInt theNbElem,
TInt theNbGauss,
TInt theNbComp,
EModeSwitch theMode = eFULL_INTERLACE) = 0;
virtual
size_t
GetValueSize(EGeometrieElement theGeom) const = 0;
virtual
size_t
GetNbVal(EGeometrieElement theGeom) const = 0;
virtual
size_t
GetNbGauss(EGeometrieElement theGeom) const = 0;
virtual
unsigned char*
GetValuePtr(EGeometrieElement theGeom) = 0;
};
//---------------------------------------------------------------
//! The class implements a container for MED TimeStamp values
template<class TMeshValueType>
struct TTimeStampValue:
virtual TTimeStampValueBase
{
typedef TMeshValueType TTMeshValue;
typedef SharedPtr<TMeshValueType> PTMeshValue;
typedef typename TMeshValueType::TElement TElement;
typedef std::map<EGeometrieElement, PTMeshValue> TTGeom2Value;
ETypeChamp myTypeChamp; //<! Keeps type of the champ
//! Gets type of the champ
virtual
ETypeChamp
GetTypeChamp() const
{
return myTypeChamp;
}
//! Keeps map of MED TimeStamp values per geometric type (const version)
TTGeom2Value myGeom2Value;
const TTGeom2Value&
GetGeom2Value() const
{
return myGeom2Value;
}
//! Gets MED TimeStamp values for the given geometric type (const version)
const PTMeshValue&
GetMeshValuePtr(EGeometrieElement theGeom) const
{
typename TTGeom2Value::const_iterator anIter = myGeom2Value.find(theGeom);
if(anIter == myGeom2Value.end())
EXCEPTION(std::runtime_error,"TTimeStampValue::GetMeshValuePtr - myGeom2Value.find(theGeom) fails");
return anIter->second;
}
//! Gets MED TimeStamp values for the given geometric type
PTMeshValue&
GetMeshValuePtr(EGeometrieElement theGeom)
{
myGeomSet.insert(theGeom);
if(myGeom2Value.find(theGeom) == myGeom2Value.end()){
myGeom2Value[theGeom] = PTMeshValue(new TTMeshValue());
return myGeom2Value[theGeom];
}
return myGeom2Value[theGeom];
}
//! Gets MED TimeStamp values for the given geometric type (const version)
const TTMeshValue&
GetMeshValue(EGeometrieElement theGeom) const
{
return *(this->GetMeshValuePtr(theGeom));
}
//! Gets MED TimeStamp values for the given geometric type
TTMeshValue&
GetMeshValue(EGeometrieElement theGeom)
{
return *(this->GetMeshValuePtr(theGeom));
}
};
//---------------------------------------------------------------
typedef TTimeStampValue<TFloatMeshValue> TFloatTimeStampValue;
typedef SharedPtr<TFloatTimeStampValue> PFloatTimeStampValue;
PFloatTimeStampValue MEDWRAPPER_EXPORT
CastToFloatTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
typedef TTimeStampValue<TIntMeshValue> TIntTimeStampValue;
typedef SharedPtr<TIntTimeStampValue> PIntTimeStampValue;
PIntTimeStampValue MEDWRAPPER_EXPORT
CastToIntTimeStampValue(const PTimeStampValueBase& theTimeStampValue);
//---------------------------------------------------------------
template<class TMeshValueTypeFrom, class TMeshValueTypeTo>
void
CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueTypeFrom> > theTimeStampValueFrom,
SharedPtr<TTimeStampValue<TMeshValueTypeTo> > theTimeStampValueTo)
{
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
CopyTimeStampValue(SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueFrom,
SharedPtr<TTimeStampValue<TMeshValueType> > theTimeStampValueTo)
{
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;
}
}
//---------------------------------------------------------------
inline
void
CopyTimeStampValueBase(const PTimeStampValueBase& theValueFrom,
const PTimeStampValueBase& theValueTo)
{
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);
}
}
//---------------------------------------------------------------
// Backward compatibility declarations
typedef TFloatTimeStampValue TTimeStampVal;
typedef PFloatTimeStampValue PTimeStampVal;
//---------------------------------------------------------------
typedef std::map<TInt,TFloatVector> TIndexes;
typedef std::map<TInt,TString> TNames;
//---------------------------------------------------------------
//! Define a base class which represents MED Grille (structured mesh)
struct MEDWRAPPER_EXPORT TGrilleInfo:
virtual TModeSwitchInfo
{
PMeshInfo myMeshInfo;
const PMeshInfo& GetMeshInfo() const { return myMeshInfo; }
TNodeCoord myCoord; //!< Contains all nodal coordinates, now used only for eGRILLE_STANDARD
//! Gives coordinates for mesh nodes (const version)
const TNodeCoord& GetNodeCoord() const;
TNodeCoord& GetNodeCoord();
//! Gives coordinates for mesh node by its number, array index from 0
TNodeCoord GetCoord(TInt theId);
//! Gives ids of nodes for mesh cell or sub-cell by its number, array index from 0
TIntVector GetConn(TInt theId, const bool isSub=false);
EGrilleType myGrilleType; //!< Defines grille type (eGRILLE_CARTESIENNE,eGRILLE_POLAIRE,eGRILLE_STANDARD)
//!Gets grille type (const version)
const EGrilleType& GetGrilleType() const;
//!Gets grille type
EGrilleType GetGrilleType();
//!Sets grille type
void SetGrilleType(EGrilleType theGrilleType);
TString myCoordNames; //!< Contains names for the coordinate dimensions
//! Get name of the coordinate dimension by its order number
virtual std::string GetCoordName(TInt theId) const = 0 ;
//! Set name of the coordinate dimension by its order number
virtual void SetCoordName(TInt theId, const std::string& theValue) = 0;
TString myCoordUnits; //!< Contains units for the coordinate dimensions
//! Get name of unit for the coordinate dimension by its order number
virtual std::string GetCoordUnit(TInt theId) const = 0;
//! Set name of unit for the coordinate dimension by its order number
virtual void SetCoordUnit(TInt theId, const std::string& theValue) = 0;
//! Map of index of axes and Table of indexes for certain axe, now used for eGRILLE_CARTESIENNE and eGRILLE_POLAIRE
TIndexes myIndixes;
//!Gets a map of Tables (const version)
const TIndexes& GetMapOfIndexes() const ;
//!Gets a map of Tables
TIndexes& GetMapOfIndexes();
//!Gets a Table of indexes for certain axe(const version)
const TFloatVector& GetIndexes(TInt theAxisNumber) const;
//!Gets a Table of indexes for certain axe
TFloatVector& GetIndexes(TInt theAxisNumber);
//!Gets a number of indices per axe
TInt GetNbIndexes(TInt theAxisNumber);
TInt GetNbNodes();//! Return count of all points
TInt GetNbCells();//! Return count of all cells
TInt GetNbSubCells();//! Return count of all entities of <mesh dimension-1>
EGeometrieElement GetGeom();//! Return geometry of cells (calculated from mesh dimension)
EGeometrieElement GetSubGeom();//! Return geometry of subcells (calculated from mesh dimension)
EEntiteMaillage GetEntity();//! Return entity (eMAILLE)
EEntiteMaillage GetSubEntity();//! Return sub entity
/*!
*Vector of grille structure (Example: {3,4,5}, 3 nodes in X axe, 4 nodes in Y axe, ...)
*/
TIntVector myGrilleStructure;
//!Gets grille structure(const version)
const TIntVector& GetGrilleStructure() const;
//!Gets grille structure
TIntVector GetGrilleStructure();
//!Sets the grille structure of theAxis axe to theNb.
void SetGrilleStructure(TInt theAxis,TInt theNb);
/*!
*Defines sequence MED Family indexes for corresponding mesh entities
*/
TElemNum myFamNum;
//! Get number of a MED FAMILY by order number of the mesh element
TInt GetFamNum(TInt theId) const;
//! Set number of a MED FAMILY for the mesh element with the order number
void SetFamNum(TInt theId, TInt theVal);
/*!
*Defines sequence MED Family indexes for sub entities
*/
TElemNum myFamSubNum;
//! Get number of a MED FAMILY by order number of sub element
TInt GetFamSubNum(TInt theId) const;
//! Set number of a MED FAMILY for theId-th sub element
void SetFamSubNum(TInt theId, TInt theVal);
/*!
*Defines sequence MED Family indexes for corresponding mesh nodes
*/
TElemNum myFamNumNode;
//! Get number of a MED FAMILY by order number of the mesh node
TInt GetFamNumNode(TInt theId) const;
//! Set number of a MED FAMILY for the mesh node with the order number
void SetFamNumNode(TInt theId, TInt theVal);
};
}
#endif // MED_Structures_HeaderFile
Reference in New Issue View Git Blame Copy Permalink