X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=ed42389f991d1d1b56ac0cc794843789a693ade6;hp=eda54c971fb6e0efc07bce69389442705505648a;hb=e3214b68d298250cb463df645aecb3d2fdd5627a;hpb=7b70ad87bf8f5c46b2751f94cd196932b9ae7122 diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx index eda54c971..ed42389f9 100644 --- a/src/SMDS/SMDS_Mesh.cxx +++ b/src/SMDS/SMDS_Mesh.cxx @@ -1,45 +1,159 @@ -// SMESH SMDS : implementaion of Salome mesh data structure +// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +// SMESH SMDS : implementaion of Salome mesh data structure + +#ifdef _MSC_VER +#pragma warning(disable:4786) +#endif #include "utilities.h" #include "SMDS_Mesh.hxx" #include "SMDS_VolumeOfNodes.hxx" #include "SMDS_VolumeOfFaces.hxx" #include "SMDS_FaceOfNodes.hxx" -#include "SMDS_Tria3OfNodes.hxx" -#include "SMDS_HexahedronOfNodes.hxx" #include "SMDS_FaceOfEdges.hxx" +#include "SMDS_PolyhedralVolumeOfNodes.hxx" +#include "SMDS_PolygonalFaceOfNodes.hxx" +#include "SMDS_QuadraticEdge.hxx" +#include "SMDS_QuadraticFaceOfNodes.hxx" +#include "SMDS_QuadraticVolumeOfNodes.hxx" +#include "SMDS_SpacePosition.hxx" +#include "SMDS_UnstructuredGrid.hxx" + +#include +#include +#include +#include +#include +#include #include +#include +#include +#include using namespace std; +#ifndef WIN32 +#include +#endif + +// number of added entities to check memory after +#define CHECKMEMORY_INTERVAL 1000 + +vector SMDS_Mesh::_meshList = vector(); +int SMDS_Mesh::chunkSize = 1024; + + +//================================================================================ +/*! + * \brief Raise an exception if free memory (ram+swap) too low + * \param doNotRaise - if true, suppres exception, just return free memory size + * \retval int - amount of available memory in MB or negative number in failure case + */ +//================================================================================ + +int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) +{ +#ifndef WIN32 + struct sysinfo si; + int err = sysinfo( &si ); + if ( err ) + return -1; + + static int limit = -1; + if ( limit < 0 ) { + int status = system("SMDS_MemoryLimit"); // it returns lower limit of free RAM + if (status >= 0 ) { + limit = WEXITSTATUS(status); + } + if ( limit < 20 ) + limit = 20; + else + limit = int( limit * 1.5 ); +#ifdef _DEBUG_ + MESSAGE ( "SMDS_Mesh::CheckMemory() memory limit = " << limit << " MB" ); +#endif + } + + const unsigned long Mbyte = 1024 * 1024; + // compute separately to avoid overflow + int freeMb = + ( si.freeram * si.mem_unit ) / Mbyte + + ( si.freeswap * si.mem_unit ) / Mbyte; + + if ( freeMb > limit ) + return freeMb - limit; + + if ( doNotRaise ) + return 0; +#ifdef _DEBUG_ + MESSAGE ("SMDS_Mesh::CheckMemory() throws as free memory too low: " << freeMb <<" MB" ); +#endif + throw std::bad_alloc(); +#else + return -1; +#endif +} + /////////////////////////////////////////////////////////////////////////////// /// Create a new mesh object /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::SMDS_Mesh() - :myNodeIDFactory(new SMDS_MeshElementIDFactory()), - myElementIDFactory(new SMDS_MeshElementIDFactory()), - myHasConstructionEdges(false), myHasConstructionFaces(false), - myHasInverseElements(true) -{ + :myParent(NULL), + myNodeIDFactory(new SMDS_MeshNodeIDFactory()), + myElementIDFactory(new SMDS_MeshElementIDFactory()), + myHasConstructionEdges(false), myHasConstructionFaces(false), + myHasInverseElements(true), + myNodeMin(0), myNodeMax(0), + myNodePool(0), myEdgePool(0), myFacePool(0), myVolumePool(0) +{ + myMeshId = _meshList.size(); // --- index of the mesh to push back in the vector + MESSAGE("myMeshId=" << myMeshId); + MESSAGE("sizeof(SMDS_MeshElement) " << sizeof(SMDS_MeshElement) ); + MESSAGE("sizeof(SMDS_MeshNode) " << sizeof(SMDS_MeshNode) ); + MESSAGE("sizeof(SMDS_MeshCell) " << sizeof(SMDS_MeshCell) ); + MESSAGE("sizeof(SMDS_VtkVolume) " << sizeof(SMDS_VtkVolume) ); + MESSAGE("sizeof(SMDS_Position) " << sizeof(SMDS_Position) ); + MESSAGE("sizeof(SMDS_SpacePosition) " << sizeof(SMDS_SpacePosition) ); + myNodeIDFactory->SetMesh(this); + myElementIDFactory->SetMesh(this); + _meshList.push_back(this); + myNodePool = new ObjectPool(SMDS_Mesh::chunkSize); + myEdgePool = new ObjectPool(SMDS_Mesh::chunkSize); + myFacePool = new ObjectPool(SMDS_Mesh::chunkSize); + myVolumePool = new ObjectPool(SMDS_Mesh::chunkSize); + + myNodes.clear(); + myCells.clear(); + myIDElements.clear(); + myVtkIndex.clear(); + myGrid = SMDS_UnstructuredGrid::New(); + myGrid->Initialize(); + myGrid->Allocate(); + vtkPoints* points = vtkPoints::New(); + points->SetNumberOfPoints(SMDS_Mesh::chunkSize); + myGrid->SetPoints( points ); + points->Delete(); + myGrid->BuildLinks(); } /////////////////////////////////////////////////////////////////////////////// @@ -48,10 +162,14 @@ SMDS_Mesh::SMDS_Mesh() /// (2003-09-08) of SMESH /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent) - :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory), - myElementIDFactory(parent->myElementIDFactory), - myHasConstructionEdges(false), myHasConstructionFaces(false), - myHasInverseElements(true) + :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory), + myElementIDFactory(parent->myElementIDFactory), + myHasConstructionEdges(false), myHasConstructionFaces(false), + myHasInverseElements(true), + myNodePool(parent->myNodePool), + myEdgePool(parent->myEdgePool), + myFacePool(parent->myFacePool), + myVolumePool(parent->myVolumePool) { } @@ -61,9 +179,9 @@ SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent) SMDS_Mesh *SMDS_Mesh::AddSubMesh() { - SMDS_Mesh *submesh = new SMDS_Mesh(this); - myChildren.insert(myChildren.end(), submesh); - return submesh; + SMDS_Mesh *submesh = new SMDS_Mesh(this); + myChildren.insert(myChildren.end(), submesh); + return submesh; } /////////////////////////////////////////////////////////////////////////////// @@ -74,7 +192,7 @@ SMDS_Mesh *SMDS_Mesh::AddSubMesh() SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z) { - return AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID()); + return SMDS_Mesh::AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -84,18 +202,71 @@ SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z) /////////////////////////////////////////////////////////////////////////////// SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) { - // find the MeshNode corresponding to ID - const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID); + // find the MeshNode corresponding to ID + const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID); + if(!node){ + //if ( myNodes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + //SMDS_MeshNode * node=new SMDS_MeshNode(ID, myMeshId, -1, x, y, z); + SMDS_MeshNode * node = myNodePool->getNew(); + node->init(ID, myMeshId, -1, x, y, z); + if (ID >= myNodes.size()) + { + myNodes.resize(ID+SMDS_Mesh::chunkSize, 0); + //MESSAGE(" ------------------ myNodes resize " << ID << " --> " << ID+SMDS_Mesh::chunkSize); + } + myNodes[ID] = node; + myNodeIDFactory->BindID(ID,node); + myInfo.myNbNodes++; + return node; + }else + return NULL; +} + +/////////////////////////////////////////////////////////////////////////////// +/// create a Mesh0DElement and add it to the current Mesh +/// @return : The created Mesh0DElement +/////////////////////////////////////////////////////////////////////////////// +SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(int idnode, int ID) +{ + SMDS_MeshNode * node = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode); + if (!node) return NULL; + return SMDS_Mesh::Add0DElementWithID(node, ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// create a Mesh0DElement and add it to the current Mesh +/// @return : The created Mesh0DElement +/////////////////////////////////////////////////////////////////////////////// +SMDS_Mesh0DElement* SMDS_Mesh::Add0DElement(const SMDS_MeshNode * node) +{ + return SMDS_Mesh::Add0DElementWithID(node, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Create a new Mesh0DElement and at it to the mesh +/// @param idnode ID of the node +/// @param ID ID of the 0D element to create +/// @return The created 0D element or NULL if an element with this +/// ID already exists or if input node is not found. +/////////////////////////////////////////////////////////////////////////////// +SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int ID) +{ + if (!n) return 0; + + //if (my0DElements.Extent() % CHECKMEMORY_INTERVAL == 0) CheckMemory(); + //MESSAGE("Add0DElementWithID" << ID) + SMDS_Mesh0DElement * el0d = new SMDS_Mesh0DElement(n); + if (myElementIDFactory->BindID(ID, el0d)) { + SMDS_MeshNode *node = const_cast(n); + //node->AddInverseElement(el0d);// --- fait avec BindID + adjustmyCellsCapacity(ID); + myCells[ID] = el0d; + myInfo.myNb0DElements++; + return el0d; + } - if (node == NULL) - { - SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z); - myNodes.insert(node); - myNodeIDFactory->BindID(ID,node); - return node; - } - else - return NULL; + delete el0d; + return NULL; } /////////////////////////////////////////////////////////////////////////////// @@ -103,12 +274,12 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) /// @return : The created MeshEdge /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) +SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) { - 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); + SMDS_MeshNode * node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); + SMDS_MeshNode * node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); + if(!node1 || !node2) return NULL; + return SMDS_Mesh::AddEdgeWithID(node1, node2, ID); } /////////////////////////////////////////////////////////////////////////////// @@ -117,9 +288,9 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) /////////////////////////////////////////////////////////////////////////////// SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1, - const SMDS_MeshNode * node2) + const SMDS_MeshNode * node2) { - return AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -127,30 +298,36 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1, /// @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 +/// @return The created edge or NULL if an element 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) + const SMDS_MeshNode * n2, + int ID) { - SMDS_MeshNode *node1,*node2; - node1=const_cast(n1); - node2=const_cast(n2); + if ( !n1 || !n2 ) return 0; + SMDS_MeshEdge * edge = 0; - SMDS_MeshEdge * edge=new SMDS_MeshEdge(node1,node2); - if(myElementIDFactory->BindID(ID, edge)) - { - node1->AddInverseElement(edge); - node2->AddInverseElement(edge); - myEdges.insert(edge); - return edge; - } - else - { - delete edge; - return NULL; - } + // --- retreive nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n2->getId()); + + SMDS_VtkEdge *edgevtk = myEdgePool->getNew(); + edgevtk->init(nodeIds, this); + edge = edgevtk; + adjustmyCellsCapacity(ID); + myCells[ID] = edge; + myInfo.myNbEdges++; + + if (edge && !registerElement(ID, edge)) + { + RemoveElement(edge, false); + edge = NULL; + } + return edge; } /////////////////////////////////////////////////////////////////////////////// @@ -159,81 +336,74 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, - const SMDS_MeshNode * n2, - const SMDS_MeshNode * n3) + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3) { - return AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// -/// Add a quadrangle defined by its nodes IDs +/// Add a triangle defined by its nodes IDs /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, 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); - if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL; - return AddFaceWithID(node1, node2, node3, 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); + if(!node1 || !node2 || !node3) return NULL; + return SMDS_Mesh::AddFaceWithID(node1, node2, node3, ID); } /////////////////////////////////////////////////////////////////////////////// -/// Add a quadrangle defined by its nodes +/// Add a triangle defined by its nodes /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddFaceWithID( - const SMDS_MeshNode * n1, - const SMDS_MeshNode * n2, - const SMDS_MeshNode * n3, int ID) +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); + //MESSAGE("AddFaceWithID " << ID) + SMDS_MeshFace * face=createTriangle(n1, n2, n3, ID); - if(myElementIDFactory->BindID(ID, face)) - { - node1->AddInverseElement(face); - node2->AddInverseElement(face); - node3->AddInverseElement(face); - return face; - } - else - { - RemoveFace(face); - return NULL; - } + if (face && !registerElement(ID, face)) { + RemoveElement(face, false); + face = NULL; + } + return face; } /////////////////////////////////////////////////////////////////////////////// -/// Add a triangle defined by its nodes. An ID is automatically affected to the +/// Add a quadrangle defined by its nodes. An ID is automatically affected to the /// created face /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, - const SMDS_MeshNode * n2, - const SMDS_MeshNode * n3, - const SMDS_MeshNode * n4) + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4) { - return AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// /// 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, *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); + 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 || !node2 || !node3 || !node4) return NULL; + return SMDS_Mesh::AddFaceWithID(node1, node2, node3, node4, ID); } /////////////////////////////////////////////////////////////////////////////// @@ -241,157 +411,247 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, int idnode2, int idnode3, /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, - const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, - const SMDS_MeshNode * n4, int ID) + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + int ID) +{ + //MESSAGE("AddFaceWithID " << ID); + SMDS_MeshFace * face=createQuadrangle(n1, n2, n3, n4, ID); + + if (face && !registerElement(ID, face)) { + RemoveElement(face, false); + face = NULL; + } + return face; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a triangle defined by its edges. An ID is automatically assigned to the +/// Created face +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1, + const SMDS_MeshEdge * e2, + const SMDS_MeshEdge * e3) +{ + if (!hasConstructionEdges()) + return NULL; + //MESSAGE("AddFaceWithID"); + return AddFaceWithID(e1,e2,e3, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a triangle defined by its edges +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1, + const SMDS_MeshEdge * e2, + const SMDS_MeshEdge * e3, + int ID) +{ + if (!hasConstructionEdges()) + return NULL; + if ( !e1 || !e2 || !e3 ) return 0; + + //if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + //MESSAGE("AddFaceWithID" << ID); + + SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3); + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbTriangles++; + + if (!registerElement(ID, face)) { + RemoveElement(face, false); + face = NULL; + } + return face; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadrangle defined by its edges. An ID is automatically assigned to the +/// Created face +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1, + const SMDS_MeshEdge * e2, + const SMDS_MeshEdge * e3, + const SMDS_MeshEdge * e4) +{ + if (!hasConstructionEdges()) + return NULL; + //MESSAGE("AddFaceWithID" ); + return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadrangle defined by its edges +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1, + const SMDS_MeshEdge * e2, + const SMDS_MeshEdge * e3, + const SMDS_MeshEdge * e4, + 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 (!hasConstructionEdges()) + return NULL; + //MESSAGE("AddFaceWithID" << ID); + if ( !e1 || !e2 || !e3 || !e4 ) return 0; + //if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4); + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbQuadrangles++; - if(myElementIDFactory->BindID(ID, face)) - { - node1->AddInverseElement(face); - node2->AddInverseElement(face); - node3->AddInverseElement(face); - node4->AddInverseElement(face); - return face; - } - else - { - RemoveFace(face); - return NULL; - } + if (!registerElement(ID, face)) + { + RemoveElement(face, false); + face = NULL; + } + return face; } /////////////////////////////////////////////////////////////////////////////// -///Create a new tetrahedron and add it to the mesh. -///@return The created tetrahedron +///Create a new tetrahedron and add it to the mesh. +///@return The created tetrahedron /////////////////////////////////////////////////////////////////////////////// SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, - const SMDS_MeshNode * n2, const SMDS_MeshNode * n3, - const SMDS_MeshNode * n4) + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myElementIDFactory->GetFreeID(); + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } /////////////////////////////////////////////////////////////////////////////// -///Create a new tetrahedron and add it to the mesh. +///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 +///@return The created tetrahedron or NULL if an element 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 ID) +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, + int idnode2, + int idnode3, + int idnode4, + int ID) { - 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); + //MESSAGE("AddVolumeWithID" << ID); + 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 || !node2 || !node3 || !node4) return NULL; + return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, ID); } - + /////////////////////////////////////////////////////////////////////////////// -///Create a new tetrahedron and add it to the mesh. +///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()) - { - SMDS_MeshFace * f1=createTriangle(node1,node2,node3); - SMDS_MeshFace * f2=createTriangle(node1,node2,node4); - SMDS_MeshFace * f3=createTriangle(node1,node3,node4); - SMDS_MeshFace * f4=createTriangle(node2,node3,node4); - volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4); - myVolumes.insert(volume); - } - else if(hasConstructionEdges()) - { - MESSAGE("Error : Not implemented"); - return NULL; - } - else - { - volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4); - myVolumes.insert(volume); - } - - if(myElementIDFactory->BindID(ID, volume)) - { - node1->AddInverseElement(volume); - node2->AddInverseElement(volume); - node3->AddInverseElement(volume); - node4->AddInverseElement(volume); - return volume; - } - else - { - RemoveVolume(volume); - return NULL; - } -} - -/////////////////////////////////////////////////////////////////////////////// -///Create a new pyramid and add it to the mesh. +///@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) +{ + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume* volume = 0; + if ( !n1 || !n2 || !n3 || !n4) return volume; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if(hasConstructionFaces()) { + SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3); + SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n4); + SMDS_MeshFace * f3=FindFaceOrCreate(n1,n3,n4); + SMDS_MeshFace * f4=FindFaceOrCreate(n2,n3,n4); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbTetras++; + } + else if(hasConstructionEdges()) { + MESSAGE("Error : Not implemented"); + return NULL; + } + else { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n3->getId()); // order SMDS-->VTK + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n4->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + volume = volvtk; + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbTetras++; + } + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +///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 +///@return The created pyramid /////////////////////////////////////////////////////////////////////////////// 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 * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n5) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = AddVolumeWithID(n1, n2, n3, n4, n5, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myElementIDFactory->GetFreeID(); + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } /////////////////////////////////////////////////////////////////////////////// -///Create a new pyramid and add it to the mesh. +///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 +///@return The created pyramid or NULL if an element 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 ID) +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, + int idnode2, + int idnode3, + int idnode4, + int idnode5, + int ID) { - 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); + //MESSAGE("AddVolumeWithID " << ID); + 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 || !node2 || !node3 || !node4 || !node5) return NULL; + return SMDS_Mesh::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 @@ -399,97 +659,104 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, ///@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()) - { - SMDS_MeshFace * f1=createQuadrangle(node1,node2,node3,node4); - SMDS_MeshFace * f2=createTriangle(node1,node2,node5); - SMDS_MeshFace * f3=createTriangle(node2,node3,node5); - SMDS_MeshFace * f4=createTriangle(node3,node4,node5); - volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4); - myVolumes.insert(volume); - } - else if(hasConstructionEdges()) - { - MESSAGE("Error : Not implemented"); - return NULL; - } - else - { - volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5); - myVolumes.insert(volume); - } - - if(myElementIDFactory->BindID(ID, volume)) - { - node1->AddInverseElement(volume); - node2->AddInverseElement(volume); - node3->AddInverseElement(volume); - node4->AddInverseElement(volume); - node5->AddInverseElement(volume); - return volume; - } - else - { - RemoveVolume(volume); - return NULL; - } -} - -/////////////////////////////////////////////////////////////////////////////// -///Create a new prism and add it to the mesh. +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) +{ + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume* volume = 0; + if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if(hasConstructionFaces()) { + SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4); + SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n5); + SMDS_MeshFace * f3=FindFaceOrCreate(n2,n3,n5); + SMDS_MeshFace * f4=FindFaceOrCreate(n3,n4,n5); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPyramids++; + } + else if(hasConstructionEdges()) { + MESSAGE("Error : Not implemented"); + return NULL; + } + else { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n5->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + volume = volvtk; + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPyramids++; + } + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +///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 +///@return The created prism /////////////////////////////////////////////////////////////////////////////// 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 * 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(n1, n2, n3, n4, n5, n6, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myElementIDFactory->GetFreeID(); + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } /////////////////////////////////////////////////////////////////////////////// -///Create a new prism and add it to the mesh. +///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 +///@return The created prism or NULL if an element 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 ID) +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); + //MESSAGE("AddVolumeWithID " << 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 || !node2 || !node3 || !node4 || !node5 || !node6) return NULL; + return SMDS_Mesh::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. @@ -497,174 +764,491 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode2, ///@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); - volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); - myVolumes.insert(volume); - } - else if(hasConstructionEdges()) - { - MESSAGE("Error : Not implemented"); - return NULL; - } - else - { - volume=new SMDS_VolumeOfNodes(node1,node2,node3,node4,node5,node6); - myVolumes.insert(volume); - } - - if(myElementIDFactory->BindID(ID, volume)) - { - node1->AddInverseElement(volume); - node2->AddInverseElement(volume); - node3->AddInverseElement(volume); - node4->AddInverseElement(volume); - node5->AddInverseElement(volume); - node6->AddInverseElement(volume); - return volume; - } - else - { - RemoveVolume(volume); - return NULL; - } -} - -/////////////////////////////////////////////////////////////////////////////// -///Create a new hexahedron and add it to the mesh. +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) +{ + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume* volume = 0; + if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if(hasConstructionFaces()) { + SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3); + SMDS_MeshFace * f2=FindFaceOrCreate(n4,n5,n6); + SMDS_MeshFace * f3=FindFaceOrCreate(n1,n4,n5,n2); + SMDS_MeshFace * f4=FindFaceOrCreate(n2,n5,n6,n3); + SMDS_MeshFace * f5=FindFaceOrCreate(n3,n6,n4,n1); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPrisms++; + } + else if(hasConstructionEdges()) { + MESSAGE("Error : Not implemented"); + return NULL; + } + else { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n5->getId()); + nodeIds.push_back(n6->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + volume = volvtk; + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPrisms++; + } + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +///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 +///@return The created hexahedron /////////////////////////////////////////////////////////////////////////////// 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) + 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(n1, n2, n3, n4, n5, n6, n7, n8, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myElementIDFactory->GetFreeID(); + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; } /////////////////////////////////////////////////////////////////////////////// -///Create a new hexahedron and add it to the mesh. +///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 +///@return The created hexahedron or NULL if an element 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, *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); +SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, + int idnode2, + int idnode3, + int idnode4, + int idnode5, + int idnode6, + int idnode7, + int idnode8, + int ID) +{ + //MESSAGE("AddVolumeWithID " << 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 || !node2 || !node3 || !node4 || !node5 || !node6 || !node7 || !node8) + return NULL; + return SMDS_Mesh::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 +///@return The created prism or NULL if an element 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()) - { - SMDS_MeshFace * f1=FindFaceOrCreate(node1,node2,node3,node4); - SMDS_MeshFace * f2=FindFaceOrCreate(node5,node6,node7,node8); - SMDS_MeshFace * f3=FindFaceOrCreate(node1,node4,node8,node5); - SMDS_MeshFace * f4=FindFaceOrCreate(node1,node2,node6,node5); - SMDS_MeshFace * f5=FindFaceOrCreate(node2,node3,node7,node6); - SMDS_MeshFace * f6=FindFaceOrCreate(node3,node4,node8,node7); - volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6); - myVolumes.insert(volume); - } - else if(hasConstructionEdges()) - { - MESSAGE("Error : Not implemented"); - return NULL; - } - else - { - volume=new SMDS_HexahedronOfNodes(node1,node2,node3,node4,node5,node6, - node7,node8); - myVolumes.insert(volume); - } - - if(myElementIDFactory->BindID(ID, volume)) - { - node1->AddInverseElement(volume); - node2->AddInverseElement(volume); - node3->AddInverseElement(volume); - node4->AddInverseElement(volume); - node5->AddInverseElement(volume); - node6->AddInverseElement(volume); - node7->AddInverseElement(volume); - node8->AddInverseElement(volume); - return volume; - } - else - { - RemoveVolume(volume); - return NULL; - } +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) +{ + //MESSAGE("AddVolumeWithID " << ID); + SMDS_MeshVolume* volume = 0; + if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if(hasConstructionFaces()) { + SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4); + SMDS_MeshFace * f2=FindFaceOrCreate(n5,n6,n7,n8); + SMDS_MeshFace * f3=FindFaceOrCreate(n1,n4,n8,n5); + SMDS_MeshFace * f4=FindFaceOrCreate(n1,n2,n6,n5); + SMDS_MeshFace * f5=FindFaceOrCreate(n2,n3,n7,n6); + SMDS_MeshFace * f6=FindFaceOrCreate(n3,n4,n8,n7); + volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbHexas++; + } + else if(hasConstructionEdges()) { + MESSAGE("Error : Not implemented"); + return NULL; + } + else { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n5->getId()); + nodeIds.push_back(n8->getId()); + nodeIds.push_back(n7->getId()); + nodeIds.push_back(n6->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + volume = volvtk; + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbHexas++; + } + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new tetrahedron defined by its faces and add it to the mesh. +///@return The created tetrahedron +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1, + const SMDS_MeshFace * f2, + const SMDS_MeshFace * f3, + const SMDS_MeshFace * f4) +{ + //MESSAGE("AddVolumeWithID"); + if (!hasConstructionFaces()) + return NULL; + return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new tetrahedron defined by its faces 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_MeshFace * f1, + const SMDS_MeshFace * f2, + const SMDS_MeshFace * f3, + const SMDS_MeshFace * f4, + int ID) +{ + //MESSAGE("AddVolumeWithID" << ID); + if (!hasConstructionFaces()) + return NULL; + if ( !f1 || !f2 || !f3 || !f4) return 0; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbTetras++; + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new pyramid defined by its faces and add it to the mesh. +///@return The created pyramid +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1, + const SMDS_MeshFace * f2, + const SMDS_MeshFace * f3, + const SMDS_MeshFace * f4, + const SMDS_MeshFace * f5) +{ + //MESSAGE("AddVolumeWithID"); + if (!hasConstructionFaces()) + return NULL; + return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new pyramid defined by its faces and add it to the mesh. +///@param ID The ID of the new volume +///@return The created pyramid +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1, + const SMDS_MeshFace * f2, + const SMDS_MeshFace * f3, + const SMDS_MeshFace * f4, + const SMDS_MeshFace * f5, + int ID) +{ + //MESSAGE("AddVolumeWithID" << ID); + if (!hasConstructionFaces()) + return NULL; + if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPyramids++; + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new prism defined by its faces and add it to the mesh. +///@return The created prism +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1, + const SMDS_MeshFace * f2, + const SMDS_MeshFace * f3, + const SMDS_MeshFace * f4, + const SMDS_MeshFace * f5, + const SMDS_MeshFace * f6) +{ + //MESSAGE("AddVolumeWithID" ); + if (!hasConstructionFaces()) + return NULL; + return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +///Create a new prism defined by its faces and add it to the mesh. +///@param ID The ID of the new volume +///@return The created prism +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1, + const SMDS_MeshFace * f2, + const SMDS_MeshFace * f3, + const SMDS_MeshFace * f4, + const SMDS_MeshFace * f5, + const SMDS_MeshFace * f6, + int ID) +{ + //MESSAGE("AddVolumeWithID" << ID); + if (!hasConstructionFaces()) + return NULL; + if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPrisms++; + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a polygon defined by its nodes IDs +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (std::vector nodes_ids, + const int ID) +{ + int nbNodes = nodes_ids.size(); + std::vector nodes (nbNodes); + for (int i = 0; i < nbNodes; i++) { + nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]); + if (!nodes[i]) return NULL; + } + return SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a polygon defined by its nodes +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID + (std::vector nodes, + const int ID) +{ + SMDS_MeshFace * face; + + //if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if (hasConstructionEdges()) + { + MESSAGE("Error : Not implemented"); + return NULL; + } + else + { + for ( int i = 0; i < nodes.size(); ++i ) + if ( !nodes[ i ] ) return 0; + face = new SMDS_PolygonalFaceOfNodes(nodes); + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbPolygons++; + } + + if (!registerElement(ID, face)) { + RemoveElement(face, false); + face = NULL; + } + return face; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a polygon defined by its nodes. +/// An ID is automatically affected to the created face. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (std::vector nodes) +{ + return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID()); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Create a new polyhedral volume and add it to the mesh. +/// @param ID The ID of the new volume +/// @return The created volume or NULL if an element with this ID already exists +/// or if input nodes are not found. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID + (std::vector nodes_ids, + std::vector quantities, + const int ID) +{ + int nbNodes = nodes_ids.size(); + std::vector nodes (nbNodes); + for (int i = 0; i < nbNodes; i++) { + nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]); + if (!nodes[i]) return NULL; + } + return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Create a new polyhedral volume and add it to the mesh. +/// @param ID The ID of the new volume +/// @return The created volume +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolumeWithID + (std::vector nodes, + std::vector quantities, + const int ID) +{ + SMDS_MeshVolume* volume; + //if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if (hasConstructionFaces()) { + MESSAGE("Error : Not implemented"); + return NULL; + } else if (hasConstructionEdges()) { + MESSAGE("Error : Not implemented"); + return NULL; + } else { + for ( int i = 0; i < nodes.size(); ++i ) + if ( !nodes[ i ] ) return 0; + volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities); + adjustmyCellsCapacity(ID); + myCells[ID] = volume; + myInfo.myNbPolyhedrons++; + } + + if (!registerElement(ID, volume)) { + RemoveElement(volume, false); + volume = NULL; + } + return volume; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Create a new polyhedral volume and add it to the mesh. +/// @return The created volume +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume + (std::vector nodes, + std::vector quantities) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID); + if (v == NULL) myElementIDFactory->ReleaseID(ID); + return v; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Registers element with the given ID, maintains inverse connections +/////////////////////////////////////////////////////////////////////////////// +bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element) +{ + //MESSAGE("registerElement " << ID); + if ((ID < myIDElements.size()) && myIDElements[ID] >= 0) // --- already bound + { + MESSAGE(" --------------------------------- already bound "<< ID << " " << myIDElements[ID]); + return false; + } + + element->myID = ID; + element->myMeshId = myMeshId; + + SMDS_MeshCell *cell = dynamic_cast(element); + MYASSERT(cell); + int vtkId = cell->getVtkId(); + if (vtkId == -1) + vtkId = myElementIDFactory->SetInVtkGrid(element); + + if (ID >= myIDElements.size()) // --- resize local vector + { + MESSAGE(" ------------------- resize myIDElements " << ID << " --> " << ID + SMDS_Mesh::chunkSize); + myIDElements.resize(ID + SMDS_Mesh::chunkSize, -1); // fill new elements with -1 + } + + myIDElements[ID] = vtkId; + //MESSAGE("smds:" << ID << " vtk:" << vtkId ); + + if (vtkId >= myVtkIndex.size()) // --- resize local vector + { + MESSAGE(" --------------------- resize myVtkIndex " << vtkId << " --> " << vtkId + SMDS_Mesh::chunkSize); + myVtkIndex.resize(vtkId + SMDS_Mesh::chunkSize, -1); + } + myVtkIndex[vtkId] = ID; + + myElementIDFactory->updateMinMax(ID); + return true; } /////////////////////////////////////////////////////////////////////////////// @@ -672,60 +1256,106 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID( /////////////////////////////////////////////////////////////////////////////// const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const { - return (const SMDS_MeshNode *)myNodeIDFactory->MeshElement(ID); + if (ID < 0 || ID >= myNodes.size()) + { + MESSAGE("----------------------------------- bad ID " << ID << " " << myNodes.size()); + return 0; + } + return (const SMDS_MeshNode *)myNodes[ID]; } /////////////////////////////////////////////////////////////////////////////// -///Create a triangle and add it to the current mesh. This methode do not bind a +///Create a triangle and add it to the current mesh. This method do not bind an ///ID to the create triangle. /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace * SMDS_Mesh::createTriangle(SMDS_MeshNode * node1, - SMDS_MeshNode * node2, SMDS_MeshNode * node3) -{ - if(hasConstructionEdges()) - { - SMDS_MeshEdge *edge1, *edge2, *edge3; - edge1=FindEdgeOrCreate(node1,node2); - edge2=FindEdgeOrCreate(node2,node3); - edge3=FindEdgeOrCreate(node3,node1); - - SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3); - myFaces.insert(face); - return face; - } - else - { - SMDS_MeshFace * face = new SMDS_Tria3OfNodes(node1,node2,node3); - myFaces.insert(face); - return face; - } +SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1, + const SMDS_MeshNode * node2, + const SMDS_MeshNode * node3, + int ID) +{ + if ( !node1 || !node2 || !node3) return 0; +// if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if(hasConstructionEdges()) + { + SMDS_MeshEdge *edge1, *edge2, *edge3; + edge1=FindEdgeOrCreate(node1,node2); + edge2=FindEdgeOrCreate(node2,node3); + edge3=FindEdgeOrCreate(node3,node1); + + //int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element + SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3); + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbTriangles++; + return face; + } + else + { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(node1->getId()); + nodeIds.push_back(node2->getId()); + nodeIds.push_back(node3->getId()); + + SMDS_MeshFace * face = 0; + SMDS_VtkFace *facevtk = myFacePool->getNew(); + facevtk->init(nodeIds, this); + face = facevtk; + adjustmyCellsCapacity(ID); + myCells[ID] = face; + //MESSAGE("createTriangle " << ID << " " << face); + myInfo.myNbTriangles++; + return face; + } } /////////////////////////////////////////////////////////////////////////////// ///Create a quadrangle and add it to the current mesh. This methode do not bind ///a ID to the create triangle. /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1, - SMDS_MeshNode * node2, SMDS_MeshNode * node3, SMDS_MeshNode * node4) -{ - if(hasConstructionEdges()) - { - SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4; - edge1=FindEdgeOrCreate(node1,node2); - edge2=FindEdgeOrCreate(node2,node3); - edge3=FindEdgeOrCreate(node3,node4); - edge4=FindEdgeOrCreate(node4,node1); - - SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4); - myFaces.insert(face); - return face; - } - else - { - SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4); - myFaces.insert(face); - return face; - } +SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1, + const SMDS_MeshNode * node2, + const SMDS_MeshNode * node3, + const SMDS_MeshNode * node4, + int ID) +{ + if ( !node1 || !node2 || !node3 || !node4 ) return 0; +// if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + if(hasConstructionEdges()) + { + //MESSAGE("createQuadrangle hasConstructionEdges "<< ID); + SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4; + edge1=FindEdgeOrCreate(node1,node2); + edge2=FindEdgeOrCreate(node2,node3); + edge3=FindEdgeOrCreate(node3,node4); + edge4=FindEdgeOrCreate(node4,node1); + + SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4); + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbQuadrangles++; + return face; + } + else + { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(node1->getId()); + nodeIds.push_back(node2->getId()); + nodeIds.push_back(node3->getId()); + nodeIds.push_back(node4->getId()); + + SMDS_MeshFace * face = 0; + SMDS_VtkFace *facevtk = myFacePool->getNew(); + facevtk->init(nodeIds, this); + face = facevtk; + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbQuadrangles++; + return face; + } } /////////////////////////////////////////////////////////////////////////////// @@ -734,7 +1364,18 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(SMDS_MeshNode * node1, void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) { - RemoveElement(node, true); + MESSAGE("RemoveNode"); + RemoveElement(node, true); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Remove an edge and all the elements which own this edge +/////////////////////////////////////////////////////////////////////////////// + +void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d) +{ + MESSAGE("Remove0DElement"); + RemoveElement(elem0d,true); } /////////////////////////////////////////////////////////////////////////////// @@ -743,7 +1384,8 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) { - RemoveElement(edge,true); + MESSAGE("RemoveEdge"); + RemoveElement(edge,true); } /////////////////////////////////////////////////////////////////////////////// @@ -752,7 +1394,8 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) { - RemoveElement(face, true); + MESSAGE("RemoveFace"); + RemoveElement(face, true); } /////////////////////////////////////////////////////////////////////////////// @@ -761,7 +1404,8 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) { - RemoveElement(volume, true); + MESSAGE("RemoveVolume"); + RemoveElement(volume, true); } //======================================================================= @@ -771,8 +1415,8 @@ void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) bool SMDS_Mesh::RemoveFromParent() { - if (myParent==NULL) return false; - else return (myParent->RemoveSubMesh(this)); + if (myParent==NULL) return false; + else return (myParent->RemoveSubMesh(this)); } //======================================================================= @@ -782,22 +1426,215 @@ bool SMDS_Mesh::RemoveFromParent() bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh) { - bool found = false; + bool found = false; + + list::iterator itmsh=myChildren.begin(); + for (; itmsh!=myChildren.end() && !found; itmsh++) + { + SMDS_Mesh * submesh = *itmsh; + if (submesh == aMesh) + { + found = true; + myChildren.erase(itmsh); + } + } + + return found; +} + +//======================================================================= +//function : ChangeElementNodes +//purpose : +//======================================================================= + +bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element, + const SMDS_MeshNode * nodes[], + const int nbnodes) +{ + MYASSERT(0); // REVOIR LES TYPES + // keep current nodes of elem + set oldNodes; + SMDS_ElemIteratorPtr itn = element->nodesIterator(); + while(itn->more()) + oldNodes.insert( itn->next() ); + + if ( !element->IsPoly() ) + myInfo.remove( element ); // element may change type + + // change nodes + bool Ok = false; + SMDS_MeshElement* elem = const_cast(element); + switch ( elem->GetType() ) + { + case SMDSAbs_0DElement: { + if ( SMDS_Mesh0DElement* elem0d = dynamic_cast( elem )) + Ok = elem0d->ChangeNode( nodes[0] ); + break; + } + case SMDSAbs_Edge: { + if ( nbnodes == 2 ) { + if ( SMDS_VtkEdge* edge = dynamic_cast( elem )) + Ok = edge->ChangeNodes( nodes[0], nodes[1] ); + } + else if ( nbnodes == 3 ) { + if ( SMDS_QuadraticEdge* edge = dynamic_cast( elem )) + Ok = edge->ChangeNodes( nodes[0], nodes[1], nodes[2] ); + } + break; + } + case SMDSAbs_Face: { + if ( SMDS_FaceOfNodes* face = dynamic_cast( elem )) + Ok = face->ChangeNodes( nodes, nbnodes ); + else + if ( SMDS_QuadraticFaceOfNodes* QF = dynamic_cast( elem )) + Ok = QF->ChangeNodes( nodes, nbnodes ); + else + if (SMDS_PolygonalFaceOfNodes* face = dynamic_cast(elem)) + Ok = face->ChangeNodes(nodes, nbnodes); + break; + } + case SMDSAbs_Volume: { + if ( SMDS_VolumeOfNodes* vol = dynamic_cast( elem )) + Ok = vol->ChangeNodes( nodes, nbnodes ); + else + if ( SMDS_QuadraticVolumeOfNodes* QV = dynamic_cast( elem )) + Ok = QV->ChangeNodes( nodes, nbnodes ); + break; + } + default: + MESSAGE ( "WRONG ELEM TYPE"); + } + + if ( Ok ) { // update InverseElements + + set::iterator it; + + // AddInverseElement to new nodes + for ( int i = 0; i < nbnodes; i++ ) { + it = oldNodes.find( nodes[i] ); + if ( it == oldNodes.end() ) + // new node + const_cast( nodes[i] )->AddInverseElement( elem ); + else + // remove from oldNodes a node that remains in elem + oldNodes.erase( it ); + } + // RemoveInverseElement from the nodes removed from elem + for ( it = oldNodes.begin(); it != oldNodes.end(); it++ ) + { + SMDS_MeshNode * n = static_cast + (const_cast( *it )); + n->RemoveInverseElement( elem ); + } + } + + if ( !element->IsPoly() ) + myInfo.add( element ); // element may change type + + return Ok; +} + +//======================================================================= +//function : ChangePolyhedronNodes +//purpose : to change nodes of polyhedral volume +//======================================================================= +bool SMDS_Mesh::ChangePolyhedronNodes (const SMDS_MeshElement * elem, + const vector& nodes, + const vector & quantities) +{ + if (elem->GetType() != SMDSAbs_Volume) { + MESSAGE("WRONG ELEM TYPE"); + return false; + } + + const SMDS_PolyhedralVolumeOfNodes* vol = dynamic_cast(elem); + if (!vol) { + return false; + } + + // keep current nodes of elem + set oldNodes; + SMDS_ElemIteratorPtr itn = elem->nodesIterator(); + while (itn->more()) { + oldNodes.insert(itn->next()); + } + + // change nodes + bool Ok = const_cast(vol)->ChangeNodes(nodes, quantities); + if (!Ok) { + return false; + } + + // update InverseElements + + // AddInverseElement to new nodes + int nbnodes = nodes.size(); + set::iterator it; + for (int i = 0; i < nbnodes; i++) { + it = oldNodes.find(nodes[i]); + if (it == oldNodes.end()) { + // new node + const_cast(nodes[i])->AddInverseElement(elem); + } else { + // remove from oldNodes a node that remains in elem + oldNodes.erase(it); + } + } + + // RemoveInverseElement from the nodes removed from elem + for (it = oldNodes.begin(); it != oldNodes.end(); it++) { + SMDS_MeshNode * n = static_cast + (const_cast( *it )); + n->RemoveInverseElement(elem); + } + + return Ok; +} - list::iterator itmsh=myChildren.begin(); - for (; itmsh!=myChildren.end() && !found; itmsh++) - { - SMDS_Mesh * submesh = *itmsh; - if (submesh == aMesh) - { - found = true; - myChildren.erase(itmsh); - } - } - return found; +//======================================================================= +//function : Find0DElement +//purpose : +//======================================================================= +const SMDS_Mesh0DElement* SMDS_Mesh::Find0DElement(int idnode) const +{ + const SMDS_MeshNode * node = FindNode(idnode); + if(node == NULL) return NULL; + return Find0DElement(node); } +const SMDS_Mesh0DElement* SMDS_Mesh::Find0DElement(const SMDS_MeshNode * node) +{ + if (!node) return 0; + const SMDS_Mesh0DElement* toReturn = NULL; + SMDS_ElemIteratorPtr it1 = node->GetInverseElementIterator(SMDSAbs_0DElement); + while (it1->more() && (toReturn == NULL)) { + const SMDS_MeshElement* e = it1->next(); + if (e->NbNodes() == 1) { + toReturn = static_cast(e); + } + } + return toReturn; +} + +//======================================================================= +//function : Find0DElementOrCreate +//purpose : +//======================================================================= +//SMDS_Mesh0DElement* SMDS_Mesh::Find0DElementOrCreate(const SMDS_MeshNode * node) +//{ +// if (!node) return 0; +// SMDS_Mesh0DElement * toReturn = NULL; +// toReturn = const_cast(Find0DElement(node)); +// if (toReturn == NULL) { +// //if (my0DElements.Extent() % CHECKMEMORY_INTERVAL == 0) CheckMemory(); +// toReturn = new SMDS_Mesh0DElement(node); +// my0DElements.Add(toReturn); +// myInfo.myNb0DElements++; +// } +// return toReturn; +//} + //======================================================================= //function : FindEdge @@ -806,287 +1643,494 @@ bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh) const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2) const { - const SMDS_MeshNode * node1=FindNode(idnode1); - const SMDS_MeshNode * node2=FindNode(idnode2); - if((node1==NULL)||(node2==NULL)) return NULL; - return FindEdge(node1,node2); + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + if((node1==NULL)||(node2==NULL)) return NULL; + return FindEdge(node1,node2); } -/////////////////////////////////////////////////////////////////////////////// -/// -/////////////////////////////////////////////////////////////////////////////// //#include "Profiler.h" const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1, - const SMDS_MeshNode * node2) const -{ - const SMDS_MeshEdge * toReturn=NULL; - //PROFILER_Init(); - //PROFILER_Set(); - SMDS_Iterator* it1=node1->edgesIterator(); - //PROFILER_Get(0); - //PROFILER_Set(); - while(it1->more()) - { - const SMDS_MeshEdge * e=static_cast - (it1->next()); - SMDS_Iterator* it2=e->nodesIterator(); - while(it2->more()) - { - if(it2->next()->GetID()==node2->GetID()) - { - toReturn=e; - break; - } - } - delete it2; - } - //PROFILER_Get(1); - delete it1; - return toReturn; + const SMDS_MeshNode * node2) +{ + if ( !node1 ) return 0; + const SMDS_MeshEdge * toReturn=NULL; + //PROFILER_Init(); + //PROFILER_Set(); + SMDS_ElemIteratorPtr it1=node1->GetInverseElementIterator(SMDSAbs_Edge); + //PROFILER_Get(0); + //PROFILER_Set(); + while(it1->more()) { + const SMDS_MeshElement * e = it1->next(); + if ( e->NbNodes() == 2 && e->GetNodeIndex( node2 ) >= 0 ) { + toReturn = static_cast( e ); + break; + } + } + //PROFILER_Get(1); + return toReturn; } +//======================================================================= +//function : FindEdgeOrCreate +//purpose : +//======================================================================= + SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1, - const SMDS_MeshNode * node2) -{ - SMDS_MeshEdge * toReturn=NULL; - toReturn=const_cast(FindEdge(node1,node2)); - if(toReturn==NULL) - { - toReturn=new SMDS_MeshEdge(const_cast(node1), - const_cast(node2)); - myEdges.insert(toReturn); - } - return toReturn; + const SMDS_MeshNode * node2) +{ + if ( !node1 || !node2) return 0; + SMDS_MeshEdge * toReturn=NULL; + toReturn=const_cast(FindEdge(node1,node2)); + if(toReturn==NULL) { + //if ( myEdges.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element + adjustmyCellsCapacity(ID); + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(node1->getId()); + nodeIds.push_back(node2->getId()); + + SMDS_VtkEdge *edgevtk = myEdgePool->getNew(); + edgevtk->init(nodeIds, this); + toReturn = edgevtk; + myCells[ID] = toReturn; + myInfo.myNbEdges++; + } + return toReturn; } + //======================================================================= -//function : FindFace +//function : FindEdge //purpose : //======================================================================= -const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, - int idnode3) const -{ - const SMDS_MeshNode * node1=FindNode(idnode1); - const SMDS_MeshNode * node2=FindNode(idnode2); - const SMDS_MeshNode * node3=FindNode(idnode3); - const SMDS_MeshFace * face; - const SMDS_MeshElement * node; - bool node2found, node3found; - if((node1==NULL)||(node2==NULL)||(node3==NULL)) return NULL; - - SMDS_Iterator* it1=node1->facesIterator(); - while(it1->more()) - { - face=static_cast(it1->next()); - if(face->NbNodes()!=3) continue; - SMDS_Iterator* it2=face->nodesIterator(); - node2found=false; - node3found=false; - while(it2->more()) - { - node=it2->next(); - if(node->GetID()==idnode2) node2found=true; - if(node->GetID()==idnode3) node3found=true; - } - delete it2; - if(node2found&&node3found) - { - delete it1; - return face; - } - } - delete it1; - return NULL; +const SMDS_MeshEdge* SMDS_Mesh::FindEdge(int idnode1, int idnode2, + int idnode3) const +{ + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + const SMDS_MeshNode * node3=FindNode(idnode3); + return FindEdge(node1,node2,node3); +} + +const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1, + const SMDS_MeshNode * node2, + const SMDS_MeshNode * node3) +{ + if ( !node1 ) return 0; + SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Edge); + while(it1->more()) { + const SMDS_MeshElement * e = it1->next(); + if ( e->NbNodes() == 3 ) { + SMDS_ElemIteratorPtr it2 = e->nodesIterator(); + while(it2->more()) { + const SMDS_MeshElement* n = it2->next(); + if( n!=node1 && + n!=node2 && + n!=node3 ) + { + e = 0; + break; + } + } + if ( e ) + return static_cast (e); + } + } + return 0; } + //======================================================================= //function : FindFace //purpose : //======================================================================= -const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, int idnode3, - int idnode4) const -{ - const SMDS_MeshNode * node1=FindNode(idnode1); - const SMDS_MeshNode * node2=FindNode(idnode2); - const SMDS_MeshNode * node3=FindNode(idnode3); - const SMDS_MeshNode * node4=FindNode(idnode4); - if((node1==NULL)||(node2==NULL)||(node3==NULL)||(node4==NULL)) return NULL; - return FindFace(node1, node2, node3, node4); -} - -const SMDS_MeshFace* SMDS_Mesh::FindFace( - const SMDS_MeshNode *node1, - const SMDS_MeshNode *node2, - const SMDS_MeshNode *node3, - const SMDS_MeshNode *node4) const -{ - const SMDS_MeshFace * face; - const SMDS_MeshElement * node; - bool node2found, node3found, node4found; - SMDS_Iterator* it1=node1->facesIterator(); - while(it1->more()) - { - face=static_cast(it1->next()); - if(face->NbNodes()!=4) continue; - SMDS_Iterator* it2=face->nodesIterator(); - node2found=false; - node3found=false; - node4found=false; - while(it2->more()) - { - node=it2->next(); - if(node->GetID()==node2->GetID()) node2found=true; - if(node->GetID()==node3->GetID()) node3found=true; - if(node->GetID()==node4->GetID()) node4found=true; - } - delete it2; - if(node2found&&node3found&&node4found) - { - delete it1; - return face; - } - } - delete it1; - return NULL; -} - -SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate( - const SMDS_MeshNode *node1, - const SMDS_MeshNode *node2, - const SMDS_MeshNode *node3, - const SMDS_MeshNode *node4) -{ - SMDS_MeshFace * toReturn=NULL; - toReturn=const_cast(FindFace(node1,node2,node3,node4)); - if(toReturn==NULL) - { - toReturn=createQuadrangle( - const_cast(node1), - const_cast(node2), - const_cast(node3), - const_cast(node4) - ); - } - return toReturn; +const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, + int idnode3) const +{ + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + const SMDS_MeshNode * node3=FindNode(idnode3); + return FindFace(node1, node2, node3); +} + +const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3) +{ + if ( !node1 ) return 0; + SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face); + while(it1->more()) { + const SMDS_MeshElement * e = it1->next(); + if ( e->NbNodes() == 3 ) { + SMDS_ElemIteratorPtr it2 = e->nodesIterator(); + while(it2->more()) { + const SMDS_MeshElement* n = it2->next(); + if( n!=node1 && + n!=node2 && + n!=node3 ) + { + e = 0; + break; + } + } + if ( e ) + return static_cast (e); + } + } + return 0; +} + +SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3) +{ + SMDS_MeshFace * toReturn=NULL; + toReturn = const_cast(FindFace(node1,node2,node3)); + if(toReturn==NULL) { + int ID = myElementIDFactory->GetFreeID(); + toReturn = createTriangle(node1,node2,node3, ID); + } + return toReturn; } + //======================================================================= -//function : FindElement +//function : FindFace //purpose : //======================================================================= -const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const -{ - return myElementIDFactory->MeshElement(IDelem); +const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, + int idnode3, int idnode4) const +{ + const SMDS_MeshNode * node1=FindNode(idnode1); + const SMDS_MeshNode * node2=FindNode(idnode2); + const SMDS_MeshNode * node3=FindNode(idnode3); + const SMDS_MeshNode * node4=FindNode(idnode4); + return FindFace(node1, node2, node3, node4); +} + +const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3, + const SMDS_MeshNode *node4) +{ + if ( !node1 ) return 0; + SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face); + while(it1->more()) { + const SMDS_MeshElement * e = it1->next(); + if ( e->NbNodes() == 4 ) { + SMDS_ElemIteratorPtr it2 = e->nodesIterator(); + while(it2->more()) { + const SMDS_MeshElement* n = it2->next(); + if( n!=node1 && + n!=node2 && + n!=node3 && + n!=node4 ) + { + e = 0; + break; + } + } + if ( e ) + return static_cast (e); + } + } + return 0; +} + +SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3, + const SMDS_MeshNode *node4) +{ + SMDS_MeshFace * toReturn=NULL; + toReturn=const_cast(FindFace(node1,node2,node3,node4)); + if(toReturn==NULL) { + int ID = myElementIDFactory->GetFreeID(); + toReturn=createQuadrangle(node1,node2,node3,node4,ID); + } + return toReturn; } + //======================================================================= -//function : DumpNodes -//purpose : +//function : FindFace +//purpose :quadratic triangle //======================================================================= -void SMDS_Mesh::DumpNodes() const -{ - MESSAGE("dump nodes of mesh : "); - SMDS_Iterator * itnode=nodesIterator(); - while(itnode->more()) MESSAGE(itnode->next()); - delete itnode; +const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, + int idnode3, int idnode4, + int idnode5, int idnode6) const +{ + const SMDS_MeshNode * node1 = FindNode(idnode1); + const SMDS_MeshNode * node2 = FindNode(idnode2); + const SMDS_MeshNode * node3 = FindNode(idnode3); + const SMDS_MeshNode * node4 = FindNode(idnode4); + const SMDS_MeshNode * node5 = FindNode(idnode5); + const SMDS_MeshNode * node6 = FindNode(idnode6); + return FindFace(node1, node2, node3, node4, node5, node6); +} + +const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3, + const SMDS_MeshNode *node4, + const SMDS_MeshNode *node5, + const SMDS_MeshNode *node6) +{ + if ( !node1 ) return 0; + SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face); + while(it1->more()) { + const SMDS_MeshElement * e = it1->next(); + if ( e->NbNodes() == 6 ) { + SMDS_ElemIteratorPtr it2 = e->nodesIterator(); + while(it2->more()) { + const SMDS_MeshElement* n = it2->next(); + if( n!=node1 && + n!=node2 && + n!=node3 && + n!=node4 && + n!=node5 && + n!=node6 ) + { + e = 0; + break; + } + } + if ( e ) + return static_cast (e); + } + } + return 0; } + //======================================================================= -//function : DumpEdges -//purpose : +//function : FindFace +//purpose : quadratic quadrangle //======================================================================= -void SMDS_Mesh::DumpEdges() const -{ - MESSAGE("dump edges of mesh : "); - SMDS_Iterator * itedge=edgesIterator(); - while(itedge->more()) MESSAGE(itedge->next()); - delete itedge; +const SMDS_MeshFace* SMDS_Mesh::FindFace(int idnode1, int idnode2, + int idnode3, int idnode4, + int idnode5, int idnode6, + int idnode7, int idnode8) const +{ + const SMDS_MeshNode * node1 = FindNode(idnode1); + const SMDS_MeshNode * node2 = FindNode(idnode2); + const SMDS_MeshNode * node3 = FindNode(idnode3); + const SMDS_MeshNode * node4 = FindNode(idnode4); + const SMDS_MeshNode * node5 = FindNode(idnode5); + const SMDS_MeshNode * node6 = FindNode(idnode6); + const SMDS_MeshNode * node7 = FindNode(idnode7); + const SMDS_MeshNode * node8 = FindNode(idnode8); + return FindFace(node1, node2, node3, node4, node5, node6, node7, node8); +} + +const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, + const SMDS_MeshNode *node2, + const SMDS_MeshNode *node3, + const SMDS_MeshNode *node4, + const SMDS_MeshNode *node5, + const SMDS_MeshNode *node6, + const SMDS_MeshNode *node7, + const SMDS_MeshNode *node8) +{ + if ( !node1 ) return 0; + SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face); + while(it1->more()) { + const SMDS_MeshElement * e = it1->next(); + if ( e->NbNodes() == 8 ) { + SMDS_ElemIteratorPtr it2 = e->nodesIterator(); + while(it2->more()) { + const SMDS_MeshElement* n = it2->next(); + if( n!=node1 && + n!=node2 && + n!=node3 && + n!=node4 && + n!=node5 && + n!=node6 && + n!=node7 && + n!=node8 ) + { + e = 0; + break; + } + } + if ( e ) + return static_cast (e); + } + } + return 0; } + //======================================================================= -//function : DumpFaces -//purpose : +//function : FindElement +//purpose : //======================================================================= -void SMDS_Mesh::DumpFaces() const +const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const { - MESSAGE("dump faces of mesh : "); - SMDS_Iterator * itface=facesIterator(); - while(itface->more()) MESSAGE(itface->next()); - delete itface; + if ((IDelem < 0) || IDelem >= myCells.size()) + { + MESSAGE("----------------------------------- bad IDelem " << IDelem << " " << myCells.size()); + assert(0); + return 0; + } + return myCells[IDelem]; } //======================================================================= -//function : DumpVolumes -//purpose : +//function : FindFace +//purpose : find polygon //======================================================================= -void SMDS_Mesh::DumpVolumes() const -{ - MESSAGE("dump volumes of mesh : "); - SMDS_Iterator * itvol=volumesIterator(); - while(itvol->more()) MESSAGE(itvol->next()); - delete itvol; +const SMDS_MeshFace* SMDS_Mesh::FindFace (std::vector nodes_ids) const +{ + int nbnodes = nodes_ids.size(); + std::vector poly_nodes (nbnodes); + for (int inode = 0; inode < nbnodes; inode++) { + const SMDS_MeshNode * node = FindNode(nodes_ids[inode]); + if (node == NULL) return NULL; + poly_nodes[inode] = node; + } + return FindFace(poly_nodes); +} + +const SMDS_MeshFace* SMDS_Mesh::FindFace (std::vector nodes) +{ + if ( nodes.size() > 2 && nodes[0] ) { + SMDS_ElemIteratorPtr itF = nodes[0]->GetInverseElementIterator(SMDSAbs_Face); + while (itF->more()) { + const SMDS_MeshElement* f = itF->next(); + if ( f->NbNodes() == nodes.size() ) { + SMDS_ElemIteratorPtr it2 = f->nodesIterator(); + while(it2->more()) { + if ( find( nodes.begin(), nodes.end(), it2->next() ) == nodes.end() ) { + f = 0; + break; + } + } + if ( f ) + return static_cast (f); + } + } + } + return NULL; +} + +//======================================================================= +//function : DumpNodes +//purpose : +//======================================================================= + +void SMDS_Mesh::DumpNodes() const +{ + MESSAGE("dump nodes of mesh : "); + SMDS_NodeIteratorPtr itnode=nodesIterator(); + while(itnode->more()) ; //MESSAGE(itnode->next()); +} + +//======================================================================= +//function : Dump0DElements +//purpose : +//======================================================================= +void SMDS_Mesh::Dump0DElements() const +{ + MESSAGE("dump 0D elements of mesh : "); + SMDS_0DElementIteratorPtr it0d = elements0dIterator(); + while(it0d->more()) ; //MESSAGE(it0d->next()); +} + +//======================================================================= +//function : DumpEdges +//purpose : +//======================================================================= + +void SMDS_Mesh::DumpEdges() const +{ + MESSAGE("dump edges of mesh : "); + SMDS_EdgeIteratorPtr itedge=edgesIterator(); + while(itedge->more()) ; //MESSAGE(itedge->next()); +} + +//======================================================================= +//function : DumpFaces +//purpose : +//======================================================================= + +void SMDS_Mesh::DumpFaces() const +{ + MESSAGE("dump faces of mesh : "); + SMDS_FaceIteratorPtr itface=facesIterator(); + while(itface->more()) ; //MESSAGE(itface->next()); +} + +//======================================================================= +//function : DumpVolumes +//purpose : +//======================================================================= + +void SMDS_Mesh::DumpVolumes() const +{ + MESSAGE("dump volumes of mesh : "); + SMDS_VolumeIteratorPtr itvol=volumesIterator(); + while(itvol->more()) ; //MESSAGE(itvol->next()); } //======================================================================= //function : DebugStats -//purpose : +//purpose : //======================================================================= void SMDS_Mesh::DebugStats() const { - MESSAGE("Debug stats of mesh : "); + MESSAGE("Debug stats of mesh : "); + + MESSAGE("===== NODES ====="< * itnode=nodesIterator(); - int sizeofnodes = 0; - int sizeoffaces = 0; + SMDS_NodeIteratorPtr itnode=nodesIterator(); + int sizeofnodes = 0; + int sizeoffaces = 0; - while(itnode->more()) - { - const SMDS_MeshNode *node = itnode->next(); + while(itnode->more()) + { + const SMDS_MeshNode *node = itnode->next(); - sizeofnodes += sizeof(*node); - - SMDS_Iterator * it= - node->GetInverseElementIterator(); - while(it->more()) - { - const SMDS_MeshElement *me = it->next(); - sizeofnodes += sizeof(me); - } - delete it; + sizeofnodes += sizeof(*node); - } - delete itnode; - SMDS_Iterator* itface=facesIterator(); - - while(itface->more()) - { - const SMDS_MeshElement *face = itface->next(); - sizeoffaces += sizeof(*face); + SMDS_ElemIteratorPtr it = node->GetInverseElementIterator(); + while(it->more()) + { + const SMDS_MeshElement *me = it->next(); + sizeofnodes += sizeof(me); + } + } - } - MESSAGE("total size of node elements = " << sizeofnodes);; - MESSAGE("total size of face elements = " << sizeoffaces);; + SMDS_FaceIteratorPtr itface=facesIterator(); + while(itface->more()) + { + const SMDS_MeshElement *face = itface->next(); + sizeoffaces += sizeof(*face); + } - //#endif + MESSAGE("total size of node elements = " << sizeofnodes);; + MESSAGE("total size of face elements = " << sizeoffaces);; + //#endif } /////////////////////////////////////////////////////////////////////////////// @@ -1094,7 +2138,18 @@ void SMDS_Mesh::DebugStats() const /////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbNodes() const { - return myNodes.size(); + //MESSAGE(myGrid->GetNumberOfPoints()); + //MESSAGE(myInfo.NbNodes()); + //MESSAGE(myNodeMax); + return myInfo.NbNodes(); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Return the number of 0D elements +/////////////////////////////////////////////////////////////////////////////// +int SMDS_Mesh::Nb0DElements() const +{ + return myInfo.Nb0DElements(); // -PR- a verfier } /////////////////////////////////////////////////////////////////////////////// @@ -1102,7 +2157,7 @@ int SMDS_Mesh::NbNodes() const /////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbEdges() const { - return myEdges.size(); + return myInfo.NbEdges(); // -PR- a verfier } /////////////////////////////////////////////////////////////////////////////// @@ -1110,7 +2165,7 @@ int SMDS_Mesh::NbEdges() const /////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbFaces() const { - return myFaces.size(); + return myInfo.NbFaces(); // -PR- a verfier } /////////////////////////////////////////////////////////////////////////////// @@ -1118,7 +2173,7 @@ int SMDS_Mesh::NbFaces() const /////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbVolumes() const { - return myVolumes.size(); + return myInfo.NbVolumes(); // -PR- a verfier } /////////////////////////////////////////////////////////////////////////////// @@ -1128,7 +2183,7 @@ int SMDS_Mesh::NbVolumes() const /////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbSubMesh() const { - return myChildren.size(); + return myChildren.size(); } /////////////////////////////////////////////////////////////////////////////// @@ -1137,47 +2192,130 @@ int SMDS_Mesh::NbSubMesh() const /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::~SMDS_Mesh() { - if(myParent==NULL) - { - delete myNodeIDFactory; - delete myElementIDFactory; - } - - list::iterator itc=myChildren.begin(); - while(itc!=myChildren.end()) - { - delete *itc; - itc++; - } - - SMDS_Iterator * itn=nodesIterator(); - while(itn->more()) - { - delete itn->next(); - } - delete itn; - - set::iterator ite=myEdges.begin(); - while(ite!=myEdges.end()) - { - delete *ite; - ite++; - } - - set::iterator itf=myFaces.begin(); - while(itf!=myFaces.end()) - { - delete *itf; - itf++; - } - - set::iterator itv=myVolumes.begin(); - while(itv!=myVolumes.end()) - { - delete *itv; - itv++; - } - + list::iterator itc=myChildren.begin(); + while(itc!=myChildren.end()) + { + delete *itc; + itc++; + } + + if(myParent==NULL) + { + delete myNodeIDFactory; + delete myElementIDFactory; + } + else + { + SMDS_ElemIteratorPtr eIt = elementsIterator(); + while ( eIt->more() ) + myElementIDFactory->ReleaseID(eIt->next()->GetID()); + SMDS_NodeIteratorPtr itn = nodesIterator(); + while (itn->more()) + myNodeIDFactory->ReleaseID(itn->next()->GetID()); + } + +// SetOfNodes::Iterator itn(myNodes); +// for (; itn.More(); itn.Next()) +// delete itn.Value(); + +// SetOf0DElements::Iterator it0d (my0DElements); +// for (; it0d.More(); it0d.Next()) +// { +// SMDS_MeshElement* elem = it0d.Value(); +// delete elem; +// } + +// SetOfEdges::Iterator ite(myEdges); +// for (; ite.More(); ite.Next()) +// { +// SMDS_MeshElement* elem = ite.Value(); +// delete elem; +// } + +// SetOfFaces::Iterator itf(myFaces); +// for (; itf.More(); itf.Next()) +// { +// SMDS_MeshElement* elem = itf.Value(); +// delete elem; +// } + +// SetOfVolumes::Iterator itv(myVolumes); +// for (; itv.More(); itv.Next()) +// { +// SMDS_MeshElement* elem = itv.Value(); +// delete elem; +// } +} + +//================================================================================ +/*! + * \brief Clear all data + */ +//================================================================================ + +void SMDS_Mesh::Clear() +{ + if (myParent!=NULL) + { + SMDS_ElemIteratorPtr eIt = elementsIterator(); + while ( eIt->more() ) + myElementIDFactory->ReleaseID(eIt->next()->GetID()); + SMDS_NodeIteratorPtr itn = nodesIterator(); + while (itn->more()) + myNodeIDFactory->ReleaseID(itn->next()->GetID()); + } + else + { + myNodeIDFactory->Clear(); + myElementIDFactory->Clear(); + } + + SMDS_ElemIteratorPtr itv = elementsIterator(); + while (itv->more()) + { + SMDS_MeshElement* elem = (SMDS_MeshElement*)(itv->next()); + SMDSAbs_ElementType aType = elem->GetType(); + switch (aType) + { + case SMDSAbs_0DElement: + delete elem; + break; + case SMDSAbs_Edge: + myEdgePool->destroy(static_cast(elem)); + break; + case SMDSAbs_Face: + myFacePool->destroy(static_cast(elem)); + break; + case SMDSAbs_Volume: + myVolumePool->destroy(static_cast(elem)); + break; + default: + break; + } + } + myCells.clear(); + + SMDS_NodeIteratorPtr itn = nodesIterator(); + while (itn->more()) + { + SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next()); + myNodePool->destroy(node); + } + myNodes.clear(); + + list::iterator itc=myChildren.begin(); + while(itc!=myChildren.end()) + (*itc)->Clear(); + + myInfo.Clear(); + + myGrid->Initialize(); + myGrid->Allocate(); + vtkPoints* points = vtkPoints::New(); + points->SetNumberOfPoints(SMDS_Mesh::chunkSize); + myGrid->SetPoints( points ); + points->Delete(); + myGrid->BuildLinks(); } /////////////////////////////////////////////////////////////////////////////// @@ -1187,7 +2325,7 @@ SMDS_Mesh::~SMDS_Mesh() /////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::hasConstructionEdges() { - return myHasConstructionEdges; + return myHasConstructionEdges; } /////////////////////////////////////////////////////////////////////////////// @@ -1199,7 +2337,7 @@ bool SMDS_Mesh::hasConstructionEdges() /////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::hasConstructionFaces() { - return myHasConstructionFaces; + return myHasConstructionFaces; } /////////////////////////////////////////////////////////////////////////////// @@ -1208,7 +2346,7 @@ bool SMDS_Mesh::hasConstructionFaces() /////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::hasInverseElements() { - return myHasInverseElements; + return myHasInverseElements; } /////////////////////////////////////////////////////////////////////////////// @@ -1217,7 +2355,7 @@ bool SMDS_Mesh::hasInverseElements() /////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::setConstructionEdges(bool b) { - myHasConstructionEdges=b; + myHasConstructionEdges=b; } /////////////////////////////////////////////////////////////////////////////// @@ -1226,7 +2364,7 @@ void SMDS_Mesh::setConstructionEdges(bool b) /////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::setConstructionFaces(bool b) { - myHasConstructionFaces=b; + myHasConstructionFaces=b; } /////////////////////////////////////////////////////////////////////////////// @@ -1235,285 +2373,309 @@ void SMDS_Mesh::setConstructionFaces(bool b) /////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::setInverseElements(bool b) { - if(!b) MESSAGE("Error : inverseElement=false not implemented"); - myHasInverseElements=b; -} - -/////////////////////////////////////////////////////////////////////////////// -/// 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 -{ - class MyIterator:public SMDS_Iterator - { - const SetOfNodes& mySet; - SetOfNodes::iterator myIterator; - public: - MyIterator(const SetOfNodes& s):mySet(s) - { - myIterator=mySet.begin(); - } - - bool more() - { - return myIterator!=mySet.end(); - } - - const SMDS_MeshNode* next() - { - const SMDS_MeshNode* current=*myIterator; - myIterator++; - return current; - } - }; - return new MyIterator(myNodes); -} - -/////////////////////////////////////////////////////////////////////////////// -///Return an iterator on egdes of the current mesh. Once used this iterator -///must be free by the caller -/////////////////////////////////////////////////////////////////////////////// -SMDS_Iterator * SMDS_Mesh::edgesIterator() const -{ - class MyIterator:public SMDS_Iterator - { - const SetOfEdges& mySet; - const SMDS_MeshEdge * myEdge; - SetOfEdges::iterator myIterator; - public: - MyIterator(const SetOfEdges& s):mySet(s) - { - myIterator=mySet.begin(); - } - - bool more() - { - while((myIterator!=mySet.end())) - { - if((*myIterator)->GetID()!=-1) - return true; - myIterator++; - } - return false; - } - - const SMDS_MeshEdge* next() - { - const SMDS_MeshEdge* current=*myIterator; - myIterator++; - return current; - } - }; - return new MyIterator(myEdges); -} - -/////////////////////////////////////////////////////////////////////////////// -///Return an iterator on faces of the current mesh. Once used this iterator -///must be free by the caller -/////////////////////////////////////////////////////////////////////////////// -SMDS_Iterator * SMDS_Mesh::facesIterator() const -{ - class MyIterator:public SMDS_Iterator - { - const SetOfFaces& mySet; - set::iterator myIterator; - public: - MyIterator(const SetOfFaces& s):mySet(s) - { - myIterator=mySet.begin(); - } - - bool more() - { - while((myIterator!=mySet.end())) - { - if((*myIterator)->GetID()!=-1) - return true; - myIterator++; - } - return false; - } - - const SMDS_MeshFace* next() - { - const SMDS_MeshFace* current=*myIterator; - myIterator++; - return current; - } - }; - return new MyIterator(myFaces); -} - -/////////////////////////////////////////////////////////////////////////////// -///Return an iterator on volumes of the current mesh. Once used this iterator -///must be free by the caller -/////////////////////////////////////////////////////////////////////////////// -SMDS_Iterator * SMDS_Mesh::volumesIterator() const -{ - class MyIterator:public SMDS_Iterator - { - const SetOfVolumes& mySet; - SetOfVolumes::iterator myIterator; - public: - MyIterator(const SetOfVolumes& s):mySet(s) - { - myIterator=mySet.begin(); - } - - bool more() - { - return myIterator!=mySet.end(); - } - - const SMDS_MeshVolume* next() - { - const SMDS_MeshVolume* current=*myIterator; - myIterator++; - return current; - } - }; - return new MyIterator(myVolumes); + if(!b) MESSAGE("Error : inverseElement=false not implemented"); + myHasInverseElements=b; +} + +/////////////////////////////////////////////////////////////////////////////// +///Iterator on NCollection_Map +/////////////////////////////////////////////////////////////////////////////// +template +struct MYNode_Map_Iterator: public FATHER +{ + int _ctr; + const MAP& _map; + MYNode_Map_Iterator(const MAP& map): _map(map) // map is a std::vector + { + _ctr = 0; + } + + bool more() + { + while (_ctr < _map.size()) + { + if (_map[_ctr]) + return true; + _ctr++; + } + return false; + } + + ELEM next() + { + ELEM current = _map[_ctr]; + _ctr++; + return current; + } +}; + +template +struct MYElem_Map_Iterator: public FATHER +{ + int _ctr; + int _type; + const MAP& _map; + MYElem_Map_Iterator(const MAP& map, int typ): _map(map) // map is a std::vector + { + _ctr = 0; + _type = typ; + } + + bool more() + { + while (_ctr < _map.size()) + { + if (_map[_ctr]) + if ( (_type == SMDSAbs_All) || (_map[_ctr]->GetType() == _type)) + return true; + _ctr++; + } + return false; + } + + ELEM next() + { + ELEM current = dynamic_cast (_map[_ctr]); + _ctr++; + return current; + } +}; + +/////////////////////////////////////////////////////////////////////////////// +/// Return an iterator on nodes of the current mesh factory +/////////////////////////////////////////////////////////////////////////////// + +SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator() const +{ + //return SMDS_NodeIteratorPtr + // (new SMDS_Mesh_MyNodeIterator(myNodeIDFactory->elementsIterator())); + typedef MYNode_Map_Iterator + < SetOfNodes, const SMDS_MeshNode*, SMDS_NodeIterator > TIterator; + return SMDS_NodeIteratorPtr(new TIterator(myNodes)); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on 0D elements of the current mesh. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_0DElementIteratorPtr SMDS_Mesh::elements0dIterator() const +{ + typedef MYElem_Map_Iterator + < SetOfCells, const SMDS_Mesh0DElement*, SMDS_0DElementIterator > TIterator; + return SMDS_0DElementIteratorPtr(new TIterator(myCells, SMDSAbs_0DElement)); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on edges of the current mesh. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const +{ + typedef MYElem_Map_Iterator + < SetOfCells, const SMDS_MeshEdge*, SMDS_EdgeIterator > TIterator; + return SMDS_EdgeIteratorPtr(new TIterator(myCells, SMDSAbs_Edge)); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on faces of the current mesh. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const +{ + typedef MYElem_Map_Iterator + < SetOfCells, const SMDS_MeshFace*, SMDS_FaceIterator > TIterator; + return SMDS_FaceIteratorPtr(new TIterator(myCells, SMDSAbs_Face)); +} + +/////////////////////////////////////////////////////////////////////////////// +///Return an iterator on volumes of the current mesh. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator() const +{ + typedef MYElem_Map_Iterator + < SetOfCells, const SMDS_MeshVolume*, SMDS_VolumeIterator > TIterator; + return SMDS_VolumeIteratorPtr(new TIterator(myCells, SMDSAbs_Volume)); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Return an iterator on elements of the current mesh factory +/////////////////////////////////////////////////////////////////////////////// +SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const +{ + switch (type) { + case SMDSAbs_All: + return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_All)); + break; + case SMDSAbs_Volume: + return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_Volume)); + case SMDSAbs_Face: + return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_Face)); + case SMDSAbs_Edge: + return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_Edge)); + case SMDSAbs_0DElement: + return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_0DElement)); + case SMDSAbs_Node: + return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfNodes >(myNodes, SMDSAbs_All)); + //return myNodeIDFactory->elementsIterator(); + default:; + } + return myElementIDFactory->elementsIterator(); } /////////////////////////////////////////////////////////////////////////////// /// Do intersection of sets (more than 2) /////////////////////////////////////////////////////////////////////////////// -set * intersectionOfSets( - set vs[], int numberOfSets) +static set * intersectionOfSets( + set vs[], int numberOfSets) { - set* rsetA=new set(vs[0]); - set* rsetB; + 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; + 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 +/// Return the list of finite elements owning the given element: elements +/// containing all the nodes of the given element, for instance faces and +/// volumes containing a given edge. /////////////////////////////////////////////////////////////////////////////// -set * getFinitElements(const SMDS_MeshElement * element) +static set * getFinitElements(const SMDS_MeshElement * element) { - int numberOfSets=element->NbNodes(); - set initSet[numberOfSets]; + int numberOfSets=element->NbNodes(); + set *initSet = new set[numberOfSets]; + + SMDS_ElemIteratorPtr itNodes=element->nodesIterator(); - SMDS_Iterator * itNodes=element->nodesIterator(); + int i=0; + while(itNodes->more()) + { + const SMDS_MeshElement* node = itNodes->next(); + MYASSERT(node); + const SMDS_MeshNode * n=static_cast(node); + SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); - 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()) + { + const SMDS_MeshElement* elem = itFe->next(); + MYASSERT(elem); + initSet[i].insert(elem); - //initSet[i]=set(); - while(itFe->more()) initSet[i].insert(itFe->next()); + } - i++; - delete itFe; - } - delete itNodes; - - return intersectionOfSets(initSet, numberOfSets); + i++; + } + set *retSet=intersectionOfSets(initSet, numberOfSets); + MESSAGE("nb elems " << i << " intersection " << retSet->size()); + delete [] initSet; + return retSet; } /////////////////////////////////////////////////////////////////////////////// /// 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 +static set * getExclusiveNodes( + set& elements) +{ + set * toReturn=new set(); + set::iterator itElements=elements.begin(); + + while(itElements!=elements.end()) + { + SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator(); + itElements++; + + while(itNodes->more()) + { + const SMDS_MeshNode * n=static_cast(itNodes->next()); + SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); + set s; + while(itFe->more()) + s.insert(itFe->next()); + if(s==elements) toReturn->insert(n); + } + } + 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; - } - } - } +void SMDS_Mesh::addChildrenWithNodes(set& setOfChildren, + const SMDS_MeshElement * element, + set& nodes) +{ + switch(element->GetType()) + { + case SMDSAbs_Node: + MESSAGE("Internal Error: This should not happend"); + break; + case SMDSAbs_0DElement: + { + } + break; + case SMDSAbs_Edge: + { + SMDS_ElemIteratorPtr itn=element->nodesIterator(); + while(itn->more()) + { + const SMDS_MeshElement * e=itn->next(); + if(nodes.find(e)!=nodes.end()) + { + setOfChildren.insert(element); + break; + } + } + } break; + case SMDSAbs_Face: + { + SMDS_ElemIteratorPtr itn=element->nodesIterator(); + while(itn->more()) + { + const SMDS_MeshElement * e=itn->next(); + if(nodes.find(e)!=nodes.end()) + { + setOfChildren.insert(element); + break; + } + } + if(hasConstructionEdges()) + { + SMDS_ElemIteratorPtr ite=element->edgesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + } + } break; + case SMDSAbs_Volume: + { + if(hasConstructionFaces()) + { + SMDS_ElemIteratorPtr ite=element->facesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + } + else if(hasConstructionEdges()) + { + SMDS_ElemIteratorPtr ite=element->edgesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + } + } + } } /////////////////////////////////////////////////////////////////////////////// @@ -1521,179 +2683,1128 @@ void SMDS_Mesh::addChildrenWithNodes(set& setOfChildren ///@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; -} - -/** - * Concat the coordinates of all nodes in an array. - * Its used to display the mesh. - * @return A array of size 3*NbNodes() containing the coordinates of nodes. - */ -double * SMDS_Mesh::getNodesCoordinates() -{ - double * toReturn=new double[3*NbNodes()]; - SMDS_Iterator * it=nodesIterator(); - int i=0; - while(it->more()) - { - const SMDS_MeshNode * n=it->next(); - toReturn[i]=n->X(); - i++; - toReturn[i]=n->Y(); - i++; - toReturn[i]=n->Z(); - i++; - } - delete it; - return toReturn; -} - -/** - * Concat the id of all nodes in an array. - * Its used to display the mesh. - * @return A array of size NbNodes() containing the ids of nodes. - */ -long * SMDS_Mesh::getNodesID() -{ - long * toReturn=new long[NbNodes()]; - SMDS_Iterator * it=nodesIterator(); - int i=0; - while(it->more()) - { - const SMDS_MeshNode * n=it->next(); - toReturn[i]=n->GetID(); - i++; - } - delete it; - return toReturn; -} - -/** - * Concat the id of nodes of edges in an array. - * Array format is {edge_id, node1_id, node2_id} - * Its used to display the mesh. - * @return A array of size 3*NbEdges() containing the edges. - */ -long * SMDS_Mesh::getEdgesIndices() -{ - long * toReturn=new long[NbEdges()*3]; - SMDS_Iterator * it=edgesIterator(); - int i=0; - - while(it->more()) - { - const SMDS_MeshEdge * e=it->next(); - toReturn[i]=e->GetID(); - i++; - SMDS_Iterator * itn=e->nodesIterator(); - while(itn->more()) - { - const SMDS_MeshElement * n=itn->next(); - toReturn[i]=n->GetID(); - i++; - } - delete itn; - } - delete it; - return toReturn; -} - -/** - * Concat the id of nodes of triangles in an array. - * Array format is {tria_id, node1_id, node2_id, node3_id} - * Its used to display the mesh. - * @return A array of size 4*NbTriangles() containing the edges. - */ -long * SMDS_Mesh::getTrianglesIndices() -{ - long * toReturn=new long[NbTriangles()*4]; - SMDS_Iterator * it=facesIterator(); - int i=0; - while(it->more()) - { - const SMDS_MeshFace * f=it->next(); - if(f->NbNodes()==3) - { - toReturn[i]=f->GetID(); - i++; - SMDS_Iterator * itn=f->nodesIterator(); - while(itn->more()) - { - const SMDS_MeshElement * n=itn->next(); - toReturn[i]=n->GetID(); - i++; - } - delete itn; - } - } - delete it; - return toReturn; -} - -/** - * Return the number of 3 nodes faces in the mesh. - * This method run in O(n). - * @return The number of face whose number of nodes is 3 + const bool removenodes) +{ + list removedElems; + list removedNodes; + RemoveElement( elem, removedElems, removedNodes, removenodes ); +} + +/////////////////////////////////////////////////////////////////////////////// +///@param elem The element to delete +///@param removedElems to be filled with all removed elements +///@param removedNodes to be filled with all removed nodes +///@param removenodes if true remaining nodes will be removed +/////////////////////////////////////////////////////////////////////////////// +void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, + list& removedElems, + list& removedNodes, + bool removenodes) +{ + //MESSAGE("SMDS_Mesh::RemoveElement " << elem->GetID() << " " << removenodes); + // get finite elements built on elem + set * s1; + if (elem->GetType() == SMDSAbs_0DElement || + elem->GetType() == SMDSAbs_Edge && !hasConstructionEdges() || + elem->GetType() == SMDSAbs_Face && !hasConstructionFaces() || + elem->GetType() == SMDSAbs_Volume) + { + s1 = new set(); + s1->insert(elem); + } + else + s1 = getFinitElements(elem); + + // get exclusive nodes (which would become free afterwards) + set * s2; + if (elem->GetType() == SMDSAbs_Node) // a node is removed + { + // do not remove nodes except elem + s2 = new set(); + s2->insert(elem); + removenodes = true; + } + else + s2 = getExclusiveNodes(*s1); + + // form the set of finite and construction elements to remove + 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); + + // remove finite and construction elements + it=s3.begin(); + while(it!=s3.end()) + { + // Remove element from of its nodes + SMDS_ElemIteratorPtr itn=(*it)->nodesIterator(); + while(itn->more()) + { + SMDS_MeshNode * n = static_cast + (const_cast(itn->next())); + n->RemoveInverseElement( (*it) ); + } + + switch((*it)->GetType()) + { + case SMDSAbs_Node: + MYASSERT("Internal Error: This should not happen"); + break; + case SMDSAbs_0DElement: + myCells[(*it)->GetID()] = 0; // -PR- ici ou dans myElementIDFactory->ReleaseID ? + myInfo.remove(*it); + removedElems.push_back( (*it) ); + myElementIDFactory->ReleaseID((*it)->GetID()); + delete (*it); + break; + case SMDSAbs_Edge: + myCells[(*it)->GetID()] = 0; + myInfo.RemoveEdge(*it); + removedElems.push_back( (*it) ); + myElementIDFactory->ReleaseID((*it)->GetID()); + if (const SMDS_VtkEdge* vtkElem = dynamic_cast(*it)) + myEdgePool->destroy((SMDS_VtkEdge*)vtkElem); + else delete (*it); + break; + case SMDSAbs_Face: + myCells[(*it)->GetID()] = 0; + myInfo.RemoveFace(*it); + removedElems.push_back( (*it) ); + myElementIDFactory->ReleaseID((*it)->GetID()); + if (const SMDS_VtkFace* vtkElem = dynamic_cast(*it)) + myFacePool->destroy((SMDS_VtkFace*)vtkElem); + else delete (*it); + break; + case SMDSAbs_Volume: + myCells[(*it)->GetID()] = 0; + myInfo.RemoveVolume(*it); + removedElems.push_back( (*it) ); + myElementIDFactory->ReleaseID((*it)->GetID()); + if (const SMDS_VtkVolume* vtkElem = dynamic_cast(*it)) + myVolumePool->destroy((SMDS_VtkVolume*)vtkElem); + else delete (*it); + break; + } + it++; + } + + // remove exclusive (free) nodes + if(removenodes) + { + it=s2->begin(); + while(it!=s2->end()) + { + //MESSAGE( "SMDS: RM node " << (*it)->GetID() ); + myNodes[(*it)->GetID()] = 0; + myInfo.myNbNodes--; + myNodeIDFactory->ReleaseID((*it)->GetID()); + removedNodes.push_back( (*it) ); + if (const SMDS_MeshNode* vtkElem = dynamic_cast(*it)) + myNodePool->destroy((SMDS_MeshNode*)vtkElem); + else delete (*it); + it++; + } + } + + delete s2; + delete s1; +} + + +/////////////////////////////////////////////////////////////////////////////// +///@param elem The element to delete +/////////////////////////////////////////////////////////////////////////////// +void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) +{ + int elemId = elem->GetID(); + //MESSAGE("SMDS_Mesh::RemoveFreeElement " << elemId); + SMDSAbs_ElementType aType = elem->GetType(); + SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem); + if (aType == SMDSAbs_Node) { + // only free node can be removed by this method + const SMDS_MeshNode* n = static_cast(todest); + SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); + if (!itFe->more()) { // free node + myNodes[elemId] = 0; + myInfo.myNbNodes--; + myNodePool->destroy(static_cast(todest)); + myNodeIDFactory->ReleaseID(elemId); + } + } else { + if (hasConstructionEdges() || hasConstructionFaces()) + // this methods is only for meshes without descendants + return; + + int vtkid = this->fromSmdsToVtk(elemId); + + // Remove element from of its nodes + SMDS_ElemIteratorPtr itn = elem->nodesIterator(); + while (itn->more()) { + SMDS_MeshNode * n = static_cast + (const_cast(itn->next())); + n->RemoveInverseElement(elem); + } + + // in meshes without descendants elements are always free + switch (aType) { + case SMDSAbs_0DElement: + myCells[elemId] = 0; + myInfo.remove(elem); + delete elem; + break; + case SMDSAbs_Edge: + myCells[elemId] = 0; + myInfo.RemoveEdge(elem); + myEdgePool->destroy(static_cast(todest)); + break; + case SMDSAbs_Face: + myCells[elemId] = 0; + myInfo.RemoveFace(elem); + myFacePool->destroy(static_cast(todest)); + break; + case SMDSAbs_Volume: + myCells[elemId] = 0; + myInfo.RemoveVolume(elem); + myVolumePool->destroy(static_cast(todest)); + break; + default: + break; + } + myElementIDFactory->ReleaseID(elemId); + + this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); + // --- to do: keep vtkid in a list of reusable cells + } +} + +/*! + * Checks if the element is present in mesh. + * Useful to determine dead pointers. */ -int SMDS_Mesh::NbTriangles() const -{ - SMDS_Iterator * it=facesIterator(); - int toReturn=0; - while(it->more()) - { - const SMDS_MeshFace * f=it->next(); - if(f->NbNodes()==3) toReturn++; - } - return toReturn; +bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const +{ + // we should not imply on validity of *elem, so iterate on containers + // of all types in the hope of finding somewhere there + SMDS_NodeIteratorPtr itn = nodesIterator(); + while (itn->more()) + if (elem == itn->next()) + return true; + SMDS_0DElementIteratorPtr it0d = elements0dIterator(); + while (it0d->more()) + if (elem == it0d->next()) + return true; + SMDS_EdgeIteratorPtr ite = edgesIterator(); + while (ite->more()) + if (elem == ite->next()) + return true; + SMDS_FaceIteratorPtr itf = facesIterator(); + while (itf->more()) + if (elem == itf->next()) + return true; + SMDS_VolumeIteratorPtr itv = volumesIterator(); + while (itv->more()) + if (elem == itv->next()) + return true; + return false; +} + +//======================================================================= +//function : MaxNodeID +//purpose : +//======================================================================= + +int SMDS_Mesh::MaxNodeID() const +{ + return myNodeMax; +} + +//======================================================================= +//function : MinNodeID +//purpose : +//======================================================================= + +int SMDS_Mesh::MinNodeID() const +{ + return myNodeMin; +} + +//======================================================================= +//function : MaxElementID +//purpose : +//======================================================================= + +int SMDS_Mesh::MaxElementID() const +{ + return myElementIDFactory->GetMaxID(); +} + +//======================================================================= +//function : MinElementID +//purpose : +//======================================================================= + +int SMDS_Mesh::MinElementID() const +{ + return myElementIDFactory->GetMinID(); +} + +//======================================================================= +//function : Renumber +//purpose : Renumber all nodes or elements. +//======================================================================= + +void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID) +{ + MESSAGE("Renumber"); + if ( deltaID == 0 ) + return; + + SMDS_MeshNodeIDFactory * idFactory = + isNodes ? myNodeIDFactory : myElementIDFactory; + + // get existing elements in the order of ID increasing + map elemMap; + SMDS_ElemIteratorPtr idElemIt = idFactory->elementsIterator(); + while ( idElemIt->more() ) { + SMDS_MeshElement* elem = const_cast(idElemIt->next()); + int id = elem->GetID(); + elemMap.insert(map::value_type(id, elem)); + } + // release their ids + map::iterator elemIt = elemMap.begin(); + idFactory->Clear(); +// for ( ; elemIt != elemMap.end(); elemIt++ ) +// { +// int id = (*elemIt).first; +// idFactory->ReleaseID( id ); +// } + // set new IDs + int ID = startID; + elemIt = elemMap.begin(); + for ( ; elemIt != elemMap.end(); elemIt++ ) + { + idFactory->BindID( ID, (*elemIt).second ); + ID += deltaID; + } +} + +//======================================================================= +//function : GetElementType +//purpose : Return type of element or node with id +//======================================================================= + +SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) const +{ + SMDS_MeshElement* elem = 0; + if( iselem ) + elem = myElementIDFactory->MeshElement( id ); + else + elem = myNodeIDFactory->MeshElement( id ); + + if( !elem ) + { + //throw SALOME_Exception(LOCALIZED ("this element isn't exist")); + return SMDSAbs_All; + } + else + return elem->GetType(); +} + + + +//******************************************************************** +//******************************************************************** +//******** ********* +//***** Methods for addition of quadratic elements ****** +//******** ********* +//******************************************************************** +//******************************************************************** + +//======================================================================= +//function : AddEdgeWithID +//purpose : +//======================================================================= +SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID) +{ + return SMDS_Mesh::AddEdgeWithID + ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12), + ID); +} + +//======================================================================= +//function : AddEdge +//purpose : +//======================================================================= +SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode* n1, + const SMDS_MeshNode* n2, + const SMDS_MeshNode* n12) +{ + return SMDS_Mesh::AddEdgeWithID(n1, n2, n12, myElementIDFactory->GetFreeID()); +} + +//======================================================================= +//function : AddEdgeWithID +//purpose : +//======================================================================= +SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n12, + int ID) +{ + if ( !n1 || !n2 || !n12 ) return 0; + + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n12->getId()); + + SMDS_MeshEdge * edge = 0; + SMDS_VtkEdge *edgevtk = myEdgePool->getNew(); + edgevtk->init(nodeIds, this); + edge = edgevtk; + adjustmyCellsCapacity(ID); + myCells[ID] = edge; + myInfo.myNbQuadEdges++; + + if (!registerElement(ID, edge)) { + RemoveElement(edge, false); + edge = NULL; + } + return edge; + +} + + +//======================================================================= +//function : AddFace +//purpose : +//======================================================================= +SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n31) +{ + return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31, + myElementIDFactory->GetFreeID()); +} + +//======================================================================= +//function : AddFaceWithID +//purpose : +//======================================================================= +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, + int n12,int n23,int n31, int ID) +{ + return SMDS_Mesh::AddFaceWithID + ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12), + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23), + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31), + ID); +} + +//======================================================================= +//function : AddFaceWithID +//purpose : +//======================================================================= +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n31, + int ID) +{ + if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31) return 0; + if(hasConstructionEdges()) { + // creation quadratic edges - not implemented + return 0; + } + else + { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n12->getId()); + nodeIds.push_back(n23->getId()); + nodeIds.push_back(n31->getId()); + + SMDS_MeshFace * face = 0; + SMDS_VtkFace *facevtk = myFacePool->getNew(); + facevtk->init(nodeIds, this); + face = facevtk; + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbQuadTriangles++; + + if (!registerElement(ID, face)) { + RemoveElement(face, false); + face = NULL; + } + return face; + } +} + + +//======================================================================= +//function : AddFace +//purpose : +//======================================================================= +SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n34, + const SMDS_MeshNode * n41) +{ + return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41, + myElementIDFactory->GetFreeID()); +} + +//======================================================================= +//function : AddFaceWithID +//purpose : +//======================================================================= +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, + int n12,int n23,int n34,int n41, int ID) +{ + return SMDS_Mesh::AddFaceWithID + ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n4) , + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12), + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23), + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n34), + (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n41), + ID); +} + +//======================================================================= +//function : AddFaceWithID +//purpose : +//======================================================================= +SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n34, + const SMDS_MeshNode * n41, + int ID) +{ + if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0; + if(hasConstructionEdges()) { + // creation quadratic edges - not implemented + return 0; + } + else + { + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n12->getId()); + nodeIds.push_back(n23->getId()); + nodeIds.push_back(n34->getId()); + nodeIds.push_back(n41->getId()); + + SMDS_MeshFace * face = 0; + SMDS_VtkFace *facevtk = myFacePool->getNew(); + facevtk->init(nodeIds, this); + face = facevtk; + adjustmyCellsCapacity(ID); + myCells[ID] = face; + myInfo.myNbQuadQuadrangles++; + + if (!registerElement(ID, face)) { + RemoveElement(face, false); + face = NULL; + } + return face; + } +} + + +//======================================================================= +//function : AddVolume +//purpose : +//======================================================================= +SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n31, + const SMDS_MeshNode * n14, + const SMDS_MeshNode * n24, + const SMDS_MeshNode * n34) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n12, n23, + n31, n14, n24, n34, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : +//======================================================================= +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, + int n12,int n23,int n31, + int n14,int n24,int n34, int ID) +{ + return SMDS_Mesh::AddVolumeWithID + ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n24), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34), + ID); +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : 2d order tetrahedron of 10 nodes +//======================================================================= +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + const SMDS_MeshNode * n2, + const SMDS_MeshNode * n3, + const SMDS_MeshNode * n4, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n31, + const SMDS_MeshNode * n14, + const SMDS_MeshNode * n24, + const SMDS_MeshNode * n34, + int ID) +{ + if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n31 || !n14 || !n24 || !n34) + return 0; + if(hasConstructionFaces()) { + // creation quadratic faces - not implemented + return 0; + } + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n4->getId()); + + nodeIds.push_back(n31->getId()); + nodeIds.push_back(n23->getId()); + nodeIds.push_back(n12->getId()); + + nodeIds.push_back(n14->getId()); + nodeIds.push_back(n34->getId()); + nodeIds.push_back(n24->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + adjustmyCellsCapacity(ID); + myCells[ID] = volvtk; + myInfo.myNbQuadTetras++; + + if (!registerElement(ID, volvtk)) { + RemoveElement(volvtk, false); + volvtk = NULL; + } + return volvtk; +} + + +//======================================================================= +//function : AddVolume +//purpose : +//======================================================================= +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 * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n34, + const SMDS_MeshNode * n41, + const SMDS_MeshNode * n15, + const SMDS_MeshNode * n25, + const SMDS_MeshNode * n35, + const SMDS_MeshNode * n45) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v = + SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n12, n23, n34, n41, + n15, n25, n35, n45, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : +//======================================================================= +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, + int n12,int n23,int n34,int n41, + int n15,int n25,int n35,int n45, int ID) +{ + return SMDS_Mesh::AddVolumeWithID + ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n35), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45), + ID); +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : 2d order pyramid of 13 nodes +//======================================================================= +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 * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n34, + const SMDS_MeshNode * n41, + const SMDS_MeshNode * n15, + const SMDS_MeshNode * n25, + const SMDS_MeshNode * n35, + const SMDS_MeshNode * n45, + int ID) +{ + if (!n1 || !n2 || !n3 || !n4 || !n5 || !n12 || !n23 || + !n34 || !n41 || !n15 || !n25 || !n35 || !n45) + return 0; + if(hasConstructionFaces()) { + // creation quadratic faces - not implemented + return 0; + } + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n5->getId()); + + nodeIds.push_back(n41->getId()); + nodeIds.push_back(n34->getId()); + nodeIds.push_back(n23->getId()); + nodeIds.push_back(n12->getId()); + + nodeIds.push_back(n15->getId()); + nodeIds.push_back(n45->getId()); + nodeIds.push_back(n35->getId()); + nodeIds.push_back(n25->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + adjustmyCellsCapacity(ID); + myCells[ID] = volvtk; + myInfo.myNbQuadPyramids++; + + if (!registerElement(ID, volvtk)) { + RemoveElement(volvtk, false); + volvtk = NULL; + } + return volvtk; +} + + +//======================================================================= +//function : AddVolume +//purpose : +//======================================================================= +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 * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n31, + const SMDS_MeshNode * n45, + const SMDS_MeshNode * n56, + const SMDS_MeshNode * n64, + const SMDS_MeshNode * n14, + const SMDS_MeshNode * n25, + const SMDS_MeshNode * n36) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v = + SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31, + n45, n56, n64, n14, n25, n36, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : +//======================================================================= +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, + int n4, int n5, int n6, + int n12,int n23,int n31, + int n45,int n56,int n64, + int n14,int n25,int n36, int ID) +{ + return SMDS_Mesh::AddVolumeWithID + ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6) , + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n31), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n45), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n64), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n14), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n25), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n36), + ID); +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : 2d order Pentahedron with 15 nodes +//======================================================================= +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 * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n31, + const SMDS_MeshNode * n45, + const SMDS_MeshNode * n56, + const SMDS_MeshNode * n64, + const SMDS_MeshNode * n14, + const SMDS_MeshNode * n25, + const SMDS_MeshNode * n36, + int ID) +{ + if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 || + !n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36) + return 0; + if(hasConstructionFaces()) { + // creation quadratic faces - not implemented + return 0; + } + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n2->getId()); + nodeIds.push_back(n3->getId()); + + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n5->getId()); + nodeIds.push_back(n6->getId()); + + nodeIds.push_back(n12->getId()); + nodeIds.push_back(n23->getId()); + nodeIds.push_back(n31->getId()); + + nodeIds.push_back(n45->getId()); + nodeIds.push_back(n56->getId()); + nodeIds.push_back(n64->getId()); + + nodeIds.push_back(n14->getId()); + nodeIds.push_back(n25->getId()); + nodeIds.push_back(n36->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + adjustmyCellsCapacity(ID); + myCells[ID] = volvtk; + myInfo.myNbQuadPrisms++; + + if (!registerElement(ID, volvtk)) { + RemoveElement(volvtk, false); + volvtk = NULL; + } + return volvtk; +} + + +//======================================================================= +//function : AddVolume +//purpose : +//======================================================================= +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, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n34, + const SMDS_MeshNode * n41, + const SMDS_MeshNode * n56, + const SMDS_MeshNode * n67, + const SMDS_MeshNode * n78, + const SMDS_MeshNode * n85, + const SMDS_MeshNode * n15, + const SMDS_MeshNode * n26, + const SMDS_MeshNode * n37, + const SMDS_MeshNode * n48) +{ + int ID = myElementIDFactory->GetFreeID(); + SMDS_MeshVolume * v = + SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41, + n56, n67, n78, n85, n15, n26, n37, n48, ID); + if(v==NULL) myElementIDFactory->ReleaseID(ID); + return v; +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : +//======================================================================= +SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, + int n5, int n6, int n7, int n8, + int n12,int n23,int n34,int n41, + int n56,int n67,int n78,int n85, + int n15,int n26,int n37,int n48, int ID) +{ + return SMDS_Mesh::AddVolumeWithID + ((SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n4), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n6), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n7), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n8), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n12), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n23), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n34), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n41), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n56), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n67), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n78), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n85), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n15), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n26), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n37), + (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n48), + ID); +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : 2d order Hexahedrons with 20 nodes +//======================================================================= +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, + const SMDS_MeshNode * n12, + const SMDS_MeshNode * n23, + const SMDS_MeshNode * n34, + const SMDS_MeshNode * n41, + const SMDS_MeshNode * n56, + const SMDS_MeshNode * n67, + const SMDS_MeshNode * n78, + const SMDS_MeshNode * n85, + const SMDS_MeshNode * n15, + const SMDS_MeshNode * n26, + const SMDS_MeshNode * n37, + const SMDS_MeshNode * n48, + int ID) +{ + if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8 || !n12 || !n23 || + !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48) + return 0; + if(hasConstructionFaces()) { + return 0; + // creation quadratic faces - not implemented + } + // --- retrieve nodes ID + vector nodeIds; + nodeIds.clear(); + nodeIds.push_back(n1->getId()); + nodeIds.push_back(n4->getId()); + nodeIds.push_back(n3->getId()); + nodeIds.push_back(n2->getId()); + + nodeIds.push_back(n5->getId()); + nodeIds.push_back(n8->getId()); + nodeIds.push_back(n7->getId()); + nodeIds.push_back(n6->getId()); + + nodeIds.push_back(n41->getId()); + nodeIds.push_back(n34->getId()); + nodeIds.push_back(n23->getId()); + nodeIds.push_back(n12->getId()); + + nodeIds.push_back(n85->getId()); + nodeIds.push_back(n78->getId()); + nodeIds.push_back(n67->getId()); + nodeIds.push_back(n56->getId()); + + nodeIds.push_back(n15->getId()); + nodeIds.push_back(n48->getId()); + nodeIds.push_back(n37->getId()); + nodeIds.push_back(n26->getId()); + + SMDS_VtkVolume *volvtk = myVolumePool->getNew(); + volvtk->init(nodeIds, this); + adjustmyCellsCapacity(ID); + myCells[ID] = volvtk; + myInfo.myNbQuadHexas++; + + if (!registerElement(ID, volvtk)) { + RemoveElement(volvtk, false); + volvtk = NULL; + } + return volvtk; +} + +void SMDS_Mesh::updateNodeMinMax() +{ + myNodeMin = 0; + if (myNodes.size() == 0) + { + myNodeMax=0; + return; + } + while (!myNodes[myNodeMin] && (myNodeMin=0)) + myNodeMin--; +} + +void SMDS_Mesh::incrementNodesCapacity(int nbNodes) +{ + int val = myIDElements.size(); + MESSAGE(" ------------------- resize myIDElements " << val << " --> " << val + nbNodes); + myIDElements.resize(val + nbNodes, -1); // fill new elements with -1 + val = myNodes.size(); + MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes); + myNodes.resize(val +nbNodes, 0); +} + +void SMDS_Mesh::incrementCellsCapacity(int nbCells) +{ + int val = myVtkIndex.size(); + MESSAGE(" ------------------- resize myVtkIndex " << val << " --> " << val + nbCells); + myVtkIndex.resize(val + nbCells, -1); // fill new elements with -1 + val = myCells.size(); + MESSAGE(" ------------------- resize myCells " << val << " --> " << val + nbCells); + myNodes.resize(val +nbCells, 0); +} + +void SMDS_Mesh::adjustStructure() +{ + myGrid->GetPoints()->GetData()->SetNumberOfTuples(myNodeIDFactory->GetMaxID()+1); +} + +void SMDS_Mesh::dumpGrid(string ficdump) +{ + MESSAGE("SMDS_Mesh::dumpGrid " << ficdump); +// vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); +// aWriter->SetFileName(ficdump.c_str()); +// aWriter->SetInput(myGrid); +// if(myGrid->GetNumberOfCells()) +// { +// aWriter->Write(); +// } +// aWriter->Delete(); + ficdump = ficdump + "_connectivity"; + ofstream ficcon(ficdump.c_str(), ios::out); + int nbPoints = myGrid->GetNumberOfPoints(); + ficcon << "-------------------------------- points " << nbPoints << endl; + for (int i=0; iGetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl; + } + int nbCells = myGrid->GetNumberOfCells(); + ficcon << "-------------------------------- cells " << nbCells << endl; + for (int i=0; iGetCell(i)); +// MESSAGE(" " << myGrid->GetCell(i)->GetCellType()); + ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -"; + int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints(); + vtkIdList *listid = myGrid->GetCell(i)->GetPointIds(); + for (int j=0; jGetId(j); + } + ficcon << endl; + } + ficcon << "-------------------------------- connectivity " << nbPoints << endl; + vtkCellLinks *links = myGrid->GetCellLinks(); + for (int i=0; iGetNcells(i); + vtkIdType *cells = links->GetCells(i); + ficcon << i << " - " << ncells << " -"; + for (int j=0; j