X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=6b0ca83d509f380c533847f1902521f443568d0a;hp=a67282810e6ab1fc3e857c426e6457aa56e37d9d;hb=e02efafc157b2d557d77e591cfc86c0d1a0d8518;hpb=484fe83a97f643207334576fbe08d4a90d67fd37 diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx index a67282810..6b0ca83d5 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,22 +725,11 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1, } } -//======================================================================= -//function : RemoveNode -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveNode(int IDnode) -{ - RemoveNode(FindNode(IDnode)); -} - -//======================================================================= -//function : RemoveNode -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove a node and all the elements which own this node +/////////////////////////////////////////////////////////////////////////////// -bool SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) +void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) { SMDS_Iterator * it= node->GetInverseElementIterator(); @@ -571,20 +738,9 @@ bool SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) myNodes.erase(const_cast(node)); } -//======================================================================= -//function : RemoveEdge -//purpose : -//======================================================================= - -void SMDS_Mesh::RemoveEdge(int idnode1, int idnode2) -{ - RemoveEdge(FindEdge(idnode1, idnode2)); -} - -//======================================================================= -//function : RemoveEdge -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove an edge and all the elements which own this edge +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) { @@ -594,30 +750,9 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * 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)); -} - -//======================================================================= -//function : RemoveFace -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove an face and all the elements which own this face +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) { @@ -627,10 +762,9 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) delete face; } -//======================================================================= -//function : RemoveVolume -//purpose : -//======================================================================= +/////////////////////////////////////////////////////////////////////////////// +/// Remove a volume +/////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) { @@ -639,9 +773,11 @@ void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) //removeElementDependencies(volume); delete volume; } + /////////////////////////////////////////////////////////////////////////////// /// Remove no longer used sub element of an element. Unbind the element ID /////////////////////////////////////////////////////////////////////////////// + void SMDS_Mesh::removeElementDependencies(SMDS_MeshElement * element) { /** @todo to be fix */ @@ -655,15 +791,6 @@ void SMDS_Mesh::removeElementDependencies(SMDS_MeshElement * 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 @@ -1026,31 +1153,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 +1244,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 +1304,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 +1321,7 @@ SMDS_Iterator * SMDS_Mesh::nodesIterator() const bool more() { - myIterator!=mySet.end(); + return myIterator!=mySet.end(); } const SMDS_MeshNode* next() @@ -1251,7 +1427,7 @@ SMDS_Iterator * SMDS_Mesh::volumesIterator() const bool more() { - myIterator!=mySet.end(); + return myIterator!=mySet.end(); } const SMDS_MeshVolume* next()