ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-02-28 14:35:36 +05:00
Code Issues Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
vsr 2008-03-20 15:51:51 +00:00
parent 9668e927d7
commit 8b4b072d81
8 changed files with 35 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/StdMeshers/StdMeshers_Distribution.cxx
View File

@ -41,6 +41,8 @@
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
#endif #endif
using namespace std;
Function::Function( const int conv ) Function::Function( const int conv )
: myConv( conv ) : myConv( conv )
{ {

24
src/StdMeshers/StdMeshers_FaceSide.hxx
View File

@ -90,7 +90,7 @@ public:
* \brief Wrap several edges. Edges must be properly ordered and oriented. * \brief Wrap several edges. Edges must be properly ordered and oriented.
*/ */
StdMeshers_FaceSide(const TopoDS_Face& theFace, StdMeshers_FaceSide(const TopoDS_Face& theFace,
list<TopoDS_Edge>& theEdges, std::list<TopoDS_Edge>& theEdges,
SMESH_Mesh* theMesh, SMESH_Mesh* theMesh,
const bool theIsForward, const bool theIsForward,
const bool theIgnoreMediumNodes); const bool theIgnoreMediumNodes);
@ -130,13 +130,13 @@ public:
* *
* Missing nodes are allowed only on internal vertices * Missing nodes are allowed only on internal vertices
*/ */
const vector<UVPtStruct>& GetUVPtStruct(bool isXConst =0, double constValue =0) const; const std::vector<UVPtStruct>& GetUVPtStruct(bool isXConst =0, double constValue =0) const;
/*! /*!
* \brief Simulates detailed data on nodes * \brief Simulates detailed data on nodes
* \param isXConst - true if normalized parameter X is constant * \param isXConst - true if normalized parameter X is constant
* \param constValue - constant parameter value * \param constValue - constant parameter value
*/ */
const vector<UVPtStruct>& SimulateUVPtStruct(int nbSeg, const std::vector<UVPtStruct>& SimulateUVPtStruct(int nbSeg,
bool isXConst = 0, bool isXConst = 0,
double constValue = 0) const; double constValue = 0) const;
/*! /*!
@ -194,15 +194,15 @@ public:
protected: protected:
vector<uvPtStruct> myPoints, myFalsePoints; std::vector<uvPtStruct> myPoints, myFalsePoints;
vector<TopoDS_Edge> myEdge; std::vector<TopoDS_Edge> myEdge;
vector<Handle(Geom2d_Curve)> myC2d; std::vector<Handle(Geom2d_Curve)> myC2d;
vector<double> myFirst, myLast; std::vector<double> myFirst, myLast;
vector<double> myNormPar; std::vector<double> myNormPar;
double myLength; double myLength;
int myNbPonits, myNbSegments; int myNbPonits, myNbSegments;
SMESH_Mesh* myMesh; SMESH_Mesh* myMesh;
bool myMissingVertexNodes, myIgnoreMediumNodes; bool myMissingVertexNodes, myIgnoreMediumNodes;
}; };

2
src/StdMeshers/StdMeshers_Hexa_3D.hxx
View File

@ -92,7 +92,7 @@ protected:
int GetFaceIndex(SMESH_Mesh& aMesh, int GetFaceIndex(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape, const TopoDS_Shape& aShape,
const vector<SMESH_subMesh*>& meshFaces, const std::vector<SMESH_subMesh*>& meshFaces,
const TopoDS_Vertex& V0, const TopoDS_Vertex& V0,
const TopoDS_Vertex& V1, const TopoDS_Vertex& V1,
const TopoDS_Vertex& V2, const TopoDS_Vertex& V2,

12
src/StdMeshers/StdMeshers_Penta_3D.hxx
View File

@ -97,7 +97,7 @@ protected:
TopTools_IndexedMapOfOrientedShape myShapeIDMap; TopTools_IndexedMapOfOrientedShape myShapeIDMap;
SMESH_Block myTBlock; SMESH_Block myTBlock;
TopoDS_Shape myEmptyShape; TopoDS_Shape myEmptyShape;
vector<int> myIsEdgeForward; std::vector<int> myIsEdgeForward;
// //
int myErrorStatus; int myErrorStatus;
}; };
@ -216,8 +216,8 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ, double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ,
const int aFaceID, const int aFaceID,
vector<const SMDS_MeshNode*>*& aCol1, std::vector<const SMDS_MeshNode*>*& aCol1,
vector<const SMDS_MeshNode*>*& aCol2); std::vector<const SMDS_MeshNode*>*& aCol2);
void ShapeSupportID(const bool theIsUpperLayer, void ShapeSupportID(const bool theIsUpperLayer,
const SMESH_Block::TShapeID theBNSSID, const SMESH_Block::TShapeID theBNSSID,
@ -256,14 +256,14 @@ class STDMESHERS_EXPORT StdMeshers_Penta_3D {
void * myMesh; void * myMesh;
SMESH_ComputeErrorPtr myErrorStatus; SMESH_ComputeErrorPtr myErrorStatus;
// //
vector <StdMeshers_TNode> myTNodes; std::vector <StdMeshers_TNode> myTNodes;
int myISize; int myISize;
int myJSize; int myJSize;
double myTol3D; // Tolerance value double myTol3D; // Tolerance value
std::map < int, int > myConnectingMap; std::map < int, int > myConnectingMap;
// //
vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face std::vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
vector<gp_XYZ> myShapeXYZ; // point on each sub-shape std::vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
bool myCreateQuadratic; bool myCreateQuadratic;
SMESH_MesherHelper* myTool; // tool building quadratic elements SMESH_MesherHelper* myTool; // tool building quadratic elements

16
src/StdMeshers/StdMeshers_Prism_3D.hxx
View File

@ -242,9 +242,9 @@ private:
BRepAdaptor_Surface mySurface; BRepAdaptor_Surface mySurface;
TopoDS_Edge myBaseEdge; TopoDS_Edge myBaseEdge;
// first and last normalized params and orientaion for each component or it-self // first and last normalized params and orientaion for each component or it-self
vector< pair< double, double> > myParams; std::vector< std::pair< double, double> > myParams;
bool myIsForward; bool myIsForward;
vector< TSideFace* > myComponents; std::vector< TSideFace* > myComponents;
SMESH_MesherHelper * myHelper; SMESH_MesherHelper * myHelper;
public: public:
TSideFace( SMESH_MesherHelper* helper, TSideFace( SMESH_MesherHelper* helper,
@ -255,7 +255,7 @@ private:
const double first = 0.0, const double first = 0.0,
const double last = 1.0); const double last = 1.0);
TSideFace( const std::vector< TSideFace* >& components, TSideFace( const std::vector< TSideFace* >& components,
const std::vector< pair< double, double> > & params); const std::vector< std::pair< double, double> > & params);
TSideFace( const TSideFace& other ); TSideFace( const TSideFace& other );
~TSideFace(); ~TSideFace();
bool IsComplex() const bool IsComplex() const
@ -347,9 +347,9 @@ private:
// container of 4 side faces // container of 4 side faces
TSideFace* mySide; TSideFace* mySide;
// node columns for each base edge // node columns for each base edge
vector< TParam2ColumnMap > myParam2ColumnMaps; std::vector< TParam2ColumnMap > myParam2ColumnMaps;
// to find a column for a node by edge SMESHDS Index // to find a column for a node by edge SMESHDS Index
map< int, pair< TParam2ColumnMap*, bool > > myShapeIndex2ColumnMap; std::map< int, std::pair< TParam2ColumnMap*, bool > > myShapeIndex2ColumnMap;
SMESH_ComputeErrorPtr myError; SMESH_ComputeErrorPtr myError;
/*! /*!
@ -359,7 +359,7 @@ private:
myError = SMESH_ComputeError::New(error,comment); myError = SMESH_ComputeError::New(error,comment);
return myError->IsOK(); return myError->IsOK();
} }
//vector< SMESH_subMesh* > mySubMeshesVec; // submesh by in-block id //std::vector< SMESH_subMesh* > mySubMeshesVec; // submesh by in-block id
}; };
// ============================================= // =============================================
@ -395,7 +395,7 @@ public:
* \param nodeColumns - columns of nodes generated from nodes of a mesh face * \param nodeColumns - columns of nodes generated from nodes of a mesh face
* \param helper - helper initialized by mesh and shape to add prisms to * \param helper - helper initialized by mesh and shape to add prisms to
*/ */
static void AddPrisms( vector<const TNodeColumn*> & nodeColumns, static void AddPrisms( std::vector<const TNodeColumn*> & nodeColumns,
SMESH_MesherHelper* helper); SMESH_MesherHelper* helper);
private: private:
@ -430,7 +430,7 @@ private:
StdMeshers_PrismAsBlock myBlock; StdMeshers_PrismAsBlock myBlock;
SMESH_MesherHelper* myHelper; SMESH_MesherHelper* myHelper;
vector<gp_XYZ> myShapeXYZ; // point on each sub-shape std::vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
// map of bottom nodes to the column of nodes above them // map of bottom nodes to the column of nodes above them
// (the column includes the bottom node) // (the column includes the bottom node)

4
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
View File

@ -87,8 +87,8 @@ class StdMeshers_ProjectionUtils
TopoDS_Vertex VV1[2], TopoDS_Vertex VV1[2],
const TopoDS_Face& face2, const TopoDS_Face& face2,
TopoDS_Vertex VV2[2], TopoDS_Vertex VV2[2],
list< TopoDS_Edge > & edges1, std::list< TopoDS_Edge > & edges1,
list< TopoDS_Edge > & edges2); std::list< TopoDS_Edge > & edges2);
/*! /*!
* \brief Insert vertex association defined by a hypothesis into a map * \brief Insert vertex association defined by a hypothesis into a map

2
src/StdMeshers/StdMeshers_Quadrangle_2D.hxx
View File

@ -47,7 +47,7 @@ enum TSideID { BOTTOM_SIDE=0, RIGHT_SIDE, TOP_SIDE, LEFT_SIDE, NB_SIDES };
typedef uvPtStruct UVPtStruct; typedef uvPtStruct UVPtStruct;
typedef struct faceQuadStruct typedef struct faceQuadStruct
{ {
vector< StdMeshers_FaceSide*> side; std::vector< StdMeshers_FaceSide*> side;
bool isEdgeOut[4]; // true, if an edge has more nodes, than the opposite bool isEdgeOut[4]; // true, if an edge has more nodes, than the opposite
UVPtStruct* uv_grid; UVPtStruct* uv_grid;
~faceQuadStruct(); ~faceQuadStruct();

6
src/StdMeshers/StdMeshers_RadialPrism_3D.hxx
View File

@ -54,8 +54,8 @@ public:
protected: protected:
typedef vector<const SMDS_MeshNode* > TNodeColumn; typedef std::vector<const SMDS_MeshNode* > TNodeColumn;
typedef map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap; typedef std::map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
TNodeColumn* makeNodeColumn( TNode2ColumnMap& n2ColMap, TNodeColumn* makeNodeColumn( TNode2ColumnMap& n2ColMap,
const SMDS_MeshNode* outNode, const SMDS_MeshNode* outNode,
@ -68,7 +68,7 @@ protected:
const StdMeshers_NumberOfLayers* myNbLayerHypo; const StdMeshers_NumberOfLayers* myNbLayerHypo;
const StdMeshers_LayerDistribution* myDistributionHypo; const StdMeshers_LayerDistribution* myDistributionHypo;
SMESH_MesherHelper* myHelper; SMESH_MesherHelper* myHelper;
vector< double > myLayerPositions; std::vector< double > myLayerPositions;
}; };
#endif #endif