#include <Standard_ErrorHandler.hxx>
#endif
+using namespace std;
+
Function::Function( const int conv )
: myConv( conv )
{
* \brief Wrap several edges. Edges must be properly ordered and oriented.
*/
StdMeshers_FaceSide(const TopoDS_Face& theFace,
- list<TopoDS_Edge>& theEdges,
+ std::list<TopoDS_Edge>& theEdges,
SMESH_Mesh* theMesh,
const bool theIsForward,
const bool theIgnoreMediumNodes);
*
* 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
* \param isXConst - true if normalized parameter X is constant
* \param constValue - constant parameter value
*/
- const vector<UVPtStruct>& SimulateUVPtStruct(int nbSeg,
+ const std::vector<UVPtStruct>& SimulateUVPtStruct(int nbSeg,
bool isXConst = 0,
double constValue = 0) const;
/*!
protected:
- vector<uvPtStruct> myPoints, myFalsePoints;
- vector<TopoDS_Edge> myEdge;
- vector<Handle(Geom2d_Curve)> myC2d;
- vector<double> myFirst, myLast;
- vector<double> myNormPar;
- double myLength;
- int myNbPonits, myNbSegments;
- SMESH_Mesh* myMesh;
- bool myMissingVertexNodes, myIgnoreMediumNodes;
+ std::vector<uvPtStruct> myPoints, myFalsePoints;
+ std::vector<TopoDS_Edge> myEdge;
+ std::vector<Handle(Geom2d_Curve)> myC2d;
+ std::vector<double> myFirst, myLast;
+ std::vector<double> myNormPar;
+ double myLength;
+ int myNbPonits, myNbSegments;
+ SMESH_Mesh* myMesh;
+ bool myMissingVertexNodes, myIgnoreMediumNodes;
};
int GetFaceIndex(SMESH_Mesh& aMesh,
const TopoDS_Shape& aShape,
- const vector<SMESH_subMesh*>& meshFaces,
+ const std::vector<SMESH_subMesh*>& meshFaces,
const TopoDS_Vertex& V0,
const TopoDS_Vertex& V1,
const TopoDS_Vertex& V2,
TopTools_IndexedMapOfOrientedShape myShapeIDMap;
SMESH_Block myTBlock;
TopoDS_Shape myEmptyShape;
- vector<int> myIsEdgeForward;
+ std::vector<int> myIsEdgeForward;
//
int myErrorStatus;
};
double SetHorizEdgeXYZ(const gp_XYZ& aBNXYZ,
const int aFaceID,
- vector<const SMDS_MeshNode*>*& aCol1,
- vector<const SMDS_MeshNode*>*& aCol2);
+ std::vector<const SMDS_MeshNode*>*& aCol1,
+ std::vector<const SMDS_MeshNode*>*& aCol2);
void ShapeSupportID(const bool theIsUpperLayer,
const SMESH_Block::TShapeID theBNSSID,
void * myMesh;
SMESH_ComputeErrorPtr myErrorStatus;
//
- vector <StdMeshers_TNode> myTNodes;
+ std::vector <StdMeshers_TNode> myTNodes;
int myISize;
int myJSize;
double myTol3D; // Tolerance value
std::map < int, int > myConnectingMap;
//
- vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
- vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
+ std::vector<StdMeshers_IJNodeMap> myWallNodesMaps; // nodes on a face
+ std::vector<gp_XYZ> myShapeXYZ; // point on each sub-shape
bool myCreateQuadratic;
SMESH_MesherHelper* myTool; // tool building quadratic elements
BRepAdaptor_Surface mySurface;
TopoDS_Edge myBaseEdge;
// 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;
- vector< TSideFace* > myComponents;
+ std::vector< TSideFace* > myComponents;
SMESH_MesherHelper * myHelper;
public:
TSideFace( SMESH_MesherHelper* helper,
const double first = 0.0,
const double last = 1.0);
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();
bool IsComplex() const
// container of 4 side faces
TSideFace* mySide;
// node columns for each base edge
- vector< TParam2ColumnMap > myParam2ColumnMaps;
+ std::vector< TParam2ColumnMap > myParam2ColumnMaps;
// 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;
/*!
myError = SMESH_ComputeError::New(error,comment);
return myError->IsOK();
}
- //vector< SMESH_subMesh* > mySubMeshesVec; // submesh by in-block id
+ //std::vector< SMESH_subMesh* > mySubMeshesVec; // submesh by in-block id
};
// =============================================
* \param nodeColumns - columns of nodes generated from nodes of a mesh face
* \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);
private:
StdMeshers_PrismAsBlock myBlock;
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
// (the column includes the bottom node)
TopoDS_Vertex VV1[2],
const TopoDS_Face& face2,
TopoDS_Vertex VV2[2],
- list< TopoDS_Edge > & edges1,
- list< TopoDS_Edge > & edges2);
+ std::list< TopoDS_Edge > & edges1,
+ std::list< TopoDS_Edge > & edges2);
/*!
* \brief Insert vertex association defined by a hypothesis into a map
typedef uvPtStruct UVPtStruct;
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
UVPtStruct* uv_grid;
~faceQuadStruct();
protected:
- typedef vector<const SMDS_MeshNode* > TNodeColumn;
- typedef map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
+ typedef std::vector<const SMDS_MeshNode* > TNodeColumn;
+ typedef std::map< const SMDS_MeshNode*, TNodeColumn > TNode2ColumnMap;
TNodeColumn* makeNodeColumn( TNode2ColumnMap& n2ColMap,
const SMDS_MeshNode* outNode,
const StdMeshers_NumberOfLayers* myNbLayerHypo;
const StdMeshers_LayerDistribution* myDistributionHypo;
SMESH_MesherHelper* myHelper;
- vector< double > myLayerPositions;
+ std::vector< double > myLayerPositions;
};
#endif
