ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-03-10 23:44:33 +05:00
Code Issues Packages Projects Releases Wiki Activity

after KERNEL 64bits update. Compile failed

Browse Source
This commit is contained in:
Viktor UZLOV 2021-01-28 18:21:20 +03:00
parent 964d47b2a0
commit 29df5478fc
12 changed files with 224 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/SMDS/SMDS_ElementFactory.cxx
View File

@ -281,11 +281,11 @@ void SMDS_ElementFactory::Clear()
*/ */
//================================================================================ //================================================================================
void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld ) void SMDS_ElementFactory::Compact( std::vector<smIdType>& theVtkIDsNewToOld )
{ {
int newNbCells = NbUsedElements(); smIdType newNbCells = NbUsedElements();
int maxCellID = GetMaxID(); smIdType maxCellID = GetMaxID();
int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize ); smIdType newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
theVtkIDsNewToOld.resize( newNbCells ); theVtkIDsNewToOld.resize( newNbCells );
@ -377,16 +377,16 @@ SMDS_NodeFactory::~SMDS_NodeFactory()
*/ */
//================================================================================ //================================================================================
void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew ) void SMDS_NodeFactory::Compact( std::vector<smIdType>& theVtkIDsOldToNew )
{ {
// IDs of VTK nodes always correspond to SMDS IDs but there can be "holes" // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes"
// in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew: // in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
// theVtkIDsOldToNew[ old VtkID ] = new VtkID // theVtkIDsOldToNew[ old VtkID ] = new VtkID
int oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints(); smIdType oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
int newNbNodes = NbUsedElements(); smIdType newNbNodes = NbUsedElements();
int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize ); smIdType newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
int maxNodeID = GetMaxID(); smIdType maxNodeID = GetMaxID();
theVtkIDsOldToNew.resize( oldNbNodes, -1 ); theVtkIDsOldToNew.resize( oldNbNodes, -1 );
@ -836,7 +836,7 @@ void SMDS_ElementChunk::Compact()
} }
else if ( it != mySubIDRanges.mySet.rbegin() ) else if ( it != mySubIDRanges.mySet.rbegin() )
{ {
int nbNodes = (it-1)->my1st; smIdType nbNodes = (it-1)->my1st;
myPositions.resize( nbNodes * 2 ); myPositions.resize( nbNodes * 2 );
std::vector<TParam> newPos( myPositions.begin(), myPositions.end() ); std::vector<TParam> newPos( myPositions.begin(), myPositions.end() );
myPositions.swap( newPos ); myPositions.swap( newPos );

4
src/SMDS/SMDS_ElementFactory.hxx
View File

@ -128,7 +128,7 @@ public:
//! Remove unused elements located not at the end of the last chunk. //! Remove unused elements located not at the end of the last chunk.
// Minimize allocated memory // Minimize allocated memory
virtual void Compact(std::vector<int>& idCellsOldToNew); virtual void Compact(std::vector<smIdType>& idCellsOldToNew);
//! Return true if Compact() will change IDs of elements //! Return true if Compact() will change IDs of elements
virtual bool CompactChangePointers(); virtual bool CompactChangePointers();
@ -170,7 +170,7 @@ public:
//! Remove unused nodes located not at the end of the last chunk. //! Remove unused nodes located not at the end of the last chunk.
// Minimize allocated memory // Minimize allocated memory
virtual void Compact(std::vector<int>& idNodesOldToNew); virtual void Compact(std::vector<smIdType>& idNodesOldToNew);
//! Return true if Compact() will change IDs of node //! Return true if Compact() will change IDs of node
virtual bool CompactChangePointers(); virtual bool CompactChangePointers();

4
src/SMDS/SMDS_ElementHolder.cxx
View File

@ -84,8 +84,8 @@ void SMDS_ElementHolder::beforeCompacting()
//purpose : restore pointers to elements //purpose : restore pointers to elements
//======================================================================= //=======================================================================
void SMDS_ElementHolder::restoreElements( const std::vector<int>& idNodesOldToNew, void SMDS_ElementHolder::restoreElements( const std::vector<smIdType>& idNodesOldToNew,
const std::vector<int>& idCellsOldToNew ) const std::vector<smIdType>& idCellsOldToNew )
{ {
tmpClear(); tmpClear();

6
src/SMDS/SMDS_ElementHolder.hxx
View File

@ -29,6 +29,8 @@
#include "SMDS_ElemIterator.hxx" #include "SMDS_ElemIterator.hxx"
#include <smIdType.hxx>
#include <vector> #include <vector>
#include <set> #include <set>
@ -80,8 +82,8 @@ class SMDS_EXPORT SMDS_ElementHolder
void beforeCompacting(); void beforeCompacting();
//! restore pointers to elements //! restore pointers to elements
void restoreElements( const std::vector<int>& idNodessOldToNew, void restoreElements( const std::vector<smIdType>& idNodessOldToNew,
const std::vector<int>& idCellsOldToNew ); const std::vector<smIdType>& idCellsOldToNew );
std::vector<const SMDS_MeshElement*> myExternalElems; //!< elements not contained in the mesh std::vector<const SMDS_MeshElement*> myExternalElems; //!< elements not contained in the mesh

2
src/SMDS/SMDS_Mesh.hxx
View File

@ -633,7 +633,7 @@ public:
} }
const SMDS_MeshNode *FindNode(smIdType idnode) const; const SMDS_MeshNode *FindNode(smIdType idnode) const;
const SMDS_MeshNode *FindNodeVtk(smIdType idnode) const; const SMDS_MeshNode *FindNodeVtk(int idnode) const;
const SMDS_MeshElement *FindElementVtk(int IDelem) const; const SMDS_MeshElement *FindElementVtk(int IDelem) const;
virtual const SMDS_MeshElement * FindElement(int IDelem) const; virtual const SMDS_MeshElement * FindElement(int IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n); static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);

4
src/SMDS/SMDS_MeshElement.cxx
View File

@ -105,7 +105,7 @@ int SMDS_MeshElement::GetNodeIndex( const SMDS_MeshNode* node ) const
*/ */
//================================================================================ //================================================================================
int SMDS_MeshElement::GetID() const smIdType SMDS_MeshElement::GetID() const
{ {
return myHolder ? myHolder->GetID( this ) : -1; return myHolder ? myHolder->GetID( this ) : -1;
} }
@ -127,7 +127,7 @@ void SMDS_MeshElement::setShapeID( const int shapeID ) const
*/ */
//================================================================================ //================================================================================
int SMDS_MeshElement::GetShapeID() const smIdType SMDS_MeshElement::GetShapeID() const
{ {
return myHolder->GetShapeID( this ); return myHolder->GetShapeID( this );
} }

5
src/SMDS/SMDS_MeshElement.hxx
View File

@ -38,6 +38,7 @@
#include <vtkType.h> #include <vtkType.h>
#include <vtkCellType.h> #include <vtkCellType.h>
#include <smIdType.hxx>
class SMDS_ElementChunk; class SMDS_ElementChunk;
class SMDS_Mesh; class SMDS_Mesh;
@ -127,10 +128,10 @@ public:
virtual int GetNodeIndex( const SMDS_MeshNode* node ) const; virtual int GetNodeIndex( const SMDS_MeshNode* node ) const;
virtual int GetID() const; virtual smIdType GetID() const;
virtual int GetVtkID() const; virtual int GetVtkID() const;
virtual int getshapeId() const { return GetShapeID(); } virtual int getshapeId() const { return GetShapeID(); }
virtual int GetShapeID() const; virtual smIdType GetShapeID() const;
// mark this element; to be used in algos // mark this element; to be used in algos
virtual void setIsMarked( bool is ) const; virtual void setIsMarked( bool is ) const;

4
src/SMDS/SMDS_MeshInfo.hxx
View File

@ -102,7 +102,7 @@ private:
smIdType myNbHexPrism; smIdType myNbHexPrism;
smIdType myNbPolyhedrons; smIdType myNbPolyhedrons;
std::vector<int*> myNb; // pointers to myNb... fields std::vector<smIdType*> myNb; // pointers to myNb... fields
std::vector<int> myShift; // shift to get an index in myNb by elem->NbNodes() std::vector<int> myShift; // shift to get an index in myNb by elem->NbNodes()
}; };
@ -407,7 +407,7 @@ SMDS_MeshInfo::NbElementsOfGeom(SMDSAbs_GeometryType geom) const
} }
inline void // setNb inline void // setNb
SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const int nb) SMDS_MeshInfo::setNb(const SMDSAbs_EntityType geomType, const smIdType nb)
{ {
switch (geomType) { switch (geomType) {
case SMDSEntity_Node: myNbNodes = nb; break; case SMDSEntity_Node: myNbNodes = nb; break;

10
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -175,8 +175,8 @@ void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh)
_mesh = mesh; _mesh = mesh;
} }
void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize, void SMDS_UnstructuredGrid::compactGrid(std::vector<smIdType>& idNodesOldToNew, smIdType newNodeSize,
std::vector<int>& idCellsNewToOld, int newCellSize) std::vector<smIdType>& idCellsNewToOld, smIdType newCellSize)
{ {
this->DeleteLinks(); this->DeleteLinks();
@ -336,7 +336,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
} }
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints, void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<int>& /*idNodesOldToNew*/, std::vector<smIdType>& /*idNodesOldToNew*/,
int& alreadyCopied, int& alreadyCopied,
int start, int start,
int end) int end)
@ -352,8 +352,8 @@ void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
} }
void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray * newTypes, void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray * newTypes,
const std::vector<int>& idCellsNewToOld, const std::vector<smIdType>& idCellsNewToOld,
const std::vector<int>& idNodesOldToNew, const std::vector<smIdType>& idNodesOldToNew,
vtkCellArray* newConnectivity, vtkCellArray* newConnectivity,
vtkIdTypeArray* newLocations, vtkIdTypeArray* newLocations,
std::vector<vtkIdType>& pointsCell) std::vector<vtkIdType>& pointsCell)

