X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=07385dc9062eae6641fe131e6a71ea4abaa154fe;hb=8384c80a93e2b6eb8f8ca0b5cce18910594e0cc5;hp=a67282810e6ab1fc3e857c426e6457aa56e37d9d;hpb=484fe83a97f643207334576fbe08d4a90d67fd37;p=modules%2Fsmesh.git diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx index a67282810..07385dc90 100644 --- a/src/SMDS/SMDS_Mesh.cxx +++ b/src/SMDS/SMDS_Mesh.cxx @@ -24,6 +24,8 @@ #include "SMDS_VolumeOfNodes.hxx" #include "SMDS_VolumeOfFaces.hxx" #include "SMDS_FaceOfNodes.hxx" +#include "SMDS_Tria3OfNodes.hxx" +#include "SMDS_HexahedronOfNodes.hxx" #include "SMDS_FaceOfEdges.hxx" /////////////////////////////////////////////////////////////////////////////// @@ -38,6 +40,9 @@ SMDS_Mesh::SMDS_Mesh() } /////////////////////////////////////////////////////////////////////////////// +/// Create a new child mesh +/// Note that the tree structure of SMDS_Mesh seems to be unused in this version +/// (2003-09-08) of SMESH /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent) :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory), @@ -60,6 +65,7 @@ SMDS_Mesh *SMDS_Mesh::AddSubMesh() /////////////////////////////////////////////////////////////////////////////// ///create a MeshNode and add it to the current Mesh +///An ID is automatically assigned to the node. ///@return : The created node /////////////////////////////////////////////////////////////////////////////// @@ -90,30 +96,46 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) } /////////////////////////////////////////////////////////////////////////////// -///create a MeshEdge and add it to the current Mesh -///@return : The created MeshEdge +/// create a MeshEdge and add it to the current Mesh +/// @return : The created MeshEdge /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshEdge* SMDS_Mesh::AddEdge(int idnode1, int idnode2) +SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) { - return AddEdgeWithID(idnode1, idnode2, myElementIDFactory->GetFreeID()); + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + if((node1==NULL)||(node2==NULL)) return NULL; + return AddEdgeWithID(node1, node2, ID); } /////////////////////////////////////////////////////////////////////////////// -///Create a new edge and at it to the mesh -///@param idnode1 ID of the first node -///@param idnode2 ID of the second node -///@param ID ID of the edge to create -///@return The created edge or NULL if an edge with this ID already exists or -///if input nodes are not found. +/// create a MeshEdge and add it to the current Mesh +/// @return : The created MeshEdge /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) +SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1, + const SMDS_MeshNode * node2) { - SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - if((node1==NULL)||(node2==NULL)) return NULL; - SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1, node2); + return AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Create a new edge and at it to the mesh +/// @param idnode1 ID of the first node +/// @param idnode2 ID of the second node +/// @param ID ID of the edge to create +/// @return The created edge or NULL if an edge with this ID already exists or +/// if input nodes are not found. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, int ID) +{ + SMDS_MeshNode *node1,*node2; + node1=const_cast(n1); + node2=const_cast(n2); + + SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1,node2); if(myElementIDFactory->BindID(ID, edge)) { node1->AddInverseElement(edge); @@ -129,17 +151,19 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) } /////////////////////////////////////////////////////////////////////////////// -/// Add a triangle defined by its nodes IDs +/// Add a triangle defined by its nodes. An ID is automatically affected to the +/// Created face /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddFace(int idnode1, int idnode2, int idnode3) +SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3) { - return AddFaceWithID(idnode1,idnode2,idnode3, - myElementIDFactory->GetFreeID()); + return AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// -/// Add a quandrangle defined by its nodes IDs +/// Add a quadrangle defined by its nodes IDs /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, int ID) @@ -147,9 +171,24 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, i SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL; - SMDS_MeshFace * face=createTriangle(node1,node2,node3); + return AddFaceWithID(node1, node2, node3, ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadrangle defined by its nodes +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID( + const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3; + node1=const_cast(n1), + node2=const_cast(n2), + node3=const_cast(n3); + SMDS_MeshFace * face=createTriangle(node1, node2, node3); if(myElementIDFactory->BindID(ID, face)) { @@ -165,41 +204,56 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, i } } -//======================================================================= -//function : AddFace -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Add a triangle defined by its nodes. An ID is automatically affected to the +/// created face +/////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddFace(int idnode1, - int idnode2, int idnode3, int idnode4) +SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4) { - int ID=myElementIDFactory->GetFreeID(); - SMDS_MeshFace* f= AddFaceWithID(idnode1, idnode2, idnode3, idnode4, ID); - if(f==NULL) myElementIDFactory->ReleaseID(ID); + return AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID()); } -//======================================================================= -//function : AddFace -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadrangle defined by its nodes IDs +/////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, - int idnode2, int idnode3, int idnode4, int ID) +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, + int idnode4, int ID) { - SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + SMDS_MeshNode *node1, *node2, *node3, *node4; + node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL; + return AddFaceWithID(node1, node2, node3, node4, ID); +} - if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL; - SMDS_MeshFace * face=createQuadrangle(node1,node2,node3,node4); +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadrangle defined by its nodes +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4; + node1=const_cast(n1), + node2=const_cast(n2), + node3=const_cast(n3); + node4=const_cast(n4); + SMDS_MeshFace * face=createQuadrangle(node1, node2, node3, node4); if(myElementIDFactory->BindID(ID, face)) { node1->AddInverseElement(face); node2->AddInverseElement(face); node3->AddInverseElement(face); - node4->AddInverseElement(face); + node4->AddInverseElement(face); return face; } else @@ -209,23 +263,24 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, } } -//======================================================================= -//function : AddVolume -//purpose : Tetrahedra -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +///Create a new tetrahedron and add it to the mesh. +///@return The created tetrahedron +/////////////////////////////////////////////////////////////////////////////// -SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, - int idnode4) +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4) { int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v= - AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, ID); + SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } - /////////////////////////////////////////////////////////////////////////////// ///Create a new tetrahedron and add it to the mesh. +///@param ID The ID of the new volume ///@return The created tetrahedron or NULL if an edge with this ID already exists ///or if input nodes are not found. /////////////////////////////////////////////////////////////////////////////// @@ -233,13 +288,32 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3, int idnode4, int ID) { - SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); - + SMDS_MeshNode *node1, *node2, *node3, *node4; + node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)) return NULL; + return AddVolumeWithID(node1, node2, node3, node4, ID); +} +/////////////////////////////////////////////////////////////////////////////// +///Create a new tetrahedron and add it to the mesh. +///@param ID The ID of the new volume +///@return The created tetrahedron +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID( + const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4; + node1=const_cast(n1), + node2=const_cast(n2), + node3=const_cast(n3); + node4=const_cast(n4); SMDS_MeshVolume* volume; if(hasConstructionFaces()) { @@ -247,17 +321,18 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, SMDS_MeshFace * f2=createTriangle(node1,node2,node4); SMDS_MeshFace * f3=createTriangle(node1,node3,node4); SMDS_MeshFace * f4=createTriangle(node2,node3,node4); - SMDS_MeshVolume* volume= - new SMDS_VolumeOfFaces(f1,f2,f3,f4); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4); myVolumes.insert(volume); } else if(hasConstructionEdges()) { - /** @todo */ + MESSAGE("Error : Not implemented"); + return NULL; } else { - /** @todo */ + volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4); + myVolumes.insert(volume); } if(myElementIDFactory->BindID(ID, volume)) @@ -276,32 +351,64 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, } /////////////////////////////////////////////////////////////////////////////// -/// Add a pyramid to the mesh. node 1,2,3 and 4 define the base of the pyramid +///Create a new pyramid and add it to the mesh. +///Nodes 1,2,3 and 4 define the base of the pyramid +///@return The created pyramid /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshVolume * SMDS_Mesh::AddVolume(int idnode1, - int idnode2, int idnode3, int idnode4, int idnode5) + +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, const SMDS_MeshNode * n5) { int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v= - AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, ID); + SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } /////////////////////////////////////////////////////////////////////////////// -/// Add a pyramid to the mesh. node 1,2,3 and 4 define the base of the pyramid +///Create a new pyramid and add it to the mesh. +///Nodes 1,2,3 and 4 define the base of the pyramid +///@param ID The ID of the new volume +///@return The created pyramid or NULL if a pyramid with this ID already exists +///or if input nodes are not found. /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, + +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3, int idnode4, int idnode5, int ID) { - SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); - SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); - - if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)) + SMDS_MeshNode *node1, *node2, *node3, *node4, *node5; + node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)|| + (node5=NULL)) return NULL; + return AddVolumeWithID(node1, node2, node3, node4, node5, ID); +} +/////////////////////////////////////////////////////////////////////////////// +///Create a new pyramid and add it to the mesh. +///Nodes 1,2,3 and 4 define the base of the pyramid +///@param ID The ID of the new volume +///@return The created pyramid +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID( + const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n5, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4, *node5; + node1=const_cast(n1), + node2=const_cast(n2), + node3=const_cast(n3); + node4=const_cast(n4); + node5=const_cast(n5); SMDS_MeshVolume* volume; if(hasConstructionFaces()) { @@ -309,17 +416,18 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, SMDS_MeshFace * f2=createTriangle(node1,node2,node5); SMDS_MeshFace * f3=createTriangle(node2,node3,node5); SMDS_MeshFace * f4=createTriangle(node3,node4,node5); - SMDS_MeshFace * f5=createTriangle(node4,node1,node4); - SMDS_MeshVolume* volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4); myVolumes.insert(volume); } else if(hasConstructionEdges()) { - /** @todo */ + MESSAGE("Error : Not implemented"); + return NULL; } else { - /** @todo */ + volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5); + myVolumes.insert(volume); } if(myElementIDFactory->BindID(ID, volume)) @@ -339,56 +447,88 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, } /////////////////////////////////////////////////////////////////////////////// -/// Add a prism. Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle. +///Create a new prism and add it to the mesh. +///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle. +///@return The created prism /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshVolume* SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, - int idnode4, int idnode5, int idnode6) + +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, const SMDS_MeshNode * n5, + const SMDS_MeshNode * n6) { int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v= - AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, - ID); + SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } -//======================================================================= -//function : AddVolume -//purpose : Prism -//======================================================================= - -SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3, - int idnode4, int idnode5, int idnode6, int ID) -{ - SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); - SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); - SMDS_MeshNode * node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); +/////////////////////////////////////////////////////////////////////////////// +///Create a new prism and add it to the mesh. +///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle. +///@param ID The ID of the new volume +///@return The created prism or NULL if a prism with this ID already exists +///or if input nodes are not found. +/////////////////////////////////////////////////////////////////////////////// - if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)|| - (node6==NULL)) return NULL; +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, + int idnode3, int idnode4, int idnode5, int idnode6, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6; + node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); + node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)|| + (node5==NULL)||(node6=NULL)) + return NULL; + return AddVolumeWithID(node1, node2, node3, node4, node5, node6, ID); +} +/////////////////////////////////////////////////////////////////////////////// +///Create a new prism and add it to the mesh. +///Nodes 1,2,3 is a triangle and 1,2,5,4 a quadrangle. +///@param ID The ID of the new volume +///@return The created prism +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID( + const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n5, + const SMDS_MeshNode * n6, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6; + node1=const_cast(n1), + node2=const_cast(n2), + node3=const_cast(n3); + node4=const_cast(n4); + node5=const_cast(n5); + node6=const_cast(n6); SMDS_MeshVolume* volume; if(hasConstructionFaces()) - { SMDS_MeshFace * f1=createTriangle(node1,node2,node3); SMDS_MeshFace * f2=createTriangle(node4,node5,node6); SMDS_MeshFace * f3=createQuadrangle(node1,node4,node5,node2); SMDS_MeshFace * f4=createQuadrangle(node2,node5,node6,node3); SMDS_MeshFace * f5=createQuadrangle(node3,node6,node4,node1); - - SMDS_MeshVolume* volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); myVolumes.insert(volume); } else if(hasConstructionEdges()) { - /** @todo */ + MESSAGE("Error : Not implemented"); + return NULL; } else { - /** @todo */ + volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6); + myVolumes.insert(volume); } if(myElementIDFactory->BindID(ID, volume)) @@ -408,40 +548,79 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode } } -//======================================================================= -//function : AddVolume -//purpose : Hexahedra -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +///Create a new hexahedron and add it to the mesh. +///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges. +///@return The created hexahedron +/////////////////////////////////////////////////////////////////////////////// -SMDS_MeshVolume* SMDS_Mesh::AddVolume(int idnode1, int idnode2, int idnode3, - int idnode4, int idnode5, int idnode6, int idnode7, int idnode8) +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, const SMDS_MeshNode * n5, + const SMDS_MeshNode * n6, const SMDS_MeshNode * n7, + const SMDS_MeshNode * n8) { int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v= - AddVolumeWithID(idnode1, idnode2, idnode3, idnode4, idnode5, idnode6, - idnode7, idnode8, ID); + SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } /////////////////////////////////////////////////////////////////////////////// -/// Add an hexahedron to the mesh. node 1,2,3,4 and 5,6,7,8 are quadrangle and -/// 5,1 and 7,3 are an edges. +///Create a new hexahedron and add it to the mesh. +///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges. +///@param ID The ID of the new volume +///@return The created hexahedron or NULL if an hexahedron with this ID already +///exists or if input nodes are not found. /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnode3, - int idnode4, int idnode5, int idnode6, int idnode7, int idnode8, int ID) -{ - SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - SMDS_MeshNode * node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - SMDS_MeshNode * node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); - SMDS_MeshNode * node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); - SMDS_MeshNode * node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); - SMDS_MeshNode * node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7); - SMDS_MeshNode * node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8); - - if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)||(node5==NULL)|| - (node6==NULL)||(node7==NULL)||(node8==NULL)) return NULL; + +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, + int idnode3, int idnode4, int idnode5, int idnode6, int idnode7, + int idnode8, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8; + node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); + node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); + node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); + node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); + node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7); + node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8); + if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4=NULL)|| + (node5==NULL)||(node6=NULL)||(node7==NULL)||(node8=NULL)) + return NULL; + return AddVolumeWithID(node1, node2, node3, node4, node5, node6, node7, + node8, ID); +} +/////////////////////////////////////////////////////////////////////////////// +///Create a new hexahedron and add it to the mesh. +///Nodes 1,2,3,4 and 5,6,7,8 are quadrangle and 5,1 and 7,3 are an edges. +///@param ID The ID of the new volume +///@return The created prism or NULL if an hexadron with this ID already exists +///or if input nodes are not found. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID( + const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n5, + const SMDS_MeshNode * n6, + const SMDS_MeshNode * n7, + const SMDS_MeshNode * n8, int ID) +{ + SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8; + node1=const_cast(n1), + node2=const_cast(n2), + node3=const_cast(n3); + node4=const_cast(n4); + node5=const_cast(n5); + node6=const_cast(n6); + node7=const_cast(n7); + node8=const_cast(n8); SMDS_MeshVolume* volume; if(hasConstructionFaces()) { @@ -456,17 +635,18 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnod } else if(hasConstructionEdges()) { - MESSAGE("Error : Not Implemented"); + MESSAGE("Error : Not implemented"); + return NULL; } else { - volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6,node7,node8); + volume=new SMDS_HexahedronOfNodes(node1,node2,node3,node4,node5,node6, + node7,node8); myVolumes.insert(volume); } if(myElementIDFactory->BindID(ID, volume)) { - //MESSAGE("SMDS_Mesh::AddVolumeWithID: update inverse elements"); node1->AddInverseElement(volume); node2->AddInverseElement(volume); node3->AddInverseElement(volume); @@ -484,11 +664,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, int idnod } } -//======================================================================= -//function : FindNode -//purpose : -//======================================================================= - +/////////////////////////////////////////////////////////////////////////////// +/// Return the node whose ID is 'ID'. +/////////////////////////////////////////////////////////////////////////////// const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const { return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID); @@ -514,7 +692,7 @@ SMDS_MeshFace * SMDS_Mesh::createTriangle(SMDS_MeshNode * node1, } else { - SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3); + SMDS_MeshFace * face = new SMDS_Tria3OfNodes(node1,node2,node3); myFaces.insert(face); return face; } @@ -547,158 +725,40 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1, } } -//======================================================================= -//function : RemoveNode -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveNode(int IDnode) -{ - RemoveNode(FindNode(IDnode)); -} - -//======================================================================= -//function : RemoveNode -//purpose : -//======================================================================= - -bool SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) -{ - SMDS_Iterator * it= - node->GetInverseElementIterator(); - while(it->more()) RemoveElement(it->next(),true); - myNodeIDFactory->ReleaseID(node->GetID()); - myNodes.erase(const_cast(node)); -} - -//======================================================================= -//function : RemoveEdge -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove a node and all the elements which own this node +/////////////////////////////////////////////////////////////////////////////// -void SMDS_Mesh::RemoveEdge(int idnode1, int idnode2) +void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) { - RemoveEdge(FindEdge(idnode1, idnode2)); + RemoveElement(node, true); } -//======================================================================= -//function : RemoveEdge -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove an edge and all the elements which own this edge +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) { - /** @todo to be fix */ - myEdges.erase(const_cast(edge)); - //removeElementDependencies(edge); - delete edge; -} - -//======================================================================= -//function : RemoveFace -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveFace(int idnode1, int idnode2, int idnode3) -{ - RemoveFace(FindFace(idnode1, idnode2, idnode3)); -} - -//======================================================================= -//function : RemoveFace -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveFace(int idnode1, int idnode2, int idnode3, int idnode4) -{ - RemoveFace(FindFace(idnode1, idnode2, idnode3, idnode4)); + RemoveElement(edge,true); } -//======================================================================= -//function : RemoveFace -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove an face and all the elements which own this face +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) { - /** @todo to be fix */ - myFaces.erase(const_cast(face)); - //removeElementDependencies(face); - delete face; + RemoveElement(face, true); } -//======================================================================= -//function : RemoveVolume -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) -{ - /** @todo to be fix */ - myVolumes.erase(const_cast(volume)); - //removeElementDependencies(volume); - delete volume; -} /////////////////////////////////////////////////////////////////////////////// -/// Remove no longer used sub element of an element. Unbind the element ID +/// Remove a volume /////////////////////////////////////////////////////////////////////////////// -void SMDS_Mesh::removeElementDependencies(SMDS_MeshElement * element) -{ - /** @todo to be fix */ - myElementIDFactory->ReleaseID(element->GetID()); - SMDS_Iterator * it=element->nodesIterator(); - while(it->more()) - { - SMDS_MeshNode * node=static_cast( - const_cast(it->next())); - node->RemoveInverseElement(element); - if(node->emptyInverseElements()) RemoveNode(node); - } -} -//======================================================================= -//function : RemoveElement -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveElement(int IDelem, const bool removenodes) -{ - RemoveElement(myElementIDFactory->MeshElement(IDelem), removenodes); -} - -//======================================================================= -//function : RemoveElement -//purpose : -//======================================================================= -void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, - const bool removenodes) +void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) { - /** @todo to be fix */ - switch(elem->GetType()) - { - case SMDSAbs_Node: - RemoveNode((const SMDS_MeshNode*)elem); - return; - case SMDSAbs_Edge: - RemoveEdge((const SMDS_MeshEdge*)elem); - break; - case SMDSAbs_Face: - RemoveFace((const SMDS_MeshFace*)elem); - break; - case SMDSAbs_Volume: - RemoveVolume((const SMDS_MeshVolume*)elem); - break; - default : - MESSAGE("remove function : unknown type"); - return; - } -/* - SMDS_Iterator * it=elem->nodesIterator(); - while(it->more()) - { - const SMDS_MeshNode * node=it->next(); - - }*/ + RemoveElement(volume, true); } //======================================================================= @@ -1026,31 +1086,52 @@ void SMDS_Mesh::DebugStats() const } +/////////////////////////////////////////////////////////////////////////////// +/// Return the number of nodes +/////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbNodes() const { - myNodes.size(); + return myNodes.size(); } +/////////////////////////////////////////////////////////////////////////////// +/// Return the number of edges (including construction edges) +/////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbEdges() const { return myEdges.size(); } +/////////////////////////////////////////////////////////////////////////////// +/// Return the number of faces (including construction faces) +/////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbFaces() const { return myFaces.size(); } +/////////////////////////////////////////////////////////////////////////////// +/// Return the number of volumes +/////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbVolumes() const { return myVolumes.size(); } +/////////////////////////////////////////////////////////////////////////////// +/// Return the number of child mesh of this mesh. +/// Note that the tree structure of SMDS_Mesh seems to be unused in this version +/// (2003-09-08) of SMESH +/////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbSubMesh() const { return myChildren.size(); } +/////////////////////////////////////////////////////////////////////////////// +/// Destroy the mesh and all its elements +/// All pointer on elements owned by this mesh become illegals. +/////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::~SMDS_Mesh() { if(myParent==NULL) @@ -1096,31 +1177,59 @@ SMDS_Mesh::~SMDS_Mesh() } +/////////////////////////////////////////////////////////////////////////////// +/// Return true if this mesh create faces with edges. +/// A false returned value mean that faces are created with nodes. A concequence +/// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable. +/////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::hasConstructionEdges() { return myHasConstructionEdges; } +/////////////////////////////////////////////////////////////////////////////// +/// Return true if this mesh create volumes with faces +/// A false returned value mean that volumes are created with nodes or edges. +/// (see hasConstructionEdges) +/// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be +/// unavailable. +/////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::hasConstructionFaces() { return myHasConstructionFaces; } +/////////////////////////////////////////////////////////////////////////////// +/// Return true if nodes are linked to the finit elements, they are belonging to. +/// Currently, It always return true. +/////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::hasInverseElements() { return myHasInverseElements; } +/////////////////////////////////////////////////////////////////////////////// +/// Make this mesh creating construction edges (see hasConstructionEdges) +/// @param b true to have construction edges, else false. +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::setConstructionEdges(bool b) { myHasConstructionEdges=b; } +/////////////////////////////////////////////////////////////////////////////// +/// Make this mesh creating construction faces (see hasConstructionFaces) +/// @param b true to have construction faces, else false. +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::setConstructionFaces(bool b) { myHasConstructionFaces=b; } +/////////////////////////////////////////////////////////////////////////////// +/// Make this mesh creating link from nodes to elements (see hasInverseElements) +/// @param b true to link nodes to elements, else false. +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::setInverseElements(bool b) { if(!b) MESSAGE("Error : inverseElement=false not implemented"); @@ -1128,8 +1237,8 @@ void SMDS_Mesh::setInverseElements(bool b) } /////////////////////////////////////////////////////////////////////////////// -///Return an iterator on nodes of the current mesh. Once used this iterator -///must be free by the caller +/// Return an iterator on nodes of the current mesh. Once used this iterator +/// must be free by the caller /////////////////////////////////////////////////////////////////////////////// SMDS_Iterator * SMDS_Mesh::nodesIterator() const { @@ -1145,7 +1254,7 @@ SMDS_Iterator * SMDS_Mesh::nodesIterator() const bool more() { - myIterator!=mySet.end(); + return myIterator!=mySet.end(); } const SMDS_MeshNode* next() @@ -1251,7 +1360,7 @@ SMDS_Iterator * SMDS_Mesh::volumesIterator() const bool more() { - myIterator!=mySet.end(); + return myIterator!=mySet.end(); } const SMDS_MeshVolume* next() @@ -1264,3 +1373,201 @@ SMDS_Iterator * SMDS_Mesh::volumesIterator() const return new MyIterator(myVolumes); } +/////////////////////////////////////////////////////////////////////////////// +/// Do intersection of sets (more than 2) +/////////////////////////////////////////////////////////////////////////////// +set * intersectionOfSets( + set vs[], int numberOfSets) +{ + set* rsetA=new set(vs[0]); + set* rsetB; + + for(int i=0; i(); + set_intersection( + rsetA->begin(), rsetA->end(), + vs[i+1].begin(), vs[i+1].end(), + inserter(*rsetB, rsetB->begin())); + delete rsetA; + rsetA=rsetB; + } + return rsetA; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Return the list of finit elements owning the given element +/////////////////////////////////////////////////////////////////////////////// +set * getFinitElements(const SMDS_MeshElement * element) +{ + int numberOfSets=element->NbNodes(); + set initSet[numberOfSets]; + + SMDS_Iterator * itNodes=element->nodesIterator(); + + int i=0; + while(itNodes->more()) + { + const SMDS_MeshNode * n=static_cast(itNodes->next()); + SMDS_Iterator * itFe = n->GetInverseElementIterator(); + + //initSet[i]=set(); + while(itFe->more()) initSet[i].insert(itFe->next()); + + i++; + delete itFe; + } + delete itNodes; + + return intersectionOfSets(initSet, numberOfSets); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Return the list of nodes used only by the given elements +/////////////////////////////////////////////////////////////////////////////// +set * getExclusiveNodes( + set& elements) +{ + set * toReturn=new set(); + set::iterator itElements=elements.begin(); + + while(itElements!=elements.end()) + { + SMDS_Iterator * itNodes= + (*itElements)->nodesIterator(); + itElements++; + + while(itNodes->more()) + { + const SMDS_MeshNode * n=static_cast(itNodes->next()); + SMDS_Iterator * itFe = n->GetInverseElementIterator(); + set s; + while(itFe->more()) s.insert(itFe->next()); + delete itFe; + if(s==elements) toReturn->insert(n); + } + delete itNodes; + } + return toReturn; +} + +/////////////////////////////////////////////////////////////////////////////// +///Find the children of an element that are made of given nodes +///@param setOfChildren The set in which matching children will be inserted +///@param element The element were to search matching children +///@param nodes The nodes that the children must have to be selected +/////////////////////////////////////////////////////////////////////////////// +void SMDS_Mesh::addChildrenWithNodes(set& setOfChildren, + const SMDS_MeshElement * element, set& nodes) +{ + + switch(element->GetType()) + { + case SMDSAbs_Node: + MESSAGE("Internal Error: This should not append"); + break; + case SMDSAbs_Edge: + { + SMDS_Iterator * itn=element->nodesIterator(); + while(itn->more()) + { + const SMDS_MeshElement * e=itn->next(); + if(nodes.find(e)!=nodes.end()) setOfChildren.insert(element); + } + delete itn; + } break; + case SMDSAbs_Face: + { + SMDS_Iterator * itn=element->nodesIterator(); + while(itn->more()) + { + const SMDS_MeshElement * e=itn->next(); + if(nodes.find(e)!=nodes.end()) setOfChildren.insert(element); + } + delete itn; + if(hasConstructionEdges()) + { + SMDS_Iterator* ite=element->edgesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + delete ite; + } + } break; + case SMDSAbs_Volume: + { + if(hasConstructionFaces()) + { + SMDS_Iterator * ite=element->facesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + delete ite; + } + else if(hasConstructionEdges()) + { + SMDS_Iterator * ite=element->edgesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + delete ite; + } + } + } +} + +/////////////////////////////////////////////////////////////////////////////// +///@param elem The element to delete +///@param removenodes if true remaining nodes will be removed +/////////////////////////////////////////////////////////////////////////////// +void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, + const bool removenodes) +{ + set * s1=getFinitElements(elem); + + set * s2=getExclusiveNodes(*s1); + set s3; + set::iterator it=s1->begin(); + while(it!=s1->end()) + { + addChildrenWithNodes(s3, *it ,*s2); + s3.insert(*it); + it++; + } + if(elem->GetType()!=SMDSAbs_Node) s3.insert(elem); + it=s3.begin(); + while(it!=s3.end()) + { + switch((*it)->GetType()) + { + case SMDSAbs_Node: + MESSAGE("Internal Error: This should not happen"); + break; + case SMDSAbs_Edge: + myEdges.erase(static_cast( + const_cast(*it))); + break; + case SMDSAbs_Face: + myFaces.erase(static_cast( + const_cast(*it))); + break; + case SMDSAbs_Volume: + myVolumes.erase(static_cast( + const_cast(*it))); + break; + } + delete (*it); + it++; + } + if(removenodes) + { + it=s2->begin(); + while(it!=s2->end()) + { + myNodes.erase(static_cast( + const_cast(*it))); + delete *it; + it++; + } + } + + delete s2; + delete s1; +}