X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=43a48eb37f23095e4f666dd64df2ed7c84a93487;hp=7c8e6632747f0d84552e71e066e6690fd6d1b3e5;hb=eb177ba64551d4218329339113f3e1782ceb6029;hpb=d92118a7a570fd784e024a7a893a67a4fc8f112c diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx index 7c8e66327..43a48eb37 100644 --- a/src/SMDS/SMDS_Mesh.cxx +++ b/src/SMDS/SMDS_Mesh.cxx @@ -26,35 +26,28 @@ #pragma warning(disable:4786) #endif -#include "SMDS_FaceOfEdges.hxx" -#include "SMDS_FaceOfNodes.hxx" #include "SMDS_Mesh.hxx" -#include "SMDS_PolygonalFaceOfNodes.hxx" -#include "SMDS_PolyhedralVolumeOfNodes.hxx" -#include "SMDS_QuadraticEdge.hxx" -#include "SMDS_QuadraticFaceOfNodes.hxx" -#include "SMDS_QuadraticVolumeOfNodes.hxx" + +#include "SMDS_ElementFactory.hxx" +#include "SMDS_ElementHolder.hxx" #include "SMDS_SetIterator.hxx" #include "SMDS_SpacePosition.hxx" #include "SMDS_UnstructuredGrid.hxx" -#include "SMDS_VolumeOfFaces.hxx" -#include "SMDS_VolumeOfNodes.hxx" -#include "utilities.h" +#include #include -#include -#include +//#include #include +#include #include #include #include -#include #include #include -#include -using namespace std; + +#include #if !defined WIN32 && !defined __APPLE__ #include @@ -63,9 +56,9 @@ using namespace std; // number of added entities to check memory after #define CHECKMEMORY_INTERVAL 100000 -vector SMDS_Mesh::_meshList = vector(); -int SMDS_Mesh::chunkSize = 1024; +#define MYASSERT(val) if (!(val)) throw SALOME_Exception(LOCALIZED("assertion not verified")); +int SMDS_Mesh::chunkSize = 1024; //================================================================================ /*! @@ -77,6 +70,7 @@ int SMDS_Mesh::chunkSize = 1024; int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) { + return -1; #if !defined WIN32 && !defined __APPLE__ struct sysinfo si; int err = sysinfo( &si ); @@ -87,13 +81,16 @@ int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) 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); - } - else { - double factor = ( si.totalswap == 0 ) ? 0.1 : 0.2; - limit = int(( factor * si.totalram * si.mem_unit ) / Mbyte ); + if ( si.totalswap == 0 ) + { + int status = system("SMDS_MemoryLimit"); // it returns lower limit of free RAM + if (status >= 0 ) { + limit = WEXITSTATUS(status); + } + else { + double factor = ( si.totalswap == 0 ) ? 0.1 : 0.2; + limit = int(( factor * si.totalram * si.mem_unit ) / Mbyte ); + } } if ( limit < 20 ) limit = 20; @@ -106,7 +103,6 @@ int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) int freeMb = ( si.freeram * si.mem_unit ) / Mbyte + ( si.freeswap * si.mem_unit ) / Mbyte; - //cout << "freeMb = " << freeMb << " limit = " << limit << endl; if ( freeMb > limit ) return freeMb - limit; @@ -125,29 +121,12 @@ int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) /// Create a new mesh object /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::SMDS_Mesh(): - myNodePool(0), myVolumePool(0), myFacePool(0), myEdgePool(0), myBallPool(0), + myNodeFactory( new SMDS_NodeFactory( this )), + myCellFactory( new SMDS_ElementFactory( this )), myParent(NULL), - myNodeIDFactory(new SMDS_MeshNodeIDFactory()), - myElementIDFactory(new SMDS_MeshElementIDFactory()), myModified(false), myModifTime(0), myCompactTime(0), - myHasConstructionEdges(false), myHasConstructionFaces(false), - myHasInverseElements(true), xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0) { - myMeshId = _meshList.size(); // --- index of the mesh to push back in the vector - 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); - myBallPool = new ObjectPool(SMDS_Mesh::chunkSize); - - myNodes.clear(); - myCells.clear(); - //myCellIdSmdsToVtk.clear(); - myCellIdVtkToSmds.clear(); myGrid = SMDS_UnstructuredGrid::New(); myGrid->setSMDS_mesh(this); myGrid->Initialize(); @@ -156,22 +135,13 @@ SMDS_Mesh::SMDS_Mesh(): // bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion" // Use double type for storing coordinates of nodes instead of float. points->SetDataType(VTK_DOUBLE); - points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/); + points->SetNumberOfPoints( 0 ); myGrid->SetPoints( points ); points->Delete(); - //myGrid->BuildLinks(); this->Modified(); // initialize static maps in SMDS_MeshCell, to be thread-safe - if ( myMeshId == 0 ) - { - SMDS_MeshCell::toVtkType( SMDSEntity_Node ); - SMDS_MeshCell::toVtkOrder( SMDSEntity_Node ); - SMDS_MeshCell::reverseSmdsOrder( SMDSEntity_Node ); - SMDS_MeshCell::interlacedSmdsOrder( SMDSEntity_Node ); - SMDS_MeshCell::toSmdsType( VTK_VERTEX ); - SMDS_MeshCell::fromVtkOrder( SMDSEntity_Node ); - } + SMDS_MeshCell::InitStaticMembers(); } /////////////////////////////////////////////////////////////////////////////// @@ -180,15 +150,9 @@ SMDS_Mesh::SMDS_Mesh(): /// (2003-09-08) of SMESH /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent): - myNodePool(parent->myNodePool), - myVolumePool(parent->myVolumePool), - myFacePool(parent->myFacePool), - myEdgePool(parent->myEdgePool), - myBallPool(parent->myBallPool), - myParent(parent), myNodeIDFactory(parent->myNodeIDFactory), - myElementIDFactory(parent->myElementIDFactory), - myHasConstructionEdges(false), myHasConstructionFaces(false), - myHasInverseElements(true) + myNodeFactory( new SMDS_NodeFactory( this )), + myCellFactory( new SMDS_ElementFactory( this )), + myParent(parent) { } @@ -211,7 +175,7 @@ SMDS_Mesh *SMDS_Mesh::AddSubMesh() SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z) { - return SMDS_Mesh::AddNodeWithID(x,y,z,myNodeIDFactory->GetFreeID()); + return SMDS_Mesh::AddNodeWithID( x,y,z, myNodeFactory->GetFreeID() ); } /////////////////////////////////////////////////////////////////////////////// @@ -219,33 +183,18 @@ SMDS_MeshNode * SMDS_Mesh::AddNode(double x, double y, double z) ///@param ID : The ID of the MeshNode to create ///@return : The created node or NULL if a node with this ID already exists /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) +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); - if(!node){ - if (ID < 1) - { - MESSAGE("=============> Bad Node Id: " << ID); - ID = myNodeIDFactory->GetFreeID(); - } - myNodeIDFactory->adjustMaxId(ID); - SMDS_MeshNode * node = myNodePool->getNew(); - node->init(ID, myMeshId, 0, x, y, z); - - if (ID >= (int)myNodes.size()) - { - myNodes.resize(ID+SMDS_Mesh::chunkSize, 0); -// MESSAGE(" ------------------ myNodes resize " << ID << " --> " << ID+SMDS_Mesh::chunkSize); - } - myNodes[ID] = node; - myNodeIDFactory->BindID(ID,node); + SMDS_MeshNode *node = myNodeFactory->NewNode( ID ); + if ( node ) + { + node->init( x, y, z ); myInfo.myNbNodes++; myModified = true; this->adjustBoundingBox(x, y, z); - return node; - }else - return NULL; + } + return node; } /////////////////////////////////////////////////////////////////////////////// @@ -254,7 +203,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(int idnode, int ID) { - SMDS_MeshNode * node = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode); + const SMDS_MeshNode * node = myNodeFactory->FindNode(idnode); if (!node) return NULL; return SMDS_Mesh::Add0DElementWithID(node, ID); } @@ -265,7 +214,7 @@ SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(int idnode, int ID) /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh0DElement* SMDS_Mesh::Add0DElement(const SMDS_MeshNode * node) { - return SMDS_Mesh::Add0DElementWithID(node, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::Add0DElementWithID( node, myCellFactory->GetFreeID() ); } /////////////////////////////////////////////////////////////////////////////// @@ -280,30 +229,26 @@ SMDS_Mesh0DElement* SMDS_Mesh::Add0DElementWithID(const SMDS_MeshNode * n, int I if (!n) return 0; if (Nb0DElements() % 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; + + if ( SMDS_MeshCell * cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_0D, /*nbNodes=*/1, n ); myInfo.myNb0DElements++; - return el0d; + return static_cast< SMDS_Mesh0DElement*> ( cell ); } - delete el0d; - return NULL; + return 0; } /////////////////////////////////////////////////////////////////////////////// /// create a Ball and add it to the current Mesh /// @return : The created Ball /////////////////////////////////////////////////////////////////////////////// -SMDS_BallElement* SMDS_Mesh::AddBallWithID(int idnode, double diameter, int ID) +SMDS_BallElement* SMDS_Mesh::AddBallWithID( int idnode, double diameter, int ID ) { - SMDS_MeshNode * node = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode); + const SMDS_MeshNode * node = myNodeFactory->FindNode( idnode ); if (!node) return NULL; - return SMDS_Mesh::AddBallWithID(node, diameter, ID); + return SMDS_Mesh::AddBallWithID( node, diameter, ID ); } /////////////////////////////////////////////////////////////////////////////// @@ -312,7 +257,7 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(int idnode, double diameter, int ID) /////////////////////////////////////////////////////////////////////////////// SMDS_BallElement* SMDS_Mesh::AddBall(const SMDS_MeshNode * node, double diameter) { - return SMDS_Mesh::AddBallWithID(node, diameter, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddBallWithID(node, diameter, myCellFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -329,17 +274,12 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame if (NbBalls() % CHECKMEMORY_INTERVAL == 0) CheckMemory(); - SMDS_BallElement *ball = myBallPool->getNew(); - ball->init(n->getVtkId(), diameter, this); - if (!this->registerElement(ID,ball)) + SMDS_BallElement* ball = static_cast< SMDS_BallElement*>( myCellFactory->NewElement( ID )); + if ( ball ) { - this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL); - myBallPool->destroy(ball); - return 0; + ball->init( n, diameter ); + myInfo.myNbBalls++; } - adjustmyCellsCapacity(ID); - myCells[ID] = ball; - myInfo.myNbBalls++; return ball; } @@ -350,8 +290,8 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame 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); + const SMDS_MeshNode * node1 = myNodeFactory->FindNode(idnode1); + const SMDS_MeshNode * node2 = myNodeFactory->FindNode(idnode2); if(!node1 || !node2) return NULL; return SMDS_Mesh::AddEdgeWithID(node1, node2, ID); } @@ -364,7 +304,7 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(int idnode1, int idnode2, int ID) SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1, const SMDS_MeshNode * node2) { - return SMDS_Mesh::AddEdgeWithID(node1, node2, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddEdgeWithID(node1, node2, myCellFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -378,36 +318,17 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode * node1, SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n2, - int ID) + int ID) { if ( !n1 || !n2 ) return 0; - SMDS_MeshEdge * edge = 0; - - // --- retrieve nodes ID - vector nodeIds; - nodeIds.clear(); - nodeIds.push_back(n1->getVtkId()); - nodeIds.push_back(n2->getVtkId()); - - SMDS_VtkEdge *edgevtk = myEdgePool->getNew(); - edgevtk->init(nodeIds, this); - if (!this->registerElement(ID,edgevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL); - myEdgePool->destroy(edgevtk); - return 0; - } - edge = edgevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = edge; - myInfo.myNbEdges++; -// if (edge && !registerElement(ID, edge)) -// { -// RemoveElement(edge, false); -// edge = NULL; -// } - return edge; + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Edge, /*nbNodes=*/2, n1, n2 ); + myInfo.myNbEdges++; + return static_cast( cell ); + } + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -419,7 +340,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, const SMDS_MeshNode * n2, const SMDS_MeshNode * n3) { - return SMDS_Mesh::AddFaceWithID(n1,n2,n3, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddFaceWithID(n1,n2,n3, myCellFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -428,9 +349,9 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, 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); + const SMDS_MeshNode * node1 = myNodeFactory->FindNode(idnode1); + const SMDS_MeshNode * node2 = myNodeFactory->FindNode(idnode2); + const SMDS_MeshNode * node3 = myNodeFactory->FindNode(idnode3); if(!node1 || !node2 || !node3) return NULL; return SMDS_Mesh::AddFaceWithID(node1, node2, node3, ID); } @@ -444,14 +365,16 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n3, int ID) { - //MESSAGE("AddFaceWithID " << ID) - SMDS_MeshFace * face=createTriangle(n1, n2, n3, ID); + if ( !n1 || !n2 || !n3 ) return 0; + if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); -// if (face && !registerElement(ID, face)) { -// RemoveElement(face, false); -// face = NULL; -// } - return face; + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Triangle, /*nbNodes=*/3, n1, n2, n3 ); + myInfo.myNbTriangles++; + return static_cast( cell ); + } + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -464,7 +387,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, const SMDS_MeshNode * n3, const SMDS_MeshNode * n4) { - return SMDS_Mesh::AddFaceWithID(n1,n2,n3, n4, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddFaceWithID(n1,n2,n3, n4, myCellFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -477,12 +400,12 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int idnode1, 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 || !node2 || !node3 || !node4) return NULL; + const SMDS_MeshNode *node1, *node2, *node3, *node4; + node1 = myNodeFactory->FindNode(idnode1); + node2 = myNodeFactory->FindNode(idnode2); + node3 = myNodeFactory->FindNode(idnode3); + node4 = myNodeFactory->FindNode(idnode4); + if ( !node1 || !node2 || !node3 || !node4 ) return NULL; return SMDS_Mesh::AddFaceWithID(node1, node2, node3, node4, ID); } @@ -496,100 +419,16 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, 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 ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - - SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3); - adjustmyCellsCapacity(ID); - myCells[ID] = face; - myInfo.myNbTriangles++; - - if (!registerElement(ID, face)) { - registerElement(myElementIDFactory->GetFreeID(), 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; - 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) -{ - if (!hasConstructionEdges()) - return NULL; - if ( !e1 || !e2 || !e3 || !e4 ) return 0; + if ( !n1 || !n2 || !n3 || !n4 ) return 0; if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4); - adjustmyCellsCapacity(ID); - myCells[ID] = face; - myInfo.myNbQuadrangles++; - if (!registerElement(ID, face)) + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - registerElement(myElementIDFactory->GetFreeID(), face); - //RemoveElement(face, false); - //face = NULL; + cell->init( SMDSEntity_Quadrangle, /*nbNodes=*/4, n1, n2, n3, n4 ); + myInfo.myNbQuadrangles++; + return static_cast( cell ); } - return face; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -602,10 +441,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n3, const SMDS_MeshNode * n4) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, myCellFactory->GetFreeID() ); } /////////////////////////////////////////////////////////////////////////////// @@ -621,11 +457,11 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, 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); + const SMDS_MeshNode *node1, *node2, *node3, *node4; + node1 = myNodeFactory->FindNode(idnode1); + node2 = myNodeFactory->FindNode(idnode2); + node3 = myNodeFactory->FindNode(idnode3); + node4 = myNodeFactory->FindNode(idnode4); if(!node1 || !node2 || !node3 || !node4) return NULL; return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, ID); } @@ -642,49 +478,16 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n4, int ID) { - SMDS_MeshVolume* volume = 0; - if ( !n1 || !n2 || !n3 || !n4) return volume; + if ( !n1 || !n2 || !n3 || !n4 ) return 0; if ( NbVolumes() % 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()) { - return NULL; - } - else { - // --- retrieve nodes ID - myNodeIds.resize(4); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n3->getVtkId(); // order SMDS-->VTK - myNodeIds[2] = n2->getVtkId(); - myNodeIds[3] = n4->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - volume = volvtk; - adjustmyCellsCapacity(ID); - myCells[ID] = volume; + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Tetra, /*nbNodes=*/4, n1, n2, n3, n4 ); myInfo.myNbTetras++; + return static_cast( cell ); } - - // if (!registerElement(ID, volume)) { - // RemoveElement(volume, false); - // volume = NULL; - // } - return volume; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -699,10 +502,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n4, const SMDS_MeshNode * n5) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, myCellFactory->GetFreeID() ); } /////////////////////////////////////////////////////////////////////////////// @@ -720,12 +520,12 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, 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); + const SMDS_MeshNode *node1, *node2, *node3, *node4, *node5; + node1 = myNodeFactory->FindNode(idnode1); + node2 = myNodeFactory->FindNode(idnode2); + node3 = myNodeFactory->FindNode(idnode3); + node4 = myNodeFactory->FindNode(idnode4); + node5 = myNodeFactory->FindNode(idnode5); if(!node1 || !node2 || !node3 || !node4 || !node5) return NULL; return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, ID); } @@ -744,50 +544,16 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n5, int ID) { - SMDS_MeshVolume* volume = 0; - if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume; + if ( !n1 || !n2 || !n3 || !n4 || !n5 ) return 0; if ( NbVolumes() % 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()) { - return NULL; - } - else { - // --- retrieve nodes ID - myNodeIds.resize(5); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n4->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n2->getVtkId(); - myNodeIds[4] = n5->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - volume = volvtk; - adjustmyCellsCapacity(ID); - myCells[ID] = volume; + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Pyramid, /*nbNodes=*/5, n1, n2, n3, n4, n5 ); myInfo.myNbPyramids++; + return static_cast( cell ); } - - // if (!registerElement(ID, volume)) { - // RemoveElement(volume, false); - // volume = NULL; - // } - return volume; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -803,10 +569,8 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n5, const SMDS_MeshNode * n6) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myCellFactory->GetFreeID(); + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID); } /////////////////////////////////////////////////////////////////////////////// @@ -825,14 +589,13 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, 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 || !node2 || !node3 || !node4 || !node5 || !node6) return NULL; + const SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6; + node1 = myNodeFactory->FindNode(idnode1); + node2 = myNodeFactory->FindNode(idnode2); + node3 = myNodeFactory->FindNode(idnode3); + node4 = myNodeFactory->FindNode(idnode4); + node5 = myNodeFactory->FindNode(idnode5); + node6 = myNodeFactory->FindNode(idnode6); return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6, ID); } @@ -851,52 +614,16 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n6, int ID) { - SMDS_MeshVolume* volume = 0; - if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume; + if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 ) return 0; if ( NbVolumes() % 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()) { - return NULL; - } - else { - // --- retrieve nodes ID - myNodeIds.resize(6); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n4->getVtkId(); - myNodeIds[4] = n5->getVtkId(); - myNodeIds[5] = n6->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - volume = volvtk; - adjustmyCellsCapacity(ID); - myCells[ID] = volume; + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Penta, /*nbNodes=*/6, n1, n2, n3, n4, n5, n6 ); myInfo.myNbPrisms++; + return static_cast( cell ); } - - // if (!registerElement(ID, volume)) { - // RemoveElement(volume, false); - // volume = NULL; - // } - return volume; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -917,12 +644,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n11, const SMDS_MeshNode * n12) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, - n7, n8, n9, n10, n11, n12, - ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, + n7, n8, n9, n10, n11, n12, + myCellFactory->GetFreeID() ); } /////////////////////////////////////////////////////////////////////////////// @@ -946,18 +670,18 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode12, int ID) { - SMDS_MeshNode *node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); - SMDS_MeshNode *node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); - SMDS_MeshNode *node3 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode3); - SMDS_MeshNode *node4 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode4); - SMDS_MeshNode *node5 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode5); - SMDS_MeshNode *node6 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode6); - SMDS_MeshNode *node7 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode7); - SMDS_MeshNode *node8 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode8); - SMDS_MeshNode *node9 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode9); - SMDS_MeshNode *node10 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode10); - SMDS_MeshNode *node11 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode11); - SMDS_MeshNode *node12 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode12); + const SMDS_MeshNode *node1 = myNodeFactory->FindNode(idnode1); + const SMDS_MeshNode *node2 = myNodeFactory->FindNode(idnode2); + const SMDS_MeshNode *node3 = myNodeFactory->FindNode(idnode3); + const SMDS_MeshNode *node4 = myNodeFactory->FindNode(idnode4); + const SMDS_MeshNode *node5 = myNodeFactory->FindNode(idnode5); + const SMDS_MeshNode *node6 = myNodeFactory->FindNode(idnode6); + const SMDS_MeshNode *node7 = myNodeFactory->FindNode(idnode7); + const SMDS_MeshNode *node8 = myNodeFactory->FindNode(idnode8); + const SMDS_MeshNode *node9 = myNodeFactory->FindNode(idnode9); + const SMDS_MeshNode *node10 = myNodeFactory->FindNode(idnode10); + const SMDS_MeshNode *node11 = myNodeFactory->FindNode(idnode11); + const SMDS_MeshNode *node12 = myNodeFactory->FindNode(idnode12); return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6, node7, node8, node9, node10, node11, node12, ID); @@ -988,44 +712,15 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, !n7 || !n8 || !n9 || !n10 || !n11 || !n12 ) return volume; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - if(hasConstructionFaces()) { - return NULL; - } - else if(hasConstructionEdges()) { - return NULL; - } - else { - // --- retrieve nodes ID - myNodeIds.resize(12); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n6->getVtkId(); - myNodeIds[2] = n5->getVtkId(); - myNodeIds[3] = n4->getVtkId(); - myNodeIds[4] = n3->getVtkId(); - myNodeIds[5] = n2->getVtkId(); - - myNodeIds[6] = n7->getVtkId(); - myNodeIds[7] = n12->getVtkId(); - myNodeIds[8] = n11->getVtkId(); - myNodeIds[9] = n10->getVtkId(); - myNodeIds[10] = n9->getVtkId(); - myNodeIds[11] = n8->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - volume = volvtk; - adjustmyCellsCapacity(ID); - myCells[ID] = volume; + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Hexagonal_Prism, + /*nbNodes=*/12, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12 ); myInfo.myNbHexPrism++; + return static_cast( cell ); } - - return volume; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -1043,10 +738,8 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n7, const SMDS_MeshNode * n8) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myCellFactory->GetFreeID(); + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID); } /////////////////////////////////////////////////////////////////////////////// @@ -1067,17 +760,15 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, 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 || !node2 || !node3 || !node4 || !node5 || !node6 || !node7 || !node8) - return NULL; + const SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8; + node1 = myNodeFactory->FindNode(idnode1); + node2 = myNodeFactory->FindNode(idnode2); + node3 = myNodeFactory->FindNode(idnode3); + node4 = myNodeFactory->FindNode(idnode4); + node5 = myNodeFactory->FindNode(idnode5); + node6 = myNodeFactory->FindNode(idnode6); + node7 = myNodeFactory->FindNode(idnode7); + node8 = myNodeFactory->FindNode(idnode8); return SMDS_Mesh::AddVolumeWithID(node1, node2, node3, node4, node5, node6, node7, node8, ID); } @@ -1103,203 +794,28 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, SMDS_MeshVolume* volume = 0; if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume; if ( NbVolumes() % 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()) { - return NULL; - } - else { - // --- retrieve nodes ID - myNodeIds.resize(8); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n4->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n2->getVtkId(); - myNodeIds[4] = n5->getVtkId(); - myNodeIds[5] = n8->getVtkId(); - myNodeIds[6] = n7->getVtkId(); - myNodeIds[7] = n6->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - 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) -{ - 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) -{ - if (!hasConstructionFaces()) - return NULL; - if ( !f1 || !f2 || !f3 || !f4) return 0; - if ( NbVolumes() % 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)) { - registerElement(myElementIDFactory->GetFreeID(), 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) -{ - 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) -{ - if (!hasConstructionFaces()) - return NULL; - if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0; - if ( NbVolumes() % 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)) { - registerElement(myElementIDFactory->GetFreeID(), 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) -{ - 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) -{ - if (!hasConstructionFaces()) - return NULL; - if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0; - if ( NbVolumes() % 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)) { - registerElement(myElementIDFactory->GetFreeID(), volume); - //RemoveElement(volume, false); - //volume = NULL; + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Hexa, + /*nbNodes=*/8, n1, n2, n3, n4, n5, n6, n7, n8 ); + myInfo.myNbHexas++; + return static_cast( cell ); } - return volume; + return 0; } /////////////////////////////////////////////////////////////////////////////// /// Add a polygon defined by its nodes IDs /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes_ids, - const int ID) +SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const std::vector & nodes_ids, + const int ID) { int nbNodes = nodes_ids.size(); - vector nodes (nbNodes); + std::vector nodes (nbNodes); for (int i = 0; i < nbNodes; i++) { - nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]); + nodes[i] = myNodeFactory->FindNode( nodes_ids[i] ); if (!nodes[i]) return NULL; } return SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID); @@ -1310,38 +826,18 @@ SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes_ids, /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* -SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes, - const int ID) +SMDS_Mesh::AddPolygonalFaceWithID (const std::vector & nodes, + const int ID) { - SMDS_MeshFace * face; - if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - if (hasConstructionEdges()) - { - return NULL; - } - else - { - myNodeIds.resize( nodes.size() ); - for ( size_t i = 0; i < nodes.size(); ++i ) - myNodeIds[i] = nodes[i]->getVtkId(); - - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->initPoly(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_Polygon, nodes ); myInfo.myNbPolygons++; + return static_cast( cell ); } - - return face; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -1349,21 +845,21 @@ SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes, /// An ID is automatically affected to the created face. /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (const vector & nodes) +SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (const std::vector & nodes) { - return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myCellFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// /// Add a quadratic polygon defined by its nodes IDs /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector & nodes_ids, - const int ID) +SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector & nodes_ids, + const int ID) { - vector nodes( nodes_ids.size() ); + std::vector nodes( nodes_ids.size() ); for ( size_t i = 0; i < nodes.size(); i++) { - nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]); + nodes[i] = myNodeFactory->FindNode(nodes_ids[i]); if (!nodes[i]) return NULL; } return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID); @@ -1374,36 +870,17 @@ SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector & nodes_ /////////////////////////////////////////////////////////////////////////////// SMDS_MeshFace* -SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector & nodes, - const int ID) +SMDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector & nodes, + const int ID) { - SMDS_MeshFace * face; - if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - if (hasConstructionEdges()) - { - return NULL; - } - else + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - myNodeIds.resize( nodes.size() ); - for ( size_t i = 0; i < nodes.size(); ++i ) - myNodeIds[i] = nodes[i]->getVtkId(); - - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->initQuadPoly(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; + cell->init( SMDSEntity_Quad_Polygon, nodes ); myInfo.myNbQuadPolygons++; + return static_cast( cell ); } - return face; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -1411,9 +888,9 @@ SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector & node /// An ID is automatically affected to the created face. /////////////////////////////////////////////////////////////////////////////// -SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const vector & nodes) +SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const std::vector & nodes) { - return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID()); + return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, myCellFactory->GetFreeID()); } /////////////////////////////////////////////////////////////////////////////// @@ -1423,15 +900,14 @@ SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const vector & nodes_ids, - const vector & quantities, - const int ID) +SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector & nodes_ids, + const std::vector & quantities, + const int ID) { int nbNodes = nodes_ids.size(); - vector nodes (nbNodes); + std::vector nodes (nbNodes); for (int i = 0; i < nbNodes; i++) { - nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]); + nodes[i] = myNodeFactory->FindNode(nodes_ids[i]); if (!nodes[i]) return NULL; } return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID); @@ -1444,57 +920,22 @@ SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID /////////////////////////////////////////////////////////////////////////////// SMDS_MeshVolume* -SMDS_Mesh::AddPolyhedralVolumeWithID (const vector& nodes, - const vector & quantities, +SMDS_Mesh::AddPolyhedralVolumeWithID (const std::vector& nodes, + const std::vector & quantities, const int ID) { - SMDS_MeshVolume* volume = 0; if ( nodes.empty() || quantities.empty() ) return NULL; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - if (hasConstructionFaces()) - { - return NULL; - } - else if (hasConstructionEdges()) - { - return NULL; - } - else + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - //#ifdef VTK_HAVE_POLYHEDRON - myNodeIds.resize( nodes.size() ); - for ( size_t i = 0; i < nodes.size(); ++i ) - myNodeIds[i] = nodes[i]->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->initPoly(myNodeIds, quantities, this); - if (!this->registerElement(ID, volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - volume = volvtk; - //#else - // for ( int i = 0; i < nodes.size(); ++i ) - // if ( !nodes[ i ] ) return 0; - // volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities); - //#endif - adjustmyCellsCapacity(ID); - myCells[ID] = volume; + SMDS_MeshVolume* volume = static_cast( cell ); + volume->init( nodes, quantities ); myInfo.myNbPolyhedrons++; + return volume; } - - //#ifndef VTK_HAVE_POLYHEDRON - // if (!registerElement(ID, volume)) - // { - // registerElement(myElementIDFactory->GetFreeID(), volume); - // //RemoveElement(volume, false); - // //volume = NULL; - // } - //#endif - return volume; + return 0; } /////////////////////////////////////////////////////////////////////////////// @@ -1503,154 +944,31 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector& nodes, /////////////////////////////////////////////////////////////////////////////// SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume - (const vector & nodes, - const vector & quantities) +(const std::vector & nodes, + const std::vector & quantities) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID); - if (v == NULL) myElementIDFactory->ReleaseID(ID); - return v; + int ID = myCellFactory->GetFreeID(); + return SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID); } SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIds(const std::vector& vtkNodeIds) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeFromVtkIdsWithID(vtkNodeIds, ID); - if (v == NULL) myElementIDFactory->ReleaseID(ID); - return v; -} - -SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIdsWithID(const std::vector& vtkNodeIds, const int ID) -{ - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(vtkNodeIds, this); - if (!this->registerElement(ID,volvtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; - } - adjustmyCellsCapacity(ID); - myCells[ID] = volvtk; - vtkIdType aVtkType = volvtk->GetVtkType(); - switch (aVtkType) - { - case VTK_TETRA: - myInfo.myNbTetras++; - break; - case VTK_PYRAMID: - myInfo.myNbPyramids++; - break; - case VTK_WEDGE: - myInfo.myNbPrisms++; - break; - case VTK_HEXAHEDRON: - myInfo.myNbHexas++; - break; - case VTK_QUADRATIC_TETRA: - myInfo.myNbQuadTetras++; - break; - case VTK_QUADRATIC_PYRAMID: - myInfo.myNbQuadPyramids++; - break; - case VTK_QUADRATIC_WEDGE: - myInfo.myNbQuadPrisms++; - break; - case VTK_QUADRATIC_HEXAHEDRON: - myInfo.myNbQuadHexas++; - break; -//#ifdef VTK_HAVE_POLYHEDRON - case VTK_POLYHEDRON: - myInfo.myNbPolyhedrons++; - break; -//#endif - default: - myInfo.myNbPolyhedrons++; - break; - } - return volvtk; + SMDS_MeshCell* cell = myCellFactory->NewCell( myCellFactory->GetFreeID() ); + SMDS_MeshVolume * vol = static_cast( cell ); + vol->init( vtkNodeIds ); + myInfo.add( cell ); + return vol; } SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIds(const std::vector& vtkNodeIds) { - int ID = myElementIDFactory->GetFreeID(); - SMDS_MeshFace * f = SMDS_Mesh::AddFaceFromVtkIdsWithID(vtkNodeIds, ID); - if (f == NULL) myElementIDFactory->ReleaseID(ID); + SMDS_MeshCell* cell = myCellFactory->NewCell( myCellFactory->GetFreeID() ); + SMDS_MeshFace * f = static_cast( cell ); + f->init( vtkNodeIds ); + myInfo.add( cell ); return f; } -SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector& vtkNodeIds, const int ID) -{ - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(vtkNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - adjustmyCellsCapacity(ID); - myCells[ID] = facevtk; - vtkIdType aVtkType = facevtk->GetVtkType(); - switch (aVtkType) - { - case VTK_TRIANGLE: - myInfo.myNbTriangles++; - break; - case VTK_QUAD: - myInfo.myNbQuadrangles++; - break; - case VTK_QUADRATIC_TRIANGLE: - myInfo.myNbQuadTriangles++; - break; - case VTK_QUADRATIC_QUAD: - myInfo.myNbQuadQuadrangles++; - break; - case VTK_BIQUADRATIC_QUAD: - myInfo.myNbBiQuadQuadrangles++; - break; - case VTK_BIQUADRATIC_TRIANGLE: - myInfo.myNbBiQuadTriangles++; - break; - case VTK_POLYGON: - myInfo.myNbPolygons++; - break; - default: - myInfo.myNbPolygons++; - } - return facevtk; -} - -/////////////////////////////////////////////////////////////////////////////// -/// Registers element with the given ID, maintains inverse connections -/////////////////////////////////////////////////////////////////////////////// -bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element) -{ - if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound - { - MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId()); - 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 (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector - { - myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1); - } - myCellIdVtkToSmds[vtkId] = ID; - - myElementIDFactory->updateMinMax(ID); - return true; -} - //======================================================================= //function : MoveNode //purpose : @@ -1667,11 +985,7 @@ void SMDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z) /////////////////////////////////////////////////////////////////////////////// const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const { - if (ID < 1 || ID >= (int)myNodes.size()) - { - return 0; - } - return (const SMDS_MeshNode *)myNodes[ID]; + return myNodeFactory->FindNode( ID ); } /////////////////////////////////////////////////////////////////////////////// @@ -1679,117 +993,12 @@ const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const /////////////////////////////////////////////////////////////////////////////// const SMDS_MeshNode * SMDS_Mesh::FindNodeVtk(int vtkId) const { - // TODO if needed use mesh->nodeIdFromVtkToSmds - if ( vtkId < 0 || vtkId+1 >= (int) myNodes.size() ) - { - MESSAGE("------------------------------------------------------------------------- "); - MESSAGE("---------------------------- bad VTK ID " << vtkId << " " << myNodes.size()); - MESSAGE("------------------------------------------------------------------------- "); - return 0; - } - return (const SMDS_MeshNode *)myNodes[vtkId+1]; -} - -/////////////////////////////////////////////////////////////////////////////// -///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(const SMDS_MeshNode * node1, - const SMDS_MeshNode * node2, - const SMDS_MeshNode * node3, - int ID) -{ - if ( !node1 || !node2 || !node3) return 0; - if ( NbFaces() % 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 - myNodeIds.resize(3); - myNodeIds[0] = node1->getVtkId(); - myNodeIds[1] = node2->getVtkId(); - myNodeIds[2] = node3->getVtkId(); - - SMDS_MeshFace * face = 0; - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(myNodeIds, this); // put in vtkUnstructuredGrid - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; - myInfo.myNbTriangles++; - return face; - } + return myNodeFactory->FindNode( vtkId + 1 ); } -/////////////////////////////////////////////////////////////////////////////// -///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(const SMDS_MeshNode * node1, - const SMDS_MeshNode * node2, - const SMDS_MeshNode * node3, - const SMDS_MeshNode * node4, - int ID) +const SMDS_MeshElement * SMDS_Mesh::FindElementVtk(int IDelem) const { - if ( !node1 || !node2 || !node3 || !node4 ) return 0; - if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - 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); - adjustmyCellsCapacity(ID); - myCells[ID] = face; - myInfo.myNbQuadrangles++; - return face; - } - else - { - // --- retrieve nodes ID - myNodeIds.resize(4); - myNodeIds[0] = node1->getVtkId(); - myNodeIds[1] = node2->getVtkId(); - myNodeIds[2] = node3->getVtkId(); - myNodeIds[3] = node4->getVtkId(); - - SMDS_MeshFace * face = 0; - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; - myInfo.myNbQuadrangles++; - return face; - } + return myCellFactory->FindElement( FromVtkToSmds( IDelem )); } /////////////////////////////////////////////////////////////////////////////// @@ -1801,42 +1010,6 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) RemoveElement(node, true); } -/////////////////////////////////////////////////////////////////////////////// -/// Remove an edge and all the elements which own this edge -/////////////////////////////////////////////////////////////////////////////// - -void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d) -{ - RemoveElement(elem0d,true); -} - -/////////////////////////////////////////////////////////////////////////////// -/// Remove an edge and all the elements which own this edge -/////////////////////////////////////////////////////////////////////////////// - -void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) -{ - RemoveElement(edge,true); -} - -/////////////////////////////////////////////////////////////////////////////// -/// Remove an face and all the elements which own this face -/////////////////////////////////////////////////////////////////////////////// - -void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) -{ - RemoveElement(face, true); -} - -/////////////////////////////////////////////////////////////////////////////// -/// Remove a volume -/////////////////////////////////////////////////////////////////////////////// - -void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) -{ - RemoveElement(volume, true); -} - //======================================================================= //function : RemoveFromParent //purpose : @@ -1857,7 +1030,7 @@ bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh) { bool found = false; - list::iterator itmsh=myChildren.begin(); + std::list::iterator itmsh=myChildren.begin(); for (; itmsh!=myChildren.end() && !found; itmsh++) { SMDS_Mesh * submesh = *itmsh; @@ -1880,28 +1053,27 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element, const SMDS_MeshNode * nodes[], const int nbnodes) { - // keep current nodes of elem - set oldNodes( element->begin_nodes(), element->end_nodes() ); + // keep current nodes of element + std::set oldNodes( element->begin_nodes(), element->end_nodes() ); // change nodes bool Ok = false; - SMDS_MeshCell* cell = dynamic_cast((SMDS_MeshElement*) element); - if (cell) - { - Ok = cell->vtkOrder(nodes, nbnodes); + if ( SMDS_MeshCell* cell = dynamic_cast((SMDS_MeshElement*) element)) Ok = cell->ChangeNodes(nodes, nbnodes); - } - if ( Ok ) { // update InverseElements + if ( Ok ) + setMyModified(); - set::iterator it; + if ( Ok && GetGrid()->HasLinks() ) // update InverseElements + { + std::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( cell ); + const_cast( nodes[i] )->AddInverseElement( element ); else // remove from oldNodes a node that remains in elem oldNodes.erase( it ); @@ -1910,84 +1082,13 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element, for ( it = oldNodes.begin(); it != oldNodes.end(); it++ ) { SMDS_MeshNode * n = const_cast( *it ); - n->RemoveInverseElement( cell ); + n->RemoveInverseElement( element ); } } 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_VtkVolume* 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 - // TODO remove this function - //bool Ok = const_cast(vol)->ChangeNodes(nodes, quantities); - bool Ok = false; - 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; -} - - -//======================================================================= -//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; @@ -2002,18 +1103,6 @@ const SMDS_Mesh0DElement* SMDS_Mesh::Find0DElement(const SMDS_MeshNode * node) return toReturn; } -//======================================================================= -//function : FindBall -//purpose : -//======================================================================= - -const SMDS_BallElement* SMDS_Mesh::FindBall(int idnode) const -{ - const SMDS_MeshNode * node = FindNode(idnode); - if(node == NULL) return NULL; - return FindBall(node); -} - const SMDS_BallElement* SMDS_Mesh::FindBall(const SMDS_MeshNode * node) { if (!node) return 0; @@ -2027,49 +1116,12 @@ const SMDS_BallElement* SMDS_Mesh::FindBall(const SMDS_MeshNode * node) 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 -//purpose : -//======================================================================= - -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); -} - -//#include "Profiler.h" const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1, 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 ) { @@ -2077,60 +1129,9 @@ const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1, break; } } - //PROFILER_Get(1); return toReturn; } - -//======================================================================= -//function : FindEdgeOrCreate -//purpose : -//======================================================================= - -SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1, - const SMDS_MeshNode * node2) -{ - if ( !node1 || !node2) return 0; - SMDS_MeshEdge * toReturn=NULL; - toReturn=const_cast(FindEdge(node1,node2)); - if(toReturn==NULL) { - if ( NbEdges() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element - adjustmyCellsCapacity(ID); - myNodeIds.resize(2); - myNodeIds[0] = node1->getVtkId(); - myNodeIds[1] = node2->getVtkId(); - - SMDS_VtkEdge *edgevtk = myEdgePool->getNew(); - edgevtk->init(myNodeIds, this); - if (!this->registerElement(ID,edgevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL); - myEdgePool->destroy(edgevtk); - return 0; - } - toReturn = edgevtk; - myCells[ID] = toReturn; - myInfo.myNbEdges++; - } - return toReturn; -} - - -//======================================================================= -//function : FindEdge -//purpose : -//======================================================================= - -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) @@ -2158,21 +1159,11 @@ const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1, return 0; } - //======================================================================= //function : FindFace //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); - return FindFace(node1, node2, node3); -} - const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, const SMDS_MeshNode *node2, const SMDS_MeshNode *node3) @@ -2200,35 +1191,11 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, 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 : 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); - return FindFace(node1, node2, node3, node4); -} - const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, const SMDS_MeshNode *node2, const SMDS_MeshNode *node3, @@ -2258,39 +1225,11 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, 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 : FindFace //purpose :quadratic triangle //======================================================================= -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, @@ -2330,22 +1269,6 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, //purpose : quadratic quadrangle //======================================================================= -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, @@ -2391,11 +1314,7 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const { - if ( IDelem <= 0 || IDelem >= (int)myCells.size() ) - { - return 0; - } - return myCells[IDelem]; + return myCellFactory->FindElement( IDelem ); } //======================================================================= @@ -2403,19 +1322,8 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const //purpose : find polygon //======================================================================= -const SMDS_MeshFace* SMDS_Mesh::FindFace (const vector& nodes_ids) const -{ - int nbnodes = nodes_ids.size(); - 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 (const vector& nodes) +const SMDS_MeshFace* SMDS_Mesh::FindFace (const std::vector& nodes) { return (const SMDS_MeshFace*) FindElement( nodes, SMDSAbs_Face ); } @@ -2431,7 +1339,7 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace (const vector& n */ //================================================================================ -const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector& nodes, +const SMDS_MeshElement* SMDS_Mesh::FindElement (const std::vector& nodes, const SMDSAbs_ElementType type, const bool noMedium) { @@ -2501,110 +1409,6 @@ int SMDS_Mesh::GetElementsByNodes(const std::vector& node return foundElems.size(); } -//======================================================================= -//function : DumpNodes -//purpose : -//======================================================================= - -void SMDS_Mesh::DumpNodes() const -{ - SMDS_NodeIteratorPtr itnode=nodesIterator(); - while(itnode->more()) ; //MESSAGE(itnode->next()); -} - -//======================================================================= -//function : Dump0DElements -//purpose : -//======================================================================= -void SMDS_Mesh::Dump0DElements() const -{ - SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement); - while(it0d->more()) ; //MESSAGE(it0d->next()); -} - -//======================================================================= -//function : DumpEdges -//purpose : -//======================================================================= - -void SMDS_Mesh::DumpEdges() const -{ - SMDS_EdgeIteratorPtr itedge=edgesIterator(); - while(itedge->more()) ; //MESSAGE(itedge->next()); -} - -//======================================================================= -//function : DumpFaces -//purpose : -//======================================================================= - -void SMDS_Mesh::DumpFaces() const -{ - SMDS_FaceIteratorPtr itface=facesIterator(); - while(itface->more()) ; //MESSAGE(itface->next()); -} - -//======================================================================= -//function : DumpVolumes -//purpose : -//======================================================================= - -void SMDS_Mesh::DumpVolumes() const -{ - SMDS_VolumeIteratorPtr itvol=volumesIterator(); - while(itvol->more()) ; //MESSAGE(itvol->next()); -} - -//======================================================================= -//function : DebugStats -//purpose : -//======================================================================= - -void SMDS_Mesh::DebugStats() const -{ - MESSAGE("Debug stats of mesh : "); - - MESSAGE("===== NODES ====="<more()) - { - const SMDS_MeshNode *node = itnode->next(); - - sizeofnodes += sizeof(*node); - - SMDS_ElemIteratorPtr it = node->GetInverseElementIterator(); - while(it->more()) - { - const SMDS_MeshElement *me = it->next(); - sizeofnodes += sizeof(me); - } - } - - SMDS_FaceIteratorPtr itface=facesIterator(); - while(itface->more()) - { - const SMDS_MeshElement *face = itface->next(); - sizeoffaces += sizeof(*face); - } - - MESSAGE("total size of node elements = " << sizeofnodes);; - MESSAGE("total size of face elements = " << sizeoffaces);; - - //#endif -} - /////////////////////////////////////////////////////////////////////////////// /// Return the number of nodes /////////////////////////////////////////////////////////////////////////////// @@ -2675,41 +1479,17 @@ int SMDS_Mesh::NbSubMesh() const /////////////////////////////////////////////////////////////////////////////// SMDS_Mesh::~SMDS_Mesh() { - list::iterator itc=myChildren.begin(); + std::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() ) - { - const SMDS_MeshElement *elem = eIt->next(); - myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId()); - } - SMDS_NodeIteratorPtr itn = nodesIterator(); - while (itn->more()) - { - const SMDS_MeshNode *node = itn->next(); - ((SMDS_MeshNode*)node)->SetPosition(SMDS_SpacePosition::originSpacePosition()); - myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId()); - } - } - myGrid->Delete(); + delete myNodeFactory; + delete myCellFactory; - delete myNodePool; - delete myVolumePool; - delete myFacePool; - delete myEdgePool; - delete myBallPool; + myGrid->Delete(); } //================================================================================ @@ -2720,46 +1500,14 @@ SMDS_Mesh::~SMDS_Mesh() void SMDS_Mesh::Clear() { - if (myParent!=NULL) - { - SMDS_ElemIteratorPtr eIt = elementsIterator(); - while ( eIt->more() ) - { - const SMDS_MeshElement *elem = eIt->next(); - myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId()); - } - SMDS_NodeIteratorPtr itn = nodesIterator(); - while (itn->more()) - { - const SMDS_MeshNode *node = itn->next(); - myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId()); - } - } - else - { - myNodeIDFactory->Clear(); - myElementIDFactory->Clear(); - } - - myVolumePool->clear(); - myFacePool->clear(); - myEdgePool->clear(); - myBallPool->clear(); - - clearVector( myCells ); - clearVector( myCellIdVtkToSmds ); + std::set< SMDS_ElementHolder* >::iterator holder = myElemHolders.begin(); + for ( ; holder != myElemHolders.end(); ++holder ) + (*holder)->clear(); - SMDS_NodeIteratorPtr itn = nodesIterator(); - while (itn->more()) - { - SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next()); - node->SetPosition(SMDS_SpacePosition::originSpacePosition()); - //myNodePool->destroy(node); - } - myNodePool->clear(); - clearVector( myNodes ); + myNodeFactory->Clear(); + myCellFactory->Clear(); - list::iterator itc=myChildren.begin(); + std::list::iterator itc=myChildren.begin(); while(itc!=myChildren.end()) (*itc)->Clear(); @@ -2776,189 +1524,36 @@ void SMDS_Mesh::Clear() vtkPoints* points = vtkPoints::New(); // rnv: to fix bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion" // using double type for storing coordinates of nodes instead float. - points->SetDataType(VTK_DOUBLE); - points->SetNumberOfPoints( 0 ); - myGrid->SetPoints( points ); - points->Delete(); - myGrid->DeleteLinks(); -} - -/////////////////////////////////////////////////////////////////////////////// -/// Return true if this mesh create faces with edges. -/// A false returned value mean that faces are created with nodes. A concequence -/// is, iteration on edges (SMDS_Element::edgesIterator) will be unavailable. -/////////////////////////////////////////////////////////////////////////////// -bool SMDS_Mesh::hasConstructionEdges() -{ - return myHasConstructionEdges; -} - -/////////////////////////////////////////////////////////////////////////////// -/// Return true if this mesh create volumes with faces -/// A false returned value mean that volumes are created with nodes or edges. -/// (see hasConstructionEdges) -/// A concequence is, iteration on faces (SMDS_Element::facesIterator) will be -/// unavailable. -/////////////////////////////////////////////////////////////////////////////// -bool SMDS_Mesh::hasConstructionFaces() -{ - return myHasConstructionFaces; -} - -/////////////////////////////////////////////////////////////////////////////// -/// Return true if nodes are linked to the finit elements, they are belonging to. -/// Currently, It always return true. -/////////////////////////////////////////////////////////////////////////////// -bool SMDS_Mesh::hasInverseElements() -{ - return myHasInverseElements; -} - -/////////////////////////////////////////////////////////////////////////////// -/// Make this mesh creating construction edges (see hasConstructionEdges) -/// @param b true to have construction edges, else false. -/////////////////////////////////////////////////////////////////////////////// -void SMDS_Mesh::setConstructionEdges(bool b) -{ - myHasConstructionEdges=b; -} - -/////////////////////////////////////////////////////////////////////////////// -/// Make this mesh creating construction faces (see hasConstructionFaces) -/// @param b true to have construction faces, else false. -/////////////////////////////////////////////////////////////////////////////// -void SMDS_Mesh::setConstructionFaces(bool b) -{ - myHasConstructionFaces=b; -} - -/////////////////////////////////////////////////////////////////////////////// -/// Make this mesh creating link from nodes to elements (see hasInverseElements) -/// @param b true to link nodes to elements, else false. -/////////////////////////////////////////////////////////////////////////////// -void SMDS_Mesh::setInverseElements(bool b) -{ - if(!b) MESSAGE("Error : inverseElement=false not implemented"); - myHasInverseElements=b; -} - -namespace { - - //================================================================================ - /*! - * \brief Iterator on elements in id increasing order - */ - //================================================================================ - - template - class IdSortedIterator : public SMDS_Iterator - { - SMDS_MeshElementIDFactory& myIDFact; - int myID, myMaxID, myNbFound, myTotalNb; - SMDSAbs_ElementType myType; - ELEM myElem; - - public: - IdSortedIterator(const SMDS_MeshElementIDFactory& fact, - const SMDSAbs_ElementType type, // SMDSAbs_All NOT allowed!!! - const int totalNb) - :myIDFact( const_cast(fact) ), - myID(1), myMaxID( myIDFact.GetMaxID() ),myNbFound(0), myTotalNb( totalNb ), - myType( type ), - myElem(0) - { - next(); - } - bool more() - { - return myElem; - } - ELEM next() - { - ELEM current = myElem; - - for ( myElem = 0; !myElem && myNbFound < myTotalNb && myID <= myMaxID; ++myID ) - if ((myElem = (ELEM) myIDFact.MeshElement( myID )) - && myElem->GetType() != myType ) - myElem = 0; - - myNbFound += bool(myElem); - - return current; - } - }; - - //================================================================================ - /*! - * \brief Iterator on vector of elements, possibly being resized while iteration - */ - //================================================================================ - - template > - class ElemVecIterator: public SMDS_Iterator - { - const std::vector& _vector; - size_t _index; - bool _more; - VALUE_FILTER _filter; - public: - ElemVecIterator(const std::vector& vec, - const VALUE_FILTER& filter=VALUE_FILTER() ) - :_vector( vec ), _index(0), _more( !vec.empty() ), _filter( filter ) - { - if ( _more && !_filter( _vector[ _index ])) - next(); - } - virtual bool more() - { - return _more; - } - virtual RETURN_VALUE next() - { - if ( !_more ) return NULL; - VECTOR_VALUE current = _vector[ _index ]; - _more = 0; - while ( !_more && ++_index < _vector.size() ) - _more = _filter( _vector[ _index ]); - return (RETURN_VALUE) current; - } - }; + points->SetDataType(VTK_DOUBLE); + points->SetNumberOfPoints( 0 ); + myGrid->SetPoints( points ); + points->Delete(); + myGrid->DeleteLinks(); } /////////////////////////////////////////////////////////////////////////////// /// Return an iterator on nodes of the current mesh factory /////////////////////////////////////////////////////////////////////////////// -SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator(bool idInceasingOrder) const +SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator() const { - // naturally always sorted by ID - typedef ElemVecIterator TIterator; - return SMDS_NodeIteratorPtr( new TIterator(myNodes)); + return myNodeFactory->GetIterator< SMDS_NodeIterator >( new SMDS_MeshElement::NonNullFilter ); } SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) const { - // naturally always sorted by ID - typedef ElemVecIterator - < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::GeomFilter > TIterator; - return SMDS_ElemIteratorPtr - (new TIterator(myCells, SMDS_MeshElement::GeomFilter( type ))); + return myCellFactory->GetIterator< SMDS_ElemIterator >( new SMDS_MeshElement::GeomFilter( type ), + myInfo.NbElements( type )); } SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) const { if ( type == SMDSEntity_Node ) { - typedef ElemVecIterator TIterator; - return SMDS_ElemIteratorPtr( new TIterator(myNodes)); + return myNodeFactory->GetIterator< SMDS_ElemIterator >( new SMDS_MeshElement::NonNullFilter ); } - // naturally always sorted by ID - typedef ElemVecIterator - < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::EntityFilter > TIterator; - return SMDS_ElemIteratorPtr - (new TIterator(myCells, SMDS_MeshElement::EntityFilter( type ))); + return myCellFactory->GetIterator( new SMDS_MeshElement::EntityFilter( type ), + myInfo.NbElements( type )); } /////////////////////////////////////////////////////////////////////////////// @@ -2966,20 +1561,18 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) c /////////////////////////////////////////////////////////////////////////////// SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const { - // naturally always sorted by ID + typedef SMDS_ElemIterator TIterator; switch ( type ) { case SMDSAbs_All: - return SMDS_ElemIteratorPtr (new ElemVecIterator(myCells)); + return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::NonNullFilter ); case SMDSAbs_Node: - return SMDS_ElemIteratorPtr - ( new ElemVecIterator( myNodes )); + return myNodeFactory->GetIterator< TIterator >( new SMDS_MeshElement::NonNullFilter ); default: - typedef ElemVecIterator - < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator; - return SMDS_ElemIteratorPtr (new TIterator(myCells, SMDS_MeshElement::TypeFilter( type ))); + return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( type ), + myInfo.NbElements( type )); } return SMDS_ElemIteratorPtr(); } @@ -2988,118 +1581,113 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const ///Return an iterator on edges of the current mesh. /////////////////////////////////////////////////////////////////////////////// -SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator(bool idInceasingOrder) const +SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const { - // naturally always sorted by ID - typedef ElemVecIterator - < const SMDS_MeshEdge*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator; - return SMDS_EdgeIteratorPtr - (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Edge ))); + typedef SMDS_EdgeIterator TIterator; + return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Edge ), + myInfo.NbEdges()); } /////////////////////////////////////////////////////////////////////////////// ///Return an iterator on faces of the current mesh. /////////////////////////////////////////////////////////////////////////////// -SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator(bool idInceasingOrder) const +SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const { - // naturally always sorted by ID - typedef ElemVecIterator - < const SMDS_MeshFace*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator; - return SMDS_FaceIteratorPtr - (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Face ))); + typedef SMDS_FaceIterator TIterator; + return myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Face ), + myInfo.NbFaces()); } /////////////////////////////////////////////////////////////////////////////// ///Return an iterator on volumes of the current mesh. /////////////////////////////////////////////////////////////////////////////// -SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator(bool idInceasingOrder) const +SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator() const +{ + typedef SMDS_VolumeIterator TIterator; + return + myCellFactory->GetIterator< TIterator >( new SMDS_MeshElement::TypeFilter( SMDSAbs_Volume ), + myInfo.NbVolumes()); +} + +SMDS_NodeIteratorPtr SMDS_Mesh::shapeNodesIterator(int shapeID, size_t nbElemsToReturn) const { - // naturally always sorted by ID - typedef ElemVecIterator - < const SMDS_MeshVolume*, SMDS_MeshCell*, SMDS_MeshElement::TypeFilter > TIterator; - return SMDS_VolumeIteratorPtr - (new TIterator(myCells, SMDS_MeshElement::TypeFilter( SMDSAbs_Volume ))); + return myNodeFactory->GetShapeIterator< SMDS_NodeIterator >( shapeID, nbElemsToReturn ); +} + +SMDS_ElemIteratorPtr SMDS_Mesh::shapeElementsIterator(int shapeID, size_t nbElemsToReturn) const +{ + return myCellFactory->GetShapeIterator< SMDS_ElemIterator >( shapeID, nbElemsToReturn ); } /////////////////////////////////////////////////////////////////////////////// /// Do intersection of sets (more than 2) /////////////////////////////////////////////////////////////////////////////// -static set * intersectionOfSets( - set vs[], int numberOfSets) +static std::set * +intersectionOfSets( std::set vs[], int numberOfSets ) { - set* rsetA=new set(vs[0]); - set* rsetB; + std::set* rsetA = new std::set(vs[0]); + std::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 finite elements owning the given element: elements /// containing all the nodes of the given element, for instance faces and /// volumes containing a given edge. /////////////////////////////////////////////////////////////////////////////// -static set * getFinitElements(const SMDS_MeshElement * element) +static std::set * getFinitElements(const SMDS_MeshElement * element) { int numberOfSets=element->NbNodes(); - set *initSet = new set[numberOfSets]; + std::set *initSet = new std::set[numberOfSets]; - SMDS_ElemIteratorPtr itNodes=element->nodesIterator(); + SMDS_NodeIteratorPtr itNodes = element->nodeIterator(); 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(); - - while ( itFe->more() ) - { - const SMDS_MeshElement* elem = itFe->next(); - MYASSERT(elem); - initSet[i].insert(elem); - } - + const SMDS_MeshNode * n = itNodes->next(); + for ( SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); itFe->more(); ) + initSet[i].insert( itFe->next() ); i++; } - set *retSet = intersectionOfSets( initSet, numberOfSets ); + std::set *retSet = intersectionOfSets( initSet, numberOfSets ); delete [] initSet; return retSet; } /////////////////////////////////////////////////////////////////////////////// -/// Return the list of nodes used only by the given elements +/// Return the std::list of nodes used only by the given elements /////////////////////////////////////////////////////////////////////////////// -static set * getExclusiveNodes(set& elements) +static +std::set *getExclusiveNodes(std::set& elements) { - set * toReturn=new set(); - set::iterator itElements=elements.begin(); + std::set * toReturn = new std::set(); + std::set::iterator itElements = elements.begin(); - while(itElements!=elements.end()) + while( itElements != elements.end() ) { - SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator(); + SMDS_NodeIteratorPtr itNodes = (*itElements)->nodeIterator(); itElements++; - while(itNodes->more()) + while( itNodes->more() ) { - const SMDS_MeshNode * n=static_cast(itNodes->next()); + const SMDS_MeshNode * n = itNodes->next(); SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); - set s; - while(itFe->more()) - s.insert(itFe->next()); - if(s==elements) toReturn->insert(n); + std::set s; + while ( itFe->more() ) + s.insert( itFe->next() ); + if ( s == elements ) toReturn->insert(n); } } return toReturn; @@ -3111,14 +1699,14 @@ static set * getExclusiveNodes(set& setOfChildren, - const SMDS_MeshElement * element, - set& nodes) +void SMDS_Mesh::addChildrenWithNodes(std::set& setOfChildren, + const SMDS_MeshElement * element, + std::set& nodes) { switch(element->GetType()) { case SMDSAbs_Node: - MESSAGE("Internal Error: This should not happen"); + throw SALOME_Exception("Internal Error: This should not happen"); break; case SMDSAbs_0DElement: case SMDSAbs_Ball: @@ -3150,28 +1738,8 @@ void SMDS_Mesh::addChildrenWithNodes(set& setOfChildren 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); - } - } case SMDSAbs_NbElementTypes: case SMDSAbs_All: break; } @@ -3182,10 +1750,10 @@ 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) + const bool removenodes) { - list removedElems; - list removedNodes; + std::vector removedElems; + std::vector removedNodes; RemoveElement( elem, removedElems, removedNodes, removenodes ); } @@ -3195,169 +1763,91 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, ///@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) +void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, + std::vector& removedElems, + std::vector& removedNodes, + bool removenodes) { // get finite elements built on elem - set * s1; + std::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); - } + || (elem->GetType() == SMDSAbs_Ball) + || (elem->GetType() == SMDSAbs_Edge) + || (elem->GetType() == SMDSAbs_Face) + || (elem->GetType() == SMDSAbs_Volume) ) + { + s1 = new std::set (); + s1->insert(elem); + } else s1 = getFinitElements(elem); // get exclusive nodes (which would become free afterwards) - set * s2; + std::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; - } + { + // do not remove nodes except elem + s2 = new std::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(); + std::set s3; + std::set::iterator it = s1->begin(); while (it != s1->end()) - { - addChildrenWithNodes(s3, *it, *s2); - s3.insert(*it); - it++; - } + { + 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()) + for( it = s3.begin();it != s3.end(); ++it ) + { + // Remove element from of its nodes + SMDS_NodeIteratorPtr itn = (*it)->nodeIterator(); + while (itn->more()) { - // 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)); - } - int IdToRemove = (*it)->GetID(); - int vtkid = (*it)->getVtkId(); - switch ((*it)->GetType()) - { - case SMDSAbs_Node: - MYASSERT("Internal Error: This should not happen"); - break; - case SMDSAbs_0DElement: - if (IdToRemove >= 0) - { - myCells[IdToRemove] = 0; // -PR- ici ou dans myElementIDFactory->ReleaseID ? - myInfo.remove(*it); - } - removedElems.push_back((*it)); - myElementIDFactory->ReleaseID(IdToRemove, vtkid); - delete (*it); - break; - case SMDSAbs_Edge: - if (IdToRemove >= 0) - { - myCells[IdToRemove] = 0; - myInfo.RemoveEdge(*it); - } - removedElems.push_back((*it)); - myElementIDFactory->ReleaseID(IdToRemove, vtkid); - if (const SMDS_VtkEdge* vtkElem = dynamic_cast(*it)) - myEdgePool->destroy((SMDS_VtkEdge*) vtkElem); - else { - ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse - delete (*it); - } - break; - case SMDSAbs_Face: - if (IdToRemove >= 0) - { - myCells[IdToRemove] = 0; - myInfo.RemoveFace(*it); - } - removedElems.push_back((*it)); - myElementIDFactory->ReleaseID(IdToRemove, vtkid); - if (const SMDS_VtkFace* vtkElem = dynamic_cast(*it)) - myFacePool->destroy((SMDS_VtkFace*) vtkElem); - else { - ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse - delete (*it); - } - break; - case SMDSAbs_Volume: - if (IdToRemove >= 0) - { - myCells[IdToRemove] = 0; - myInfo.RemoveVolume(*it); - } - removedElems.push_back((*it)); - myElementIDFactory->ReleaseID(IdToRemove, vtkid); - if (const SMDS_VtkVolume* vtkElem = dynamic_cast(*it)) - myVolumePool->destroy((SMDS_VtkVolume*) vtkElem); - else { - ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse - delete (*it); - } - break; - case SMDSAbs_Ball: - if (IdToRemove >= 0) - { - myCells[IdToRemove] = 0; - myInfo.remove(*it); - } - removedElems.push_back((*it)); - myElementIDFactory->ReleaseID(IdToRemove, vtkid); - if (const SMDS_BallElement* vtkElem = dynamic_cast(*it)) - myBallPool->destroy(const_cast( vtkElem )); - else { - ((SMDS_MeshElement*) *it)->init( 0, -1, -1 ); // avoid reuse - delete (*it); - } - break; + SMDS_MeshNode * n = const_cast (itn->next()); + n->RemoveInverseElement((*it)); + } - case SMDSAbs_All: // avoid compilation warning - case SMDSAbs_NbElementTypes: break; - } - if (vtkid >= 0) - { - this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); - } - it++; + int vtkid = (*it)->GetVtkID(); + + switch ((*it)->GetType()) { + case SMDSAbs_Node: + throw SALOME_Exception(LOCALIZED("Internal Error: This should not happen")); + break; + case SMDSAbs_Edge: myInfo.RemoveEdge(*it); break; + case SMDSAbs_Face: myInfo.RemoveFace(*it); break; + case SMDSAbs_Volume: myInfo.RemoveVolume(*it); break; + case SMDSAbs_Ball: myInfo.myNbBalls--; break; + case SMDSAbs_0DElement: myInfo.myNb0DElements--; break; + case SMDSAbs_All: // avoid compilation warning + case SMDSAbs_NbElementTypes: break; + } + + myCellFactory->Free( static_cast< const SMDS_MeshCell*>( *it )); + + if (vtkid >= 0) + { + this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); } + } // remove exclusive (free) nodes if (removenodes) { - it = s2->begin(); - while (it != s2->end()) + for ( it = s2->begin(); it != s2->end(); ++it ) { - int IdToRemove = (*it)->GetID(); - if (IdToRemove >= 0) - { - myNodes[IdToRemove] = 0; - myInfo.myNbNodes--; - } - myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId()); + myInfo.myNbNodes--; + myNodeFactory->Free( (*it) ); removedNodes.push_back((*it)); - if (const SMDS_MeshNode* vtkElem = dynamic_cast(*it)) - { - ((SMDS_MeshNode*)vtkElem)->SetPosition(SMDS_SpacePosition::originSpacePosition()); - myNodePool->destroy((SMDS_MeshNode*) vtkElem); - } - else - delete (*it); - it++; } } @@ -3371,95 +1861,60 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, /////////////////////////////////////////////////////////////////////////////// void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) { - int elemId = elem->GetID(); - int vtkId = elem->getVtkId(); + const int vtkId = elem->GetVtkID(); 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); + const SMDS_MeshNode* n = static_cast( elem ); if ( n->NbInverseElements() == 0 ) { // free node - myNodes[elemId] = 0; myInfo.myNbNodes--; - ((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition()); - ((SMDS_MeshNode*) n)->SMDS_MeshElement::init( 0, -1, -1 ); // avoid reuse - myNodePool->destroy(static_cast(todest)); - myNodeIDFactory->ReleaseID(elemId, vtkId); + myNodeFactory->Free( n ); + } + else + { + throw SALOME_Exception( LOCALIZED( "RemoveFreeElement: not a free node" )); } } else { - if (hasConstructionEdges() || hasConstructionFaces()) - // this methods is only for meshes without descendants - return; - // Remove element from of its nodes - SMDS_ElemIteratorPtr itn = elem->nodesIterator(); + SMDS_NodeIteratorPtr itn = elem->nodeIterator(); while (itn->more()) { - SMDS_MeshNode * n = static_cast - (const_cast(itn->next())); + SMDS_MeshNode * n = 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; - elem = 0; - 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; - case SMDSAbs_Ball: - myCells[elemId] = 0; - myInfo.remove(elem); - myBallPool->destroy(static_cast(todest)); - break; - default: - break; + case SMDSAbs_0DElement: myInfo.remove(elem); break; + case SMDSAbs_Edge: myInfo.RemoveEdge(elem); break; + case SMDSAbs_Face: myInfo.RemoveFace(elem); break; + case SMDSAbs_Volume: myInfo.RemoveVolume(elem); break; + case SMDSAbs_Ball: myInfo.remove(elem); break; + default: break; } - myElementIDFactory->ReleaseID(elemId, vtkId); + myCellFactory->Free( elem ); this->myGrid->GetCellTypesArray()->SetValue(vtkId, VTK_EMPTY_CELL); - // --- to do: keep vtkid in a list of reusable cells - - if ( elem ) - ((SMDS_MeshElement*) elem)->init( 0, -1, -1 ); // avoid reuse } } +//======================================================================= /*! * Checks if the element is present in mesh. - * Useful to determine dead pointers. */ +//======================================================================= + bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const { - // we should not rely 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_ElemIteratorPtr ite = elementsIterator(); - while (ite->more()) - if (elem == ite->next()) - return true; - return false; + if ( !elem || elem->IsNull() ) + return false; + + if ( elem->GetType() == SMDSAbs_Node ) + return ( elem == myNodeFactory->FindElement( elem->GetID() )); + + return ( elem == myCellFactory->FindElement( elem->GetID() )); } //======================================================================= @@ -3469,7 +1924,7 @@ bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const int SMDS_Mesh::MaxNodeID() const { - return myNodeIDFactory->GetMaxID(); + return myNodeFactory->GetMaxID(); } //======================================================================= @@ -3479,7 +1934,7 @@ int SMDS_Mesh::MaxNodeID() const int SMDS_Mesh::MinNodeID() const { - return myNodeIDFactory->GetMinID(); + return myNodeFactory->GetMinID(); } //======================================================================= @@ -3489,7 +1944,7 @@ int SMDS_Mesh::MinNodeID() const int SMDS_Mesh::MaxElementID() const { - return myElementIDFactory->GetMaxID(); + return myCellFactory->GetMaxID(); } //======================================================================= @@ -3499,7 +1954,7 @@ int SMDS_Mesh::MaxElementID() const int SMDS_Mesh::MinElementID() const { - return myElementIDFactory->GetMinID(); + return myCellFactory->GetMinID(); } //======================================================================= @@ -3507,39 +1962,12 @@ int SMDS_Mesh::MinElementID() const //purpose : Renumber all nodes or elements. //======================================================================= -void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID) -{ - if ( deltaID == 0 ) - return; - - SMDS_MeshNodeIDFactory * idFactory = - isNodes ? myNodeIDFactory : myElementIDFactory; +// void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID) +// { +// if ( deltaID == 0 ) +// return; - // 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 @@ -3548,19 +1976,13 @@ void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int del SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) const { - SMDS_MeshElement* elem = 0; + const SMDS_MeshElement* elem = 0; if( iselem ) - elem = myElementIDFactory->MeshElement( id ); + elem = myCellFactory->FindElement( id ); else - elem = myNodeIDFactory->MeshElement( id ); + elem = myNodeFactory->FindElement( id ); - if( !elem ) - { - //throw SALOME_Exception(LOCALIZED ("this element isn't exist")); - return SMDSAbs_All; - } - else - return elem->GetType(); + return elem ? elem->GetType() : SMDSAbs_All; } @@ -3579,11 +2001,10 @@ SMDSAbs_ElementType SMDS_Mesh::GetElementType( const int id, const bool iselem ) //======================================================================= 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); + return SMDS_Mesh::AddEdgeWithID (myNodeFactory->FindNode(n1), + myNodeFactory->FindNode(n2), + myNodeFactory->FindNode(n12), + ID); } //======================================================================= @@ -3594,7 +2015,7 @@ 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()); + return SMDS_Mesh::AddEdgeWithID(n1, n2, n12, myCellFactory->GetFreeID()); } //======================================================================= @@ -3604,36 +2025,17 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdge(const SMDS_MeshNode* n1, SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n2, const SMDS_MeshNode * n12, - int ID) + int ID) { if ( !n1 || !n2 || !n12 ) return 0; - // --- retrieve nodes ID - myNodeIds.resize(3); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n12->getVtkId(); - - SMDS_MeshEdge * edge = 0; - SMDS_VtkEdge *edgevtk = myEdgePool->getNew(); - edgevtk->init(myNodeIds, this); - if (!this->registerElement(ID,edgevtk)) + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL); - myEdgePool->destroy(edgevtk); - return 0; + cell->init( SMDSEntity_Quad_Edge, /*nbNodes=*/3, n1, n2, n12 ); + myInfo.myNbQuadEdges++; + return static_cast( cell ); } - edge = edgevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = edge; - myInfo.myNbQuadEdges++; - - // if (!registerElement(ID, edge)) { - // RemoveElement(edge, false); - // edge = NULL; - // } - return edge; - + return 0; } @@ -3649,7 +2051,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, const SMDS_MeshNode * n31) { return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31, - myElementIDFactory->GetFreeID()); + myCellFactory->GetFreeID()); } //======================================================================= @@ -3659,14 +2061,13 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, 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); + return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n31), + ID); } //======================================================================= @@ -3681,42 +2082,16 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, 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 + if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 ) return 0; + if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - // --- retrieve nodes ID - myNodeIds.resize(6); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n12->getVtkId(); - myNodeIds[4] = n23->getVtkId(); - myNodeIds[5] = n31->getVtkId(); - - SMDS_MeshFace * face = 0; - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; + cell->init( SMDSEntity_Quad_Triangle, /*nbNodes=*/6, n1, n2, n3, n12, n23, n31 ); myInfo.myNbQuadTriangles++; - - // if (!registerElement(ID, face)) { - // RemoveElement(face, false); - // face = NULL; - // } - return face; + return static_cast( cell ); } + return 0; } @@ -3733,7 +2108,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, const SMDS_MeshNode * nCenter) { return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter, - myElementIDFactory->GetFreeID()); + myCellFactory->GetFreeID()); } //======================================================================= @@ -3743,15 +2118,14 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n12,int n23,int n31, int nCenter, 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), - (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter), - ID); + return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n31), + myNodeFactory->FindNode(nCenter), + ID); } //======================================================================= @@ -3768,42 +2142,15 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, int ID) { if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 || !nCenter) return 0; - if(hasConstructionEdges()) { - // creation quadratic edges - not implemented - return 0; - } - else + if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - // --- retrieve nodes ID - myNodeIds.resize(7); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n12->getVtkId(); - myNodeIds[4] = n23->getVtkId(); - myNodeIds[5] = n31->getVtkId(); - myNodeIds[6] = nCenter->getVtkId(); - - SMDS_MeshFace * face = 0; - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; + cell->init( SMDSEntity_BiQuad_Triangle, /*nbNodes=*/7, n1, n2, n3, n12, n23, n31, nCenter ); myInfo.myNbBiQuadTriangles++; - - // if (!registerElement(ID, face)) { - // RemoveElement(face, false); - // face = NULL; - // } - return face; + return static_cast( cell ); } + return 0; } @@ -3821,7 +2168,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, const SMDS_MeshNode * n41) { return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41, - myElementIDFactory->GetFreeID()); + myCellFactory->GetFreeID()); } //======================================================================= @@ -3831,16 +2178,15 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, 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); + return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n4) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n34), + myNodeFactory->FindNode(n41), + ID); } //======================================================================= @@ -3858,43 +2204,15 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, int ID) { if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0; - if(hasConstructionEdges()) { - // creation quadratic edges - not implemented - return 0; - } - else + if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - // --- retrieve nodes ID - myNodeIds.resize(8); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n4->getVtkId(); - myNodeIds[4] = n12->getVtkId(); - myNodeIds[5] = n23->getVtkId(); - myNodeIds[6] = n34->getVtkId(); - myNodeIds[7] = n41->getVtkId(); - - SMDS_MeshFace * face = 0; - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; + cell->init( SMDSEntity_Quad_Quadrangle, /*nbNodes=*/8, n1, n2, n3, n4, n12, n23, n34, n41 ); myInfo.myNbQuadQuadrangles++; - - // if (!registerElement(ID, face)) { - // RemoveElement(face, false); - // face = NULL; - // } - return face; + return static_cast( cell ); } + return 0; } //======================================================================= @@ -3912,7 +2230,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, const SMDS_MeshNode * nCenter) { return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter, - myElementIDFactory->GetFreeID()); + myCellFactory->GetFreeID()); } //======================================================================= @@ -3922,17 +2240,16 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1, SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int n12,int n23,int n34,int n41, int nCenter, 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), - (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter), - ID); + return SMDS_Mesh::AddFaceWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n4) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n34), + myNodeFactory->FindNode(n41), + myNodeFactory->FindNode(nCenter), + ID); } //======================================================================= @@ -3951,44 +2268,16 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, int ID) { if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41 || !nCenter) return 0; - if(hasConstructionEdges()) { - // creation quadratic edges - not implemented - return 0; - } - else + if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - // --- retrieve nodes ID - myNodeIds.resize(9); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n4->getVtkId(); - myNodeIds[4] = n12->getVtkId(); - myNodeIds[5] = n23->getVtkId(); - myNodeIds[6] = n34->getVtkId(); - myNodeIds[7] = n41->getVtkId(); - myNodeIds[8] = nCenter->getVtkId(); - - SMDS_MeshFace * face = 0; - SMDS_VtkFace *facevtk = myFacePool->getNew(); - facevtk->init(myNodeIds, this); - if (!this->registerElement(ID,facevtk)) - { - this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); - myFacePool->destroy(facevtk); - return 0; - } - face = facevtk; - adjustmyCellsCapacity(ID); - myCells[ID] = face; + cell->init( SMDSEntity_BiQuad_Quadrangle, + /*nbNodes=*/9, n1, n2, n3, n4, n12, n23, n34, n41, nCenter ); myInfo.myNbBiQuadQuadrangles++; - - // if (!registerElement(ID, face)) { - // RemoveElement(face, false); - // face = NULL; - // } - return face; + return static_cast( cell ); } + return 0; } @@ -4007,11 +2296,8 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, 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; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n12, n23, + n31, n14, n24, n34, myCellFactory->GetFreeID()); } //======================================================================= @@ -4022,18 +2308,17 @@ 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); + return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n4) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n31), + myNodeFactory->FindNode(n14), + myNodeFactory->FindNode(n24), + myNodeFactory->FindNode(n34), + ID); } //======================================================================= @@ -4054,42 +2339,16 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, { 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 - myNodeIds.resize(10); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n3->getVtkId(); - myNodeIds[2] = n2->getVtkId(); - myNodeIds[3] = n4->getVtkId(); - - myNodeIds[4] = n31->getVtkId(); - myNodeIds[5] = n23->getVtkId(); - myNodeIds[6] = n12->getVtkId(); - - myNodeIds[7] = n14->getVtkId(); - myNodeIds[8] = n34->getVtkId(); - myNodeIds[9] = n24->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) + if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; + cell->init( SMDSEntity_Quad_Tetra, + /*nbNodes=*/10, n1, n2, n3, n4, n12, n23, n31, n14, n24, n34 ); + myInfo.myNbQuadTetras++; + return static_cast( cell ); } - adjustmyCellsCapacity(ID); - myCells[ID] = volvtk; - myInfo.myNbQuadTetras++; - - // if (!registerElement(ID, volvtk)) { - // RemoveElement(volvtk, false); - // volvtk = NULL; - // } - return volvtk; + return 0; } @@ -4111,12 +2370,8 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, 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; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n12, n23, n34, n41, + n15, n25, n35, n45, myCellFactory->GetFreeID()); } //======================================================================= @@ -4127,21 +2382,20 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int 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); + return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n4) , + myNodeFactory->FindNode(n5) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n34), + myNodeFactory->FindNode(n41), + myNodeFactory->FindNode(n15), + myNodeFactory->FindNode(n25), + myNodeFactory->FindNode(n35), + myNodeFactory->FindNode(n45), + ID); } //======================================================================= @@ -4166,51 +2420,22 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, 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 - myNodeIds.resize(13); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n4->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n2->getVtkId(); - myNodeIds[4] = n5->getVtkId(); - - myNodeIds[5] = n41->getVtkId(); - myNodeIds[6] = n34->getVtkId(); - myNodeIds[7] = n23->getVtkId(); - myNodeIds[8] = n12->getVtkId(); - - myNodeIds[9] = n15->getVtkId(); - myNodeIds[10] = n45->getVtkId(); - myNodeIds[11] = n35->getVtkId(); - myNodeIds[12] = n25->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) + if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; + cell->init( SMDSEntity_Quad_Pyramid, + /*nbNodes=*/13, n1, n2, n3, n4, n5, n12, n23, n34, n41, n15, n25, n35, n45); + myInfo.myNbQuadPyramids++; + return static_cast( cell ); } - adjustmyCellsCapacity(ID); - myCells[ID] = volvtk; - myInfo.myNbQuadPyramids++; - - // if (!registerElement(ID, volvtk)) { - // RemoveElement(volvtk, false); - // volvtk = NULL; - // } - return volvtk; + return 0; } //======================================================================= //function : AddVolume -//purpose : +//purpose : 2d order Pentahedron (prism) with 15 nodes //======================================================================= SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n2, @@ -4228,17 +2453,13 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, 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; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31, + n45, n56, n64, n14, n25, n36, myCellFactory->GetFreeID()); } //======================================================================= //function : AddVolumeWithID -//purpose : +//purpose : 2d order Pentahedron (prism) with 15 nodes //======================================================================= SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, @@ -4246,28 +2467,27 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, 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); + return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n4) , + myNodeFactory->FindNode(n5) , + myNodeFactory->FindNode(n6) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n31), + myNodeFactory->FindNode(n45), + myNodeFactory->FindNode(n56), + myNodeFactory->FindNode(n64), + myNodeFactory->FindNode(n14), + myNodeFactory->FindNode(n25), + myNodeFactory->FindNode(n36), + ID); } //======================================================================= //function : AddVolumeWithID -//purpose : 2d order Pentahedron with 15 nodes +//purpose : 2d order Pentahedron (prism) with 15 nodes //======================================================================= SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n2, @@ -4289,49 +2509,116 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, 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 - myNodeIds.resize(15); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n2->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - - myNodeIds[3] = n4->getVtkId(); - myNodeIds[4] = n5->getVtkId(); - myNodeIds[5] = n6->getVtkId(); - - myNodeIds[6] = n12->getVtkId(); - myNodeIds[7] = n23->getVtkId(); - myNodeIds[8] = n31->getVtkId(); - - myNodeIds[9] = n45->getVtkId(); - myNodeIds[10] = n56->getVtkId(); - myNodeIds[11] = n64->getVtkId(); - - myNodeIds[12] = n14->getVtkId(); - myNodeIds[13] = n25->getVtkId(); - myNodeIds[14] = n36->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) + if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; + cell->init( SMDSEntity_Quad_Penta, /*nbNodes=*/15, + n1, n2, n3, n4, n5, n6, n12, n23, n31, n45, n56, n64, n14, n25, n36 ); + myInfo.myNbQuadPrisms++; + return static_cast( cell ); } - adjustmyCellsCapacity(ID); - myCells[ID] = volvtk; - myInfo.myNbQuadPrisms++; + return 0; +} - // if (!registerElement(ID, volvtk)) { - // RemoveElement(volvtk, false); - // volvtk = NULL; - // } - return volvtk; +//======================================================================= +//function : AddVolume +//purpose : 2d order Pentahedron (prism) with 18 nodes +//======================================================================= +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, + const SMDS_MeshNode * n1245, + const SMDS_MeshNode * n2356, + const SMDS_MeshNode * n1346) +{ + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n12, n23, n31, + n45, n56, n64, n14, n25, n36, n1245, n2356, n1346, + myCellFactory->GetFreeID()); +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : 2d order Pentahedron (prism) with 18 nodes +//======================================================================= +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 n1245, int n2356, int n1346, int ID) +{ + return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1) , + myNodeFactory->FindNode(n2) , + myNodeFactory->FindNode(n3) , + myNodeFactory->FindNode(n4) , + myNodeFactory->FindNode(n5) , + myNodeFactory->FindNode(n6) , + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n31), + myNodeFactory->FindNode(n45), + myNodeFactory->FindNode(n56), + myNodeFactory->FindNode(n64), + myNodeFactory->FindNode(n14), + myNodeFactory->FindNode(n25), + myNodeFactory->FindNode(n36), + myNodeFactory->FindNode(n1245), + myNodeFactory->FindNode(n2356), + myNodeFactory->FindNode(n1346), + ID); +} + +//======================================================================= +//function : AddVolumeWithID +//purpose : 2d order Pentahedron (prism) with 18 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, + const SMDS_MeshNode * n1245, + const SMDS_MeshNode * n2356, + const SMDS_MeshNode * n1346, + int ID) +{ + //MESSAGE("AddVolumeWithID penta18 "<< ID); + if (!n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n12 || !n23 || + !n31 || !n45 || !n56 || !n64 || !n14 || !n25 || !n36 || !n1245 || !n2356 || !n1346) + return 0; + if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) + { + cell->init( SMDSEntity_BiQuad_Penta, /*nbNodes=*/18, n1, n2, n3, n4, n5, n6, + n12, n23, n31, n45, n56, n64, n14, n25, n36, n1245, n2356, n1346 ); + myInfo.myNbBiQuadPrisms++; + return static_cast( cell ); + } + return 0; } @@ -4360,12 +2647,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, 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; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41, + n56, n67, n78, n85, n15, n26, n37, n48, + myCellFactory->GetFreeID()); } //======================================================================= @@ -4378,28 +2662,27 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, 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); + return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1), + myNodeFactory->FindNode(n2), + myNodeFactory->FindNode(n3), + myNodeFactory->FindNode(n4), + myNodeFactory->FindNode(n5), + myNodeFactory->FindNode(n6), + myNodeFactory->FindNode(n7), + myNodeFactory->FindNode(n8), + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n34), + myNodeFactory->FindNode(n41), + myNodeFactory->FindNode(n56), + myNodeFactory->FindNode(n67), + myNodeFactory->FindNode(n78), + myNodeFactory->FindNode(n85), + myNodeFactory->FindNode(n15), + myNodeFactory->FindNode(n26), + myNodeFactory->FindNode(n37), + myNodeFactory->FindNode(n48), + ID); } //======================================================================= @@ -4431,54 +2714,16 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, 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 - myNodeIds.resize(20); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n4->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n2->getVtkId(); - - myNodeIds[4] = n5->getVtkId(); - myNodeIds[5] = n8->getVtkId(); - myNodeIds[6] = n7->getVtkId(); - myNodeIds[7] = n6->getVtkId(); - - myNodeIds[8] = n41->getVtkId(); - myNodeIds[9] = n34->getVtkId(); - myNodeIds[10] = n23->getVtkId(); - myNodeIds[11] = n12->getVtkId(); - - myNodeIds[12] = n85->getVtkId(); - myNodeIds[13] = n78->getVtkId(); - myNodeIds[14] = n67->getVtkId(); - myNodeIds[15] = n56->getVtkId(); - - myNodeIds[16] = n15->getVtkId(); - myNodeIds[17] = n48->getVtkId(); - myNodeIds[18] = n37->getVtkId(); - myNodeIds[19] = n26->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) + if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; + cell->init( SMDSEntity_Quad_Hexa, /*nbNodes=*/20, n1, n2, n3, n4, n5, n6, n7, n8, + n12, n23, n34, n41, n56, n67, n78, n85, n15, n26, n37, n48 ); + myInfo.myNbQuadHexas++; + return static_cast( cell ); } - adjustmyCellsCapacity(ID); - myCells[ID] = volvtk; - myInfo.myNbQuadHexas++; - - // if (!registerElement(ID, volvtk)) { - // RemoveElement(volvtk, false); - // volvtk = NULL; - // } - return volvtk; + return 0; } //======================================================================= @@ -4513,14 +2758,10 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n5678, const SMDS_MeshNode * nCenter) { - 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, - n1234, n1256, n2367, n3478, n1458, n5678, nCenter, - ID); - if(v==NULL) myElementIDFactory->ReleaseID(ID); - return v; + return SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n12, n23, n34, n41, + n56, n67, n78, n85, n15, n26, n37, n48, + n1234, n1256, n2367, n3478, n1458, n5678, nCenter, + myCellFactory->GetFreeID()); } //======================================================================= @@ -4535,40 +2776,39 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n1234,int n1256,int n2367,int n3478, int n1458,int n5678,int nCenter, 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), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1234), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1256), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n2367), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n3478), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n1458), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(n5678), - (SMDS_MeshNode*) myNodeIDFactory->MeshElement(nCenter), - ID); + return SMDS_Mesh::AddVolumeWithID (myNodeFactory->FindNode(n1), + myNodeFactory->FindNode(n2), + myNodeFactory->FindNode(n3), + myNodeFactory->FindNode(n4), + myNodeFactory->FindNode(n5), + myNodeFactory->FindNode(n6), + myNodeFactory->FindNode(n7), + myNodeFactory->FindNode(n8), + myNodeFactory->FindNode(n12), + myNodeFactory->FindNode(n23), + myNodeFactory->FindNode(n34), + myNodeFactory->FindNode(n41), + myNodeFactory->FindNode(n56), + myNodeFactory->FindNode(n67), + myNodeFactory->FindNode(n78), + myNodeFactory->FindNode(n85), + myNodeFactory->FindNode(n15), + myNodeFactory->FindNode(n26), + myNodeFactory->FindNode(n37), + myNodeFactory->FindNode(n48), + myNodeFactory->FindNode(n1234), + myNodeFactory->FindNode(n1256), + myNodeFactory->FindNode(n2367), + myNodeFactory->FindNode(n3478), + myNodeFactory->FindNode(n1458), + myNodeFactory->FindNode(n5678), + myNodeFactory->FindNode(nCenter), + ID); } //======================================================================= //function : AddVolumeWithID -//purpose : 2d order Hexahedrons with 20 nodes +//purpose : 2d order Hexahedrons with 27 nodes //======================================================================= SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n2, @@ -4603,61 +2843,20 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, !n34 || !n41 || !n56 || !n67 || !n78 || !n85 || !n15 || !n26 || !n37 || !n48 || !n1234 || !n1256 || !n2367 || !n3478 || !n1458 || !n5678 || !nCenter ) return 0; - if(hasConstructionFaces()) { - return 0; - // creation quadratic faces - not implemented - } - // --- retrieve nodes ID - myNodeIds.resize(27); - myNodeIds[0] = n1->getVtkId(); - myNodeIds[1] = n4->getVtkId(); - myNodeIds[2] = n3->getVtkId(); - myNodeIds[3] = n2->getVtkId(); - - myNodeIds[4] = n5->getVtkId(); - myNodeIds[5] = n8->getVtkId(); - myNodeIds[6] = n7->getVtkId(); - myNodeIds[7] = n6->getVtkId(); - - myNodeIds[8] = n41->getVtkId(); - myNodeIds[9] = n34->getVtkId(); - myNodeIds[10] = n23->getVtkId(); - myNodeIds[11] = n12->getVtkId(); - - myNodeIds[12] = n85->getVtkId(); - myNodeIds[13] = n78->getVtkId(); - myNodeIds[14] = n67->getVtkId(); - myNodeIds[15] = n56->getVtkId(); - - myNodeIds[16] = n15->getVtkId(); - myNodeIds[17] = n48->getVtkId(); - myNodeIds[18] = n37->getVtkId(); - myNodeIds[19] = n26->getVtkId(); - - myNodeIds[20] = n1256->getVtkId(); - myNodeIds[21] = n3478->getVtkId(); - myNodeIds[22] = n1458->getVtkId(); - myNodeIds[23] = n2367->getVtkId(); - myNodeIds[24] = n1234->getVtkId(); - myNodeIds[25] = n5678->getVtkId(); - myNodeIds[26] = nCenter->getVtkId(); - - SMDS_VtkVolume *volvtk = myVolumePool->getNew(); - volvtk->init(myNodeIds, this); - if (!this->registerElement(ID,volvtk)) + if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); + + if ( SMDS_MeshCell* cell = myCellFactory->NewCell( ID )) { - this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); - myVolumePool->destroy(volvtk); - return 0; + cell->init( SMDSEntity_TriQuad_Hexa, /*nbNodes=*/27, n1, n2, n3, n4, n5, n6, n7, n8, + n12, n23, n34, n41, n56, n67, n78, n85, n15, n26, n37, n48, + n1234, n1256, n2367, n3478, n1458, n5678, nCenter); + myInfo.myNbTriQuadHexas++; + return static_cast( cell ); } - adjustmyCellsCapacity(ID); - myCells[ID] = volvtk; - myInfo.myNbTriQuadHexas++; - - return volvtk; + return 0; } -void SMDS_Mesh::dumpGrid(string ficdump) +void SMDS_Mesh::dumpGrid(std::string ficdump) { // vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); // aWriter->SetFileName(ficdump.c_str()); @@ -4668,7 +2867,7 @@ void SMDS_Mesh::dumpGrid(string ficdump) // } // aWriter->Delete(); ficdump = ficdump + "_connectivity"; - ofstream ficcon(ficdump.c_str(), ios::out); + std::ofstream ficcon(ficdump.c_str(), ios::out); int nbPoints = myGrid->GetNumberOfPoints(); ficcon << "-------------------------------- points " << nbPoints << endl; for (int i=0; imyCompactTime = this->myModifTime; + + bool idsChange = ( myNodeFactory->CompactChangePointers() || + myCellFactory->CompactChangePointers() ); + if ( idsChange ) + { + std::set< SMDS_ElementHolder* >::iterator holder = myElemHolders.begin(); + for ( ; holder != myElemHolders.end(); ++holder ) + (*holder)->beforeCompacting(); + } + int oldCellSize = myCellFactory->GetMaxID(); + + // remove "holes" in SMDS numeration + std::vector idNodesOldToNew, idCellsNewToOld, idCellsOldToNew; + myNodeFactory->Compact( idNodesOldToNew ); + myCellFactory->Compact( idCellsNewToOld ); + + // make VTK IDs correspond to SMDS IDs + int newNodeSize = myNodeFactory->NbUsedElements(); + int newCellSize = myCellFactory->NbUsedElements(); + myGrid->compactGrid( idNodesOldToNew, newNodeSize, idCellsNewToOld, newCellSize ); + + if ( idsChange && !myElemHolders.empty() ) + { + // idCellsNewToOld -> idCellsOldToNew + idCellsOldToNew.resize( oldCellSize, oldCellSize ); + for ( size_t iNew = 0; iNew < idCellsNewToOld.size(); ++iNew ) + { + if ( idCellsNewToOld[ iNew ] >= (int) idCellsOldToNew.size() ) + idCellsOldToNew.resize( ( 1 + idCellsNewToOld[ iNew ]) * 1.5, oldCellSize ); + idCellsOldToNew[ idCellsNewToOld[ iNew ]] = iNew; + } + } + + std::set< SMDS_ElementHolder* >::iterator holder = myElemHolders.begin(); + for ( ; holder != myElemHolders.end(); ++holder ) + if ( idsChange ) + (*holder)->restoreElements( idNodesOldToNew, idCellsOldToNew ); + else + (*holder)->compact(); + + return; } -int SMDS_Mesh::fromVtkToSmds(int vtkid) +int SMDS_Mesh::FromVtkToSmds( int vtkid ) const { - if (vtkid >= 0 && vtkid < (int)myCellIdVtkToSmds.size()) - return myCellIdVtkToSmds[vtkid]; - throw SALOME_Exception(LOCALIZED ("vtk id out of bounds")); + return myCellFactory->FromVtkToSmds( vtkid ); } -// void SMDS_Mesh::updateBoundingBox() -// { -// xmin = 0; xmax = 0; -// ymin = 0; ymax = 0; -// zmin = 0; zmax = 0; -// vtkPoints *points = myGrid->GetPoints(); -// int myNodesSize = this->myNodes.size(); -// for (int i = 0; i < myNodesSize; i++) -// { -// if (SMDS_MeshNode *n = myNodes[i]) -// { -// double coords[3]; -// points->GetPoint(n->myVtkID, coords); -// if (coords[0] < xmin) xmin = coords[0]; -// else if (coords[0] > xmax) xmax = coords[0]; -// if (coords[1] < ymin) ymin = coords[1]; -// else if (coords[1] > ymax) ymax = coords[1]; -// if (coords[2] < zmin) zmin = coords[2]; -// else if (coords[2] > zmax) zmax = coords[2]; -// } -// } -// } - double SMDS_Mesh::getMaxDim() { double dmax = 1.e-3; @@ -4765,7 +2980,12 @@ vtkMTimeType SMDS_Mesh::GetMTime() const return this->myModifTime; } -bool SMDS_Mesh::isCompacted() +bool SMDS_Mesh::IsCompacted() +{ + return ( this->myCompactTime == this->myModifTime ); +} + +void SMDS_Mesh::setNbShapes( size_t nbShapes ) { - return this->myCompactTime == this->myModifTime; + myNodeFactory->SetNbShapes( nbShapes ); }