15
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -28,6 +28,7 @@
#include <vtkUnstructuredGrid.h> #include <vtkUnstructuredGrid.h>
#include <vtkCellLinks.h> #include <vtkCellLinks.h>
#include <smIdType.hxx>
#include <vector> #include <vector>
#include <set> #include <set>
@ -73,10 +74,10 @@ class SMDS_EXPORT SMDS_UnstructuredGrid: public vtkUnstructuredGrid
{ {
public: public:
void setSMDS_mesh(SMDS_Mesh *mesh); void setSMDS_mesh(SMDS_Mesh *mesh);
void compactGrid(std::vector<int>& idNodesOldToNew, void compactGrid(std::vector<smIdType>& idNodesOldToNew,
int newNodeSize, smIdType newNodeSize,
std::vector<int>& idCellsOldToNew, std::vector<smIdType>& idCellsOldToNew,
int newCellSize); smIdType newCellSize);
virtual vtkMTimeType GetMTime(); virtual vtkMTimeType GetMTime();
virtual vtkPoints *GetPoints(); virtual vtkPoints *GetPoints();
@ -115,10 +116,10 @@ public:
protected: protected:
SMDS_UnstructuredGrid(); SMDS_UnstructuredGrid();
~SMDS_UnstructuredGrid(); ~SMDS_UnstructuredGrid();
void copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied, int start, int end); void copyNodes(vtkPoints *newPoints, std::vector<smIdType>& idNodesOldToNew, int& alreadyCopied, int start, int end);
void copyBloc(vtkUnsignedCharArray *newTypes, void copyBloc(vtkUnsignedCharArray *newTypes,
const std::vector<int>& idCellsOldToNew, const std::vector<smIdType>& idCellsOldToNew,
const std::vector<int>& idNodesOldToNew, const std::vector<smIdType>& idNodesOldToNew,
vtkCellArray* newConnectivity, vtkCellArray* newConnectivity,
vtkIdTypeArray* newLocations, vtkIdTypeArray* newLocations,
std::vector<vtkIdType>& pointsCell); std::vector<vtkIdType>& pointsCell);

198
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -194,7 +194,7 @@ SMDS_MeshNode* SMESHDS_Mesh::AddNode(double x, double y, double z){
return node; return node;
} }
SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, int ID){ SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, smIdType ID){
SMDS_MeshNode* node = SMDS_Mesh::AddNodeWithID(x,y,z,ID); SMDS_MeshNode* node = SMDS_Mesh::AddNodeWithID(x,y,z,ID);
if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z); if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
return node; return node;
@ -218,7 +218,7 @@ void SMESHDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z
bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem, bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
const SMDS_MeshNode * nodes[], const SMDS_MeshNode * nodes[],
const int nbnodes) const smIdType nbnodes)
{ {
if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes )) if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
return false; return false;
@ -286,7 +286,7 @@ void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const int /*startID*/, cons
//function : Add0DElement //function : Add0DElement
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID) SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(smIdType nodeID, smIdType ID)
{ {
SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID); SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID);
if (anElem) myScript->Add0DElement(ID, nodeID); if (anElem) myScript->Add0DElement(ID, nodeID);
@ -294,7 +294,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
} }
SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID
(const SMDS_MeshNode * node, int ID) (const SMDS_MeshNode * node, smIdType ID)
{ {
return Add0DElementWithID(node->GetID(), ID); return Add0DElementWithID(node->GetID(), ID);
} }
@ -311,7 +311,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID) SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(smIdType node, double diameter, smIdType ID)
{ {
SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID); SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
if (anElem) myScript->AddBall(anElem->GetID(), node, diameter); if (anElem) myScript->AddBall(anElem->GetID(), node, diameter);
@ -320,7 +320,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node, SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node,
double diameter, double diameter,
int ID) smIdType ID)
{ {
SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID); SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter); if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
@ -340,7 +340,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBall (const SMDS_MeshNode * node,
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID) SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID)
{ {
SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID); SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID);
if(anElem) myScript->AddEdge(ID,n1,n2); if(anElem) myScript->AddEdge(ID,n1,n2);
@ -349,7 +349,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
int ID) smIdType ID)
{ {
return AddEdgeWithID(n1->GetID(), return AddEdgeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -370,7 +370,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode * n1,
//function :AddFace //function :AddFace
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID) SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3); if(anElem) myScript->AddFace(ID,n1,n2,n3);
@ -380,7 +380,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
int ID) smIdType ID)
{ {
return AddFaceWithID(n1->GetID(), return AddFaceWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -404,7 +404,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
//function :AddFace //function :AddFace
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int ID) SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID);
if(anElem) myScript->AddFace(ID, n1, n2, n3, n4); if(anElem) myScript->AddFace(ID, n1, n2, n3, n4);
@ -415,7 +415,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
int ID) smIdType ID)
{ {
return AddFaceWithID(n1->GetID(), return AddFaceWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -442,7 +442,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function :AddVolume //function :AddVolume
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int ID) SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID); SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4); if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4);
@ -453,7 +453,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), return AddVolumeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -480,7 +480,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume //function :AddVolume
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID) SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID); SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5); if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5);
@ -492,7 +492,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5, const SMDS_MeshNode * n5,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), return AddVolumeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -522,7 +522,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume //function :AddVolume
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID) SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID)
{ {
SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID); SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6); if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6);
@ -535,7 +535,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5, const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6, const SMDS_MeshNode * n6,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), return AddVolumeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -568,7 +568,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume //function :AddVolume
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID) SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID)
{ {
SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID); SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8); if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8);
@ -583,7 +583,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n6, const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7, const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8, const SMDS_MeshNode * n8,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), return AddVolumeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -623,10 +623,10 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function :AddVolume //function :AddVolume
//purpose : add hexagonal prism //purpose : add hexagonal prism
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n5, int n6, int n7, int n8, smIdType n5, smIdType n6, smIdType n7, smIdType n8,
int n9, int n10, int n11, int n12, smIdType n9, smIdType n10, smIdType n11, smIdType n12,
int ID) smIdType ID)
{ {
SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, ID); SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, ID);
if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12); if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
@ -645,7 +645,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n10, const SMDS_MeshNode * n10,
const SMDS_MeshNode * n11, const SMDS_MeshNode * n11,
const SMDS_MeshNode * n12, const SMDS_MeshNode * n12,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), return AddVolumeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -697,8 +697,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddPolygonalFace //function : AddPolygonalFace
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids, SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
const int ID) const smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
if (anElem) { if (anElem) {
@ -709,12 +709,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nod
SMDS_MeshFace* SMDS_MeshFace*
SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes, SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const int ID) const smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
if (anElem) { if (anElem) {
int i, len = nodes.size(); smIdType i, len = nodes.size();
std::vector<int> nodes_ids (len); std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID(); nodes_ids[i] = nodes[i]->GetID();
} }
@ -728,8 +728,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes); SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
if (anElem) { if (anElem) {
int i, len = nodes.size(); smIdType i, len = nodes.size();
std::vector<int> nodes_ids (len); std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID(); nodes_ids[i] = nodes[i]->GetID();
} }
@ -743,8 +743,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
//function : AddQuadPolygonalFace //function : AddQuadPolygonalFace
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>& nodes_ids, SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
const int ID) const smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes_ids, ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes_ids, ID);
if (anElem) { if (anElem) {
@ -755,12 +755,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>&
SMDS_MeshFace* SMDS_MeshFace*
SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes, SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const int ID) const smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
if (anElem) { if (anElem) {
int i, len = nodes.size(); smIdType i, len = nodes.size();
std::vector<int> nodes_ids (len); std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID(); nodes_ids[i] = nodes[i]->GetID();
} }
@ -774,8 +774,8 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFace(nodes); SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFace(nodes);
if (anElem) { if (anElem) {
int i, len = nodes.size(); smIdType i, len = nodes.size();
std::vector<int> nodes_ids (len); std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID(); nodes_ids[i] = nodes[i]->GetID();
} }
@ -789,9 +789,9 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
//function : AddPolyhedralVolume //function : AddPolyhedralVolume
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids, SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities, const std::vector<smIdType>& quantities,
const int ID) const smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID); SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
if (anElem) { if (anElem) {
@ -803,12 +803,12 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*>& nodes, (const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities, const std::vector<int>& quantities,
const int ID) const smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID); SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
if (anElem) { if (anElem) {
int i, len = nodes.size(); smIdType i, len = nodes.size();
std::vector<int> nodes_ids (len); std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID(); nodes_ids[i] = nodes[i]->GetID();
} }
@ -823,8 +823,8 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities); SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
if (anElem) { if (anElem) {
int i, len = nodes.size(); smIdType i, len = nodes.size();
std::vector<int> nodes_ids (len); std::vector<smIdType> nodes_ids (len);
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
nodes_ids[i] = nodes[i]->GetID(); nodes_ids[i] = nodes[i]->GetID();
} }
@ -1489,7 +1489,7 @@ SMESHDS_Mesh::~SMESHDS_Mesh()
//function : AddEdgeWithID //function : AddEdgeWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID) SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID)
{ {
SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID); SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
if(anElem) myScript->AddEdge(ID,n1,n2,n12); if(anElem) myScript->AddEdge(ID,n1,n2,n12);
@ -1519,7 +1519,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12, const SMDS_MeshNode * n12,
int ID) smIdType ID)
{ {
return AddEdgeWithID(n1->GetID(), return AddEdgeWithID(n1->GetID(),
n2->GetID(), n2->GetID(),
@ -1550,8 +1550,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID //function : AddFaceWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
int n12,int n23,int n31, int ID) smIdType n12,smIdType n23,smIdType n31, smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31); if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
@ -1568,7 +1568,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n12, const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23, const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31, const SMDS_MeshNode * n31,
int ID) smIdType ID)
{ {
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(), n12->GetID(), n23->GetID(), n31->GetID(),
@ -1599,8 +1599,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID //function : AddFaceWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
int n12,int n23,int n31, int nCenter, int ID) smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter); if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
@ -1618,7 +1618,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n23, const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31, const SMDS_MeshNode * n31,
const SMDS_MeshNode * nCenter, const SMDS_MeshNode * nCenter,
int ID) smIdType ID)
{ {
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(), n12->GetID(), n23->GetID(), n31->GetID(),
@ -1650,8 +1650,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID //function : AddFaceWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n12,int n23,int n34,int n41, int ID) smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41); if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
@ -1670,7 +1670,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n23, const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34, const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41, const SMDS_MeshNode * n41,
int ID) smIdType ID)
{ {
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(), return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(), n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@ -1704,9 +1704,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
//function : AddFaceWithID //function : AddFaceWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int nCenter, int ID) smIdType nCenter, smIdType ID)
{ {
SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID); SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter); if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
@ -1726,7 +1726,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n34, const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41, const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter, const SMDS_MeshNode * nCenter,
int ID) smIdType ID)
{ {
return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(), return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(), n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@ -1761,9 +1761,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID //function : AddVolumeWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n12,int n23,int n31, smIdType n12,smIdType n23,smIdType n31,
int n14,int n24,int n34, int ID) smIdType n14,smIdType n24,smIdType n34, smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23, SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
n31,n14,n24,n34,ID); n31,n14,n24,n34,ID);
@ -1785,7 +1785,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14, const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24, const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34, const SMDS_MeshNode * n34,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(), return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n12->GetID(), n23->GetID(), n31->GetID(), n12->GetID(), n23->GetID(), n31->GetID(),
@ -1825,9 +1825,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID //function : AddVolumeWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int n15,int n25,int n35,int n45, int ID) smIdType n15,smIdType n25,smIdType n35,smIdType n45, smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5, SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
n12,n23,n34,n41, n12,n23,n34,n41,
@ -1854,7 +1854,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n25, const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35, const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45, const SMDS_MeshNode * n45,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(), n4->GetID(), n5->GetID(),
@ -1899,11 +1899,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID //function : AddVolumeWithID
//purpose : 2nd order pentahedron (prism) with 15 nodes //purpose : 2nd order pentahedron (prism) with 15 nodes
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
int n4, int n5, int n6, smIdType n4, smIdType n5, smIdType n6,
int n12,int n23,int n31, smIdType n12,smIdType n23,smIdType n31,
int n45,int n56,int n64, smIdType n45,smIdType n56,smIdType n64,
int n14,int n25,int n36, int ID) smIdType n14,smIdType n25,smIdType n36, smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6, SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
n12,n23,n31, n12,n23,n31,
@ -1933,7 +1933,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n14, const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25, const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36, const SMDS_MeshNode * n36,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(), n6->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
@ -1982,13 +1982,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID //function : AddVolumeWithID
//purpose : 2nd order pentahedron (prism) with 18 nodes //purpose : 2nd order pentahedron (prism) with 18 nodes
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
int n4, int n5, int n6, smIdType n4, smIdType n5, smIdType n6,
int n12,int n23,int n31, smIdType n12,smIdType n23,smIdType n31,
int n45,int n56,int n64, smIdType n45,smIdType n56,smIdType n64,
int n14,int n25,int n36, smIdType n14,smIdType n25,smIdType n36,
int n1245, int n2356, int n1346, smIdType n1245, smIdType n2356, smIdType n1346,
int ID) smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6, SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
n12,n23,n31, n12,n23,n31,
@ -2022,7 +2022,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n1245, const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356, const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346, const SMDS_MeshNode * n1346,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
n4->GetID(), n5->GetID(), n6->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
@ -2076,11 +2076,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
//function : AddVolumeWithID //function : AddVolumeWithID
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n5, int n6, int n7, int n8, smIdType n5, smIdType n6, smIdType n7, smIdType n8,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int n56,int n67,int n78,int n85, smIdType n56,smIdType n67,smIdType n78,smIdType n85,
int n15,int n26,int n37,int n48, int ID) smIdType n15,smIdType n26,smIdType n37,smIdType n48, smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8, SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
n12,n23,n34,n41, n12,n23,n34,n41,
@ -2115,7 +2115,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n26, const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37, const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48, const SMDS_MeshNode * n48,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(), return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(), n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
@ -2175,14 +2175,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
return anElem; return anElem;
} }
SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n5, int n6, int n7, int n8, smIdType n5, smIdType n6, smIdType n7, smIdType n8,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int n56,int n67,int n78,int n85, smIdType n56,smIdType n67,smIdType n78,smIdType n85,
int n15,int n26,int n37,int n48, smIdType n15,smIdType n26,smIdType n37,smIdType n48,
int n1234,int n1256,int n2367,int n3478, smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
int n1458,int n5678,int nCenter, smIdType n1458,smIdType n5678,smIdType nCenter,
int ID) smIdType ID)
{ {
SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8, SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
n12,n23,n34,n41, n12,n23,n34,n41,
@ -2225,7 +2225,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n1458, const SMDS_MeshNode * n1458,
const SMDS_MeshNode * n5678, const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter, const SMDS_MeshNode * nCenter,
int ID) smIdType ID)
{ {
return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(), return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(), n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),

172
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -77,64 +77,64 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H); bool AddHypothesis(const TopoDS_Shape & SS, const SMESHDS_Hypothesis * H);
bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H); bool RemoveHypothesis(const TopoDS_Shape & S, const SMESHDS_Hypothesis * H);
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID); virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, smIdType ID);
virtual SMDS_MeshNode* AddNode(double x, double y, double z); virtual SMDS_MeshNode* AddNode(double x, double y, double z);
virtual SMDS_Mesh0DElement* Add0DElementWithID(int nodeID, int ID); virtual SMDS_Mesh0DElement* Add0DElementWithID(smIdType nodeID, smIdType ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, int ID); virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * node, smIdType ID);
virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * node); virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * node);
virtual SMDS_BallElement* AddBallWithID(int n, double diameter, int ID); virtual SMDS_BallElement* AddBallWithID(smIdType n, double diameter, smIdType ID);
virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID); virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, smIdType ID);
virtual SMDS_BallElement* AddBall (const SMDS_MeshNode * n, double diameter); virtual SMDS_BallElement* AddBall (const SMDS_MeshNode * n, double diameter);
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID); virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
int ID); smIdType ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1, virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2); const SMDS_MeshNode * n2);
// 2d order edge with 3 nodes: n12 - node between n1 and n2 // 2d order edge with 3 nodes: n12 - node between n1 and n2
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID); virtual SMDS_MeshEdge* AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12, const SMDS_MeshNode * n12,
int ID); smIdType ID);
virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1, virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n12); const SMDS_MeshNode * n12);
// tria 3 // tria 3
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID); virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
int ID); smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3); const SMDS_MeshNode * n3);
// quad 4 // quad 4
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID); virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
int ID); smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4); const SMDS_MeshNode * n4);
// 2d order triangle of 6 nodes // 2d order triangle of 6 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
int n12,int n23,int n31, int ID); smIdType n12,smIdType n23,smIdType n31, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n12, const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23, const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31, const SMDS_MeshNode * n31,
int ID); smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -143,8 +143,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n31); const SMDS_MeshNode * n31);
// biquadratic triangle of 7 nodes // biquadratic triangle of 7 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
int n12,int n23,int n31, int nCenter, int ID); smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -152,7 +152,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n23, const SMDS_MeshNode * n23,
const SMDS_MeshNode * n31, const SMDS_MeshNode * n31,
const SMDS_MeshNode * nCenter, const SMDS_MeshNode * nCenter,
int ID); smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -162,8 +162,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * nCenter); const SMDS_MeshNode * nCenter);
// 2d order quadrangle // 2d order quadrangle
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n12,int n23,int n34,int n41, int ID); smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -172,7 +172,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n23, const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34, const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41, const SMDS_MeshNode * n41,
int ID); smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -183,8 +183,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n41); const SMDS_MeshNode * n41);
// biquadratic quadrangle of 9 nodes // biquadratic quadrangle of 9 nodes
virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, virtual SMDS_MeshFace* AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n12,int n23,int n34,int n41, int nCenter, int ID); smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType nCenter, smIdType ID);
virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -194,7 +194,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n34, const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41, const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter, const SMDS_MeshNode * nCenter,
int ID); smIdType ID);
virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1, virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -205,38 +205,38 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n41, const SMDS_MeshNode * n41,
const SMDS_MeshNode * nCenter); const SMDS_MeshNode * nCenter);
// tetra 4 // tetra 4
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID); virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4); const SMDS_MeshNode * n4);
// pyra 5 // pyra 5
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID); virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5, const SMDS_MeshNode * n5,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5); const SMDS_MeshNode * n5);
// penta 6 // penta 6
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID); virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4, const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5, const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6, const SMDS_MeshNode * n6,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -244,7 +244,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n5, const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6); const SMDS_MeshNode * n6);
// hexa 8 // hexa 8
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID); virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -253,7 +253,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n6, const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7, const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8, const SMDS_MeshNode * n8,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -263,8 +263,8 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n7, const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8); const SMDS_MeshNode * n8);
// hexagonal prism of 12 nodes // hexagonal prism of 12 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6,
int n7, int n8, int n9, int n10, int n11, int n12, int ID); smIdType n7, smIdType n8, smIdType n9, smIdType n10, smIdType n11, smIdType n12, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -277,7 +277,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n10, const SMDS_MeshNode * n10,
const SMDS_MeshNode * n11, const SMDS_MeshNode * n11,
const SMDS_MeshNode * n12, const SMDS_MeshNode * n12,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -292,9 +292,9 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n12); const SMDS_MeshNode * n12);
// 2d order tetrahedron of 10 nodes // 2d order tetrahedron of 10 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n12,int n23,int n31, smIdType n12,smIdType n23,smIdType n31,
int n14,int n24,int n34, int ID); smIdType n14,smIdType n24,smIdType n34, smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -305,7 +305,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n14, const SMDS_MeshNode * n14,
const SMDS_MeshNode * n24, const SMDS_MeshNode * n24,
const SMDS_MeshNode * n34, const SMDS_MeshNode * n34,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -318,10 +318,10 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n34); const SMDS_MeshNode * n34);
// 2d order pyramid of 13 nodes // 2d order pyramid of 13 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int n15,int n25,int n35,int n45, smIdType n15,smIdType n25,smIdType n35,smIdType n45,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -335,7 +335,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n25, const SMDS_MeshNode * n25,
const SMDS_MeshNode * n35, const SMDS_MeshNode * n35,
const SMDS_MeshNode * n45, const SMDS_MeshNode * n45,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -351,12 +351,12 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n45); const SMDS_MeshNode * n45);
// 2d order Pentahedron with 15 nodes // 2d order Pentahedron with 15 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
int n4, int n5, int n6, smIdType n4, smIdType n5, smIdType n6,
int n12,int n23,int n31, smIdType n12,smIdType n23,smIdType n31,
int n45,int n56,int n64, smIdType n45,smIdType n56,smIdType n64,
int n14,int n25,int n36, smIdType n14,smIdType n25,smIdType n36,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -372,7 +372,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n14, const SMDS_MeshNode * n14,
const SMDS_MeshNode * n25, const SMDS_MeshNode * n25,
const SMDS_MeshNode * n36, const SMDS_MeshNode * n36,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -390,13 +390,13 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n36); const SMDS_MeshNode * n36);
// 2d order Pentahedron with 18 nodes // 2d order Pentahedron with 18 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
int n4, int n5, int n6, smIdType n4, smIdType n5, smIdType n6,
int n12,int n23,int n31, smIdType n12,smIdType n23,smIdType n31,
int n45,int n56,int n64, smIdType n45,smIdType n56,smIdType n64,
int n14,int n25,int n36, smIdType n14,smIdType n25,smIdType n36,
int n1245, int n2356, int n1346, smIdType n1245, smIdType n2356, smIdType n1346,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -415,7 +415,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n1245, const SMDS_MeshNode * n1245,
const SMDS_MeshNode * n2356, const SMDS_MeshNode * n2356,
const SMDS_MeshNode * n1346, const SMDS_MeshNode * n1346,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -436,12 +436,12 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n1346); const SMDS_MeshNode * n1346);
// 2d order Hexahedrons with 20 nodes // 2d order Hexahedrons with 20 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n5, int n6, int n7, int n8, smIdType n5, smIdType n6, smIdType n7, smIdType n8,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int n56,int n67,int n78,int n85, smIdType n56,smIdType n67,smIdType n78,smIdType n85,
int n15,int n26,int n37,int n48, smIdType n15,smIdType n26,smIdType n37,smIdType n48,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -462,7 +462,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n26, const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37, const SMDS_MeshNode * n37,
const SMDS_MeshNode * n48, const SMDS_MeshNode * n48,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -485,14 +485,14 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n48); const SMDS_MeshNode * n48);
// 2d order Hexahedrons with 27 nodes // 2d order Hexahedrons with 27 nodes
virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, virtual SMDS_MeshVolume* AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
int n5, int n6, int n7, int n8, smIdType n5, smIdType n6, smIdType n7, smIdType n8,
int n12,int n23,int n34,int n41, smIdType n12,smIdType n23,smIdType n34,smIdType n41,
int n56,int n67,int n78,int n85, smIdType n56,smIdType n67,smIdType n78,smIdType n85,
int n15,int n26,int n37,int n48, smIdType n15,smIdType n26,smIdType n37,smIdType n48,
int n1234,int n1256,int n2367,int n3478, smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
int n1458,int n5678,int nCenter, smIdType n1458,smIdType n5678,smIdType nCenter,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -520,7 +520,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n1458, const SMDS_MeshNode * n1458,
const SMDS_MeshNode * n5678, const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter, const SMDS_MeshNode * nCenter,
int ID); smIdType ID);
virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1, virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2, const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3, const SMDS_MeshNode * n3,
@ -549,31 +549,31 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
const SMDS_MeshNode * n5678, const SMDS_MeshNode * n5678,
const SMDS_MeshNode * nCenter); const SMDS_MeshNode * nCenter);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<int>& nodes_ids, virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
const int ID); const smIdType ID);
virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes, virtual SMDS_MeshFace* AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
const int ID); const smIdType ID);
virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes); virtual SMDS_MeshFace* AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<int> & nodes_ids, virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<smIdType> & nodes_ids,
const int ID); const smIdType ID);
virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes, virtual SMDS_MeshFace* AddQuadPolygonalFaceWithID(const std::vector<const SMDS_MeshNode*> & nodes,
const int ID); const smIdType ID);
virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes); virtual SMDS_MeshFace* AddQuadPolygonalFace(const std::vector<const SMDS_MeshNode*> & nodes);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<int>& nodes_ids, (const std::vector<smIdType>& nodes_ids,
const std::vector<int>& quantities, const std::vector<int>& quantities,
const int ID); const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID virtual SMDS_MeshVolume* AddPolyhedralVolumeWithID
(const std::vector<const SMDS_MeshNode*>& nodes, (const std::vector<const SMDS_MeshNode*>& nodes,
const std::vector<int>& quantities, const std::vector<int>& quantities,
const int ID); const smIdType ID);
virtual SMDS_MeshVolume* AddPolyhedralVolume virtual SMDS_MeshVolume* AddPolyhedralVolume
(const std::vector<const SMDS_MeshNode*>& nodes, (const std::vector<const SMDS_MeshNode*>& nodes,
@ -594,7 +594,7 @@ class SMESHDS_EXPORT SMESHDS_Mesh : public SMDS_Mesh
bool ChangeElementNodes(const SMDS_MeshElement * elem, bool ChangeElementNodes(const SMDS_MeshElement * elem,
const SMDS_MeshNode * nodes[], const SMDS_MeshNode * nodes[],
const int nbnodes); const smIdType nbnodes);
bool ChangePolygonNodes(const SMDS_MeshElement * elem, bool ChangePolygonNodes(const SMDS_MeshElement * elem,
std::vector<const SMDS_MeshNode*> nodes); std::vector<const SMDS_MeshNode*> nodes);
bool ChangePolyhedronNodes(const SMDS_MeshElement * elem, bool ChangePolyhedronNodes(const SMDS_MeshElement * elem,