X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=6582e23f156cf269ea2239d2131d406fec87b328;hp=823936204b6775186f5e724f30a85d274ca4c863;hb=f3e2b7fea2d36b7dbe2df39f3e08e9c4d9b30e6d;hpb=f1013bf7248e1d093c9a5865acbe74f6f98140b6 diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx index 823936204..6582e23f1 100644 --- a/src/SMDS/SMDS_Mesh.cxx +++ b/src/SMDS/SMDS_Mesh.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE // // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -124,16 +124,16 @@ int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc) /////////////////////////////////////////////////////////////////////////////// /// Create a new mesh object /////////////////////////////////////////////////////////////////////////////// -SMDS_Mesh::SMDS_Mesh() - :myParent(NULL), - myNodeIDFactory(new SMDS_MeshNodeIDFactory()), - myElementIDFactory(new SMDS_MeshElementIDFactory()), - myHasConstructionEdges(false), myHasConstructionFaces(false), - myHasInverseElements(true), - myNodeMin(0), myNodeMax(0), - myNodePool(0), myEdgePool(0), myFacePool(0), myVolumePool(0),myBallPool(0), - myModified(false), myModifTime(0), myCompactTime(0), - xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0) +SMDS_Mesh::SMDS_Mesh(): + myNodePool(0), myVolumePool(0), myFacePool(0), myEdgePool(0), myBallPool(0), + myParent(NULL), + myNodeIDFactory(new SMDS_MeshNodeIDFactory()), + myElementIDFactory(new SMDS_MeshElementIDFactory()), + myModified(false), myModifTime(0), myCompactTime(0), + myNodeMin(0), myNodeMax(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); @@ -169,16 +169,16 @@ SMDS_Mesh::SMDS_Mesh() /// Note that the tree structure of SMDS_Mesh seems to be unused in this version /// (2003-09-08) of SMESH /////////////////////////////////////////////////////////////////////////////// -SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent) - :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory), - myElementIDFactory(parent->myElementIDFactory), - myHasConstructionEdges(false), myHasConstructionFaces(false), - myHasInverseElements(true), - myNodePool(parent->myNodePool), - myEdgePool(parent->myEdgePool), - myFacePool(parent->myFacePool), - myVolumePool(parent->myVolumePool), - myBallPool(parent->myBallPool) +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) { } @@ -188,9 +188,9 @@ SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent) SMDS_Mesh *SMDS_Mesh::AddSubMesh() { - SMDS_Mesh *submesh = new SMDS_Mesh(this); - myChildren.insert(myChildren.end(), submesh); - return submesh; + SMDS_Mesh *submesh = new SMDS_Mesh(this); + myChildren.insert(myChildren.end(), submesh); + return submesh; } /////////////////////////////////////////////////////////////////////////////// @@ -223,7 +223,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID) SMDS_MeshNode * node = myNodePool->getNew(); node->init(ID, myMeshId, 0, x, y, z); - if (ID >= myNodes.size()) + if (ID >= (int)myNodes.size()) { myNodes.resize(ID+SMDS_Mesh::chunkSize, 0); // MESSAGE(" ------------------ myNodes resize " << ID << " --> " << ID+SMDS_Mesh::chunkSize); @@ -322,11 +322,11 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame SMDS_BallElement *ball = myBallPool->getNew(); ball->init(n->getVtkId(), diameter, this); if (!this->registerElement(ID,ball)) - { - this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL); - myBallPool->destroy(ball); - return 0; - } + { + this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL); + myBallPool->destroy(ball); + return 0; + } adjustmyCellsCapacity(ID); myCells[ID] = ball; myInfo.myNbBalls++; @@ -525,7 +525,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1, if ( !e1 || !e2 || !e3 ) return 0; if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); - MESSAGE("AddFaceWithID" << ID); SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3); adjustmyCellsCapacity(ID); @@ -552,7 +551,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1, { if (!hasConstructionEdges()) return NULL; - //MESSAGE("AddFaceWithID" ); return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID()); } @@ -568,7 +566,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1, { if (!hasConstructionEdges()) return NULL; - MESSAGE("AddFaceWithID" << ID); if ( !e1 || !e2 || !e3 || !e4 ) return 0; if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4); @@ -596,7 +593,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n4) { int ID = myElementIDFactory->GetFreeID(); - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); return v; @@ -615,7 +611,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode4, int ID) { - //MESSAGE("AddVolumeWithID" << ID); SMDS_MeshNode *node1, *node2, *node3, *node4; node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); @@ -637,7 +632,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n4, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume* volume = 0; if ( !n1 || !n2 || !n3 || !n4) return volume; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); @@ -652,7 +646,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, myInfo.myNbTetras++; } else if(hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { @@ -697,7 +690,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n5) { int ID = myElementIDFactory->GetFreeID(); - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); return v; @@ -718,7 +710,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode5, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshNode *node1, *node2, *node3, *node4, *node5; node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); @@ -743,7 +734,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n5, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume* volume = 0; if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); @@ -758,7 +748,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, myInfo.myNbPyramids++; } else if(hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { @@ -805,7 +794,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1, const SMDS_MeshNode * n6) { int ID = myElementIDFactory->GetFreeID(); - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID); if(v==NULL) myElementIDFactory->ReleaseID(ID); return v; @@ -827,7 +815,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode6, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6; node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); @@ -854,7 +841,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n6, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume* volume = 0; if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); @@ -870,7 +856,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, myInfo.myNbPrisms++; } else if(hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { @@ -994,28 +979,27 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, return volume; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); if(hasConstructionFaces()) { - MESSAGE("Error : Not implemented"); return NULL; } else if(hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { // --- retrieve nodes ID + myNodeIds.resize(12); myNodeIds[0] = n1->getVtkId(); - myNodeIds[0] = n6->getVtkId(); - myNodeIds[0] = n5->getVtkId(); - myNodeIds[0] = n4->getVtkId(); - myNodeIds[0] = n3->getVtkId(); - myNodeIds[0] = n2->getVtkId(); - - myNodeIds[0] = n7->getVtkId(); - myNodeIds[0] = n12->getVtkId(); - myNodeIds[0] = n11->getVtkId(); - myNodeIds[0] = n10->getVtkId(); - myNodeIds[0] = n9->getVtkId(); - myNodeIds[0] = n8->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); @@ -1073,7 +1057,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1, int idnode8, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8; node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1); node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2); @@ -1107,7 +1090,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, const SMDS_MeshNode * n8, int ID) { - //MESSAGE("AddVolumeWithID " << ID); SMDS_MeshVolume* volume = 0; if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume; if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); @@ -1124,7 +1106,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, myInfo.myNbHexas++; } else if(hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { @@ -1170,7 +1151,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1, const SMDS_MeshFace * f3, const SMDS_MeshFace * f4) { - //MESSAGE("AddVolumeWithID"); if (!hasConstructionFaces()) return NULL; return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID()); @@ -1188,7 +1168,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1, const SMDS_MeshFace * f4, int ID) { - MESSAGE("AddVolumeWithID" << ID); if (!hasConstructionFaces()) return NULL; if ( !f1 || !f2 || !f3 || !f4) return 0; @@ -1217,7 +1196,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1, const SMDS_MeshFace * f4, const SMDS_MeshFace * f5) { - //MESSAGE("AddVolumeWithID"); if (!hasConstructionFaces()) return NULL; return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID()); @@ -1236,7 +1214,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1, const SMDS_MeshFace * f5, int ID) { - MESSAGE("AddVolumeWithID" << ID); if (!hasConstructionFaces()) return NULL; if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0; @@ -1266,7 +1243,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1, const SMDS_MeshFace * f5, const SMDS_MeshFace * f6) { - //MESSAGE("AddVolumeWithID" ); if (!hasConstructionFaces()) return NULL; return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID()); @@ -1286,7 +1262,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1, const SMDS_MeshFace * f6, int ID) { - MESSAGE("AddVolumeWithID" << ID); if (!hasConstructionFaces()) return NULL; if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0; @@ -1333,13 +1308,10 @@ SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes, if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); if (hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { - //#ifdef VTK_HAVE_POLYHEDRON - //MESSAGE("AddPolygonalFaceWithID vtk " << ID); myNodeIds.resize( nodes.size() ); for ( size_t i = 0; i < nodes.size(); ++i ) myNodeIds[i] = nodes[i]->getVtkId(); @@ -1353,25 +1325,12 @@ SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes, return 0; } face = facevtk; - //#else - // MESSAGE("AddPolygonalFaceWithID smds " << ID); - // for ( int i = 0; i < nodes.size(); ++i ) - // if ( !nodes[ i ] ) return 0; - // face = new SMDS_PolygonalFaceOfNodes(nodes); - //#endif + adjustmyCellsCapacity(ID); myCells[ID] = face; myInfo.myNbPolygons++; } - //#ifndef VTK_HAVE_POLYHEDRON - // if (!registerElement(ID, face)) - // { - // registerElement(myElementIDFactory->GetFreeID(), face); - // //RemoveElement(face, false); - // //face = NULL; - // } - //#endif return face; } @@ -1385,6 +1344,68 @@ SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (const vector & return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID()); } +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadratic polygon defined by its nodes IDs +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector & nodes_ids, + const int ID) +{ + vector nodes( nodes_ids.size() ); + for ( size_t i = 0; i < nodes.size(); i++) { + nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]); + if (!nodes[i]) return NULL; + } + return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID); +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadratic polygon defined by its nodes +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* +SMDS_Mesh::AddQuadPolygonalFaceWithID (const 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->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; + myInfo.myNbQuadPolygons++; + } + return face; +} + +/////////////////////////////////////////////////////////////////////////////// +/// Add a quadratic polygon defined by its nodes. +/// An ID is automatically affected to the created face. +/////////////////////////////////////////////////////////////////////////////// + +SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const vector & nodes) +{ + return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID()); +} + /////////////////////////////////////////////////////////////////////////////// /// Create a new polyhedral volume and add it to the mesh. /// @param ID The ID of the new volume @@ -1423,18 +1444,15 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector& nodes, if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); if (hasConstructionFaces()) { - MESSAGE("Error : Not implemented"); return NULL; } else if (hasConstructionEdges()) { - MESSAGE("Error : Not implemented"); return NULL; } else { //#ifdef VTK_HAVE_POLYHEDRON - //MESSAGE("AddPolyhedralVolumeWithID vtk " << ID); myNodeIds.resize( nodes.size() ); for ( size_t i = 0; i < nodes.size(); ++i ) myNodeIds[i] = nodes[i]->getVtkId(); @@ -1449,7 +1467,6 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector& nodes, } volume = volvtk; //#else - // MESSAGE("AddPolyhedralVolumeWithID smds " << ID); // for ( int i = 0; i < nodes.size(); ++i ) // if ( !nodes[ i ] ) return 0; // volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities); @@ -1599,8 +1616,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector& /////////////////////////////////////////////////////////////////////////////// bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element) { - //MESSAGE("registerElement " << ID); - if ((ID >=0) && (ID < myCells.size()) && myCells[ID]) // --- already bound + if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound { MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId()); return false; @@ -1615,9 +1631,8 @@ bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element) if (vtkId == -1) vtkId = myElementIDFactory->SetInVtkGrid(element); - if (vtkId >= myCellIdVtkToSmds.size()) // --- resize local vector + if (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector { -// MESSAGE(" --------------------- resize myCellIdVtkToSmds " << vtkId << " --> " << vtkId + SMDS_Mesh::chunkSize); myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1); } myCellIdVtkToSmds[vtkId] = ID; @@ -1642,11 +1657,8 @@ 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 >= myNodes.size()) + if (ID < 1 || ID >= (int)myNodes.size()) { -// MESSAGE("------------------------------------------------------------------------- "); -// MESSAGE("----------------------------------- bad ID " << ID << " " << myNodes.size()); -// MESSAGE("------------------------------------------------------------------------- "); return 0; } return (const SMDS_MeshNode *)myNodes[ID]; @@ -1658,7 +1670,7 @@ 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 >= (myNodes.size() -1)) + if ( vtkId < 0 || vtkId+1 >= (int) myNodes.size() ) { MESSAGE("------------------------------------------------------------------------- "); MESSAGE("---------------------------- bad VTK ID " << vtkId << " " << myNodes.size()); @@ -1713,7 +1725,6 @@ SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1, face = facevtk; adjustmyCellsCapacity(ID); myCells[ID] = face; - //MESSAGE("createTriangle " << ID << " " << face); myInfo.myNbTriangles++; return face; } @@ -1733,7 +1744,6 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1, if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory(); if(hasConstructionEdges()) { - //MESSAGE("createQuadrangle hasConstructionEdges "<< ID); SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4; edge1=FindEdgeOrCreate(node1,node2); edge2=FindEdgeOrCreate(node2,node3); @@ -1778,8 +1788,7 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1, void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) { - MESSAGE("RemoveNode"); - RemoveElement(node, true); + RemoveElement(node, true); } /////////////////////////////////////////////////////////////////////////////// @@ -1788,7 +1797,6 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node) void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d) { - MESSAGE("Remove0DElement"); RemoveElement(elem0d,true); } @@ -1798,8 +1806,7 @@ void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d) void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) { - MESSAGE("RemoveEdge"); - RemoveElement(edge,true); + RemoveElement(edge,true); } /////////////////////////////////////////////////////////////////////////////// @@ -1808,8 +1815,7 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge) void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) { - MESSAGE("RemoveFace"); - RemoveElement(face, true); + RemoveElement(face, true); } /////////////////////////////////////////////////////////////////////////////// @@ -1818,8 +1824,7 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face) void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) { - MESSAGE("RemoveVolume"); - RemoveElement(volume, true); + RemoveElement(volume, true); } //======================================================================= @@ -1829,8 +1834,8 @@ void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume) bool SMDS_Mesh::RemoveFromParent() { - if (myParent==NULL) return false; - else return (myParent->RemoveSubMesh(this)); + if (myParent==NULL) return false; + else return (myParent->RemoveSubMesh(this)); } //======================================================================= @@ -1840,20 +1845,20 @@ bool SMDS_Mesh::RemoveFromParent() bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh) { - bool found = false; + bool found = false; - list::iterator itmsh=myChildren.begin(); - for (; itmsh!=myChildren.end() && !found; itmsh++) - { - SMDS_Mesh * submesh = *itmsh; - if (submesh == aMesh) - { - found = true; - myChildren.erase(itmsh); - } - } + list::iterator itmsh=myChildren.begin(); + for (; itmsh!=myChildren.end() && !found; itmsh++) + { + SMDS_Mesh * submesh = *itmsh; + if (submesh == aMesh) + { + found = true; + myChildren.erase(itmsh); + } + } - return found; + return found; } //======================================================================= @@ -1865,7 +1870,6 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element, const SMDS_MeshNode * nodes[], const int nbnodes) { - MESSAGE("SMDS_Mesh::ChangeElementNodes"); // keep current nodes of elem set oldNodes( element->begin_nodes(), element->end_nodes() ); @@ -1873,10 +1877,10 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element, bool Ok = false; SMDS_MeshCell* cell = dynamic_cast((SMDS_MeshElement*) element); if (cell) - { - Ok = cell->vtkOrder(nodes, nbnodes); - Ok = cell->ChangeNodes(nodes, nbnodes); - } + { + Ok = cell->vtkOrder(nodes, nbnodes); + Ok = cell->ChangeNodes(nodes, nbnodes); + } if ( Ok ) { // update InverseElements @@ -2377,13 +2381,8 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1, const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const { - if ((IDelem <= 0) || IDelem >= myCells.size()) + if ( IDelem <= 0 || IDelem >= (int)myCells.size() ) { - MESSAGE("--------------------------------------------------------------------------------- "); - MESSAGE("----------------------------------- bad IDelem " << IDelem << " " << myCells.size()); - MESSAGE("--------------------------------------------------------------------------------- "); - // TODO raise an exception - //assert(0); return 0; } return myCells[IDelem]; @@ -2433,9 +2432,9 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vectornext(); int nbNodesToCheck = noMedium ? e->NbCornerNodes() : e->NbNodes(); - if ( nbNodesToCheck == nodes.size() ) + if ( nbNodesToCheck == (int)nodes.size() ) { - for ( int i = 1; e && i < nodes.size(); ++ i ) + for ( size_t i = 1; e && i < nodes.size(); ++i ) { int nodeIndex = e->GetNodeIndex( nodes[ i ]); if ( nodeIndex < 0 || nodeIndex >= nbNodesToCheck ) @@ -2456,9 +2455,8 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vectormore()) ; //MESSAGE(itnode->next()); + SMDS_NodeIteratorPtr itnode=nodesIterator(); + while(itnode->more()) ; //MESSAGE(itnode->next()); } //======================================================================= @@ -2467,7 +2465,6 @@ void SMDS_Mesh::DumpNodes() const //======================================================================= void SMDS_Mesh::Dump0DElements() const { - MESSAGE("dump 0D elements of mesh : "); SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement); while(it0d->more()) ; //MESSAGE(it0d->next()); } @@ -2479,9 +2476,8 @@ void SMDS_Mesh::Dump0DElements() const void SMDS_Mesh::DumpEdges() const { - MESSAGE("dump edges of mesh : "); - SMDS_EdgeIteratorPtr itedge=edgesIterator(); - while(itedge->more()) ; //MESSAGE(itedge->next()); + SMDS_EdgeIteratorPtr itedge=edgesIterator(); + while(itedge->more()) ; //MESSAGE(itedge->next()); } //======================================================================= @@ -2491,9 +2487,8 @@ void SMDS_Mesh::DumpEdges() const void SMDS_Mesh::DumpFaces() const { - MESSAGE("dump faces of mesh : "); - SMDS_FaceIteratorPtr itface=facesIterator(); - while(itface->more()) ; //MESSAGE(itface->next()); + SMDS_FaceIteratorPtr itface=facesIterator(); + while(itface->more()) ; //MESSAGE(itface->next()); } //======================================================================= @@ -2503,9 +2498,8 @@ void SMDS_Mesh::DumpFaces() const void SMDS_Mesh::DumpVolumes() const { - MESSAGE("dump volumes of mesh : "); - SMDS_VolumeIteratorPtr itvol=volumesIterator(); - while(itvol->more()) ; //MESSAGE(itvol->next()); + SMDS_VolumeIteratorPtr itvol=volumesIterator(); + while(itvol->more()) ; //MESSAGE(itvol->next()); } //======================================================================= @@ -2563,10 +2557,7 @@ void SMDS_Mesh::DebugStats() const /////////////////////////////////////////////////////////////////////////////// int SMDS_Mesh::NbNodes() const { - //MESSAGE(myGrid->GetNumberOfPoints()); - //MESSAGE(myInfo.NbNodes()); - //MESSAGE(myNodeMax); - return myInfo.NbNodes(); + return myInfo.NbNodes(); } /////////////////////////////////////////////////////////////////////////////// @@ -2669,7 +2660,6 @@ SMDS_Mesh::~SMDS_Mesh() void SMDS_Mesh::Clear() { - MESSAGE("SMDS_Mesh::Clear"); if (myParent!=NULL) { SMDS_ElemIteratorPtr eIt = elementsIterator(); @@ -3028,61 +3018,57 @@ static set * intersectionOfSets( /////////////////////////////////////////////////////////////////////////////// static set * getFinitElements(const SMDS_MeshElement * element) { - int numberOfSets=element->NbNodes(); - set *initSet = new set[numberOfSets]; + int numberOfSets=element->NbNodes(); + set *initSet = new set[numberOfSets]; - SMDS_ElemIteratorPtr itNodes=element->nodesIterator(); + SMDS_ElemIteratorPtr itNodes=element->nodesIterator(); - int i=0; - while(itNodes->more()) - { - const SMDS_MeshElement* node = itNodes->next(); - MYASSERT(node); - const SMDS_MeshNode * n=static_cast(node); - SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); - - //initSet[i]=set(); - while(itFe->more()) - { - const SMDS_MeshElement* elem = itFe->next(); - MYASSERT(elem); - initSet[i].insert(elem); + 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); + } - i++; - } - set *retSet=intersectionOfSets(initSet, numberOfSets); -// MESSAGE("nb elems " << i << " intersection " << retSet->size()); - delete [] initSet; - return retSet; + i++; + } + set *retSet = intersectionOfSets( initSet, numberOfSets ); + delete [] initSet; + return retSet; } /////////////////////////////////////////////////////////////////////////////// /// Return the list of nodes used only by the given elements /////////////////////////////////////////////////////////////////////////////// -static set * getExclusiveNodes( - set& elements) +static set * getExclusiveNodes(set& elements) { - set * toReturn=new set(); - set::iterator itElements=elements.begin(); + set * toReturn=new set(); + set::iterator itElements=elements.begin(); - while(itElements!=elements.end()) - { - SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator(); - itElements++; - - while(itNodes->more()) - { - const SMDS_MeshNode * n=static_cast(itNodes->next()); - SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); - set s; - while(itFe->more()) - s.insert(itFe->next()); - if(s==elements) toReturn->insert(n); - } - } - return toReturn; + while(itElements!=elements.end()) + { + SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator(); + itElements++; + + while(itNodes->more()) + { + const SMDS_MeshNode * n=static_cast(itNodes->next()); + SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); + set s; + while(itFe->more()) + s.insert(itFe->next()); + if(s==elements) toReturn->insert(n); + } + } + return toReturn; } /////////////////////////////////////////////////////////////////////////////// @@ -3096,62 +3082,65 @@ void SMDS_Mesh::addChildrenWithNodes(set& setOfChildren set& nodes) { switch(element->GetType()) + { + case SMDSAbs_Node: + MESSAGE("Internal Error: This should not happen"); + break; + case SMDSAbs_0DElement: + case SMDSAbs_Ball: + { + } + break; + case SMDSAbs_Edge: + { + SMDS_ElemIteratorPtr itn=element->nodesIterator(); + while(itn->more()) { - case SMDSAbs_Node: - MESSAGE("Internal Error: This should not happen"); - break; - case SMDSAbs_0DElement: + const SMDS_MeshElement * e=itn->next(); + if(nodes.find(e)!=nodes.end()) { + setOfChildren.insert(element); + break; } - break; - case SMDSAbs_Edge: - { - SMDS_ElemIteratorPtr itn=element->nodesIterator(); - while(itn->more()) - { - const SMDS_MeshElement * e=itn->next(); - if(nodes.find(e)!=nodes.end()) - { - setOfChildren.insert(element); - break; - } - } - } break; - case SMDSAbs_Face: - { - SMDS_ElemIteratorPtr itn=element->nodesIterator(); - while(itn->more()) - { - const SMDS_MeshElement * e=itn->next(); - if(nodes.find(e)!=nodes.end()) - { - setOfChildren.insert(element); - break; - } - } - if(hasConstructionEdges()) - { - SMDS_ElemIteratorPtr ite=element->edgesIterator(); - while(ite->more()) - addChildrenWithNodes(setOfChildren, ite->next(), nodes); - } - } break; - case SMDSAbs_Volume: - { - if(hasConstructionFaces()) - { - SMDS_ElemIteratorPtr ite=element->facesIterator(); - while(ite->more()) - addChildrenWithNodes(setOfChildren, ite->next(), nodes); - } - else if(hasConstructionEdges()) - { - SMDS_ElemIteratorPtr ite=element->edgesIterator(); - while(ite->more()) - addChildrenWithNodes(setOfChildren, ite->next(), nodes); - } - } } + } break; + case SMDSAbs_Face: + { + SMDS_ElemIteratorPtr itn=element->nodesIterator(); + while(itn->more()) + { + const SMDS_MeshElement * e=itn->next(); + if(nodes.find(e)!=nodes.end()) + { + setOfChildren.insert(element); + break; + } + } + if(hasConstructionEdges()) + { + SMDS_ElemIteratorPtr ite=element->edgesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + } + } break; + case SMDSAbs_Volume: + { + if(hasConstructionFaces()) + { + SMDS_ElemIteratorPtr ite=element->facesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + } + else if(hasConstructionEdges()) + { + SMDS_ElemIteratorPtr ite=element->edgesIterator(); + while(ite->more()) + addChildrenWithNodes(setOfChildren, ite->next(), nodes); + } + } + case SMDSAbs_NbElementTypes: + case SMDSAbs_All: break; + } } /////////////////////////////////////////////////////////////////////////////// @@ -3177,7 +3166,6 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, list& removedNodes, bool removenodes) { - //MESSAGE("SMDS_Mesh::RemoveElement " << elem->getVtkId() << " " << removenodes); // get finite elements built on elem set * s1; if ( (elem->GetType() == SMDSAbs_0DElement) @@ -3222,19 +3210,16 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, // 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)); - } + { + SMDS_MeshNode * n = static_cast (const_cast (itn->next())); + n->RemoveInverseElement((*it)); + } int IdToRemove = (*it)->GetID(); int vtkid = (*it)->getVtkId(); - //MESSAGE("elem Id to remove " << IdToRemove << " vtkid " << vtkid << - // " vtktype " << (*it)->GetVtkType() << " type " << (*it)->GetType()); switch ((*it)->GetType()) { case SMDSAbs_Node: - MYASSERT("Internal Error: This should not happen") - ; + MYASSERT("Internal Error: This should not happen"); break; case SMDSAbs_0DElement: if (IdToRemove >= 0) @@ -3256,8 +3241,10 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, myElementIDFactory->ReleaseID(IdToRemove, vtkid); if (const SMDS_VtkEdge* vtkElem = dynamic_cast(*it)) myEdgePool->destroy((SMDS_VtkEdge*) vtkElem); - else + else { + ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse delete (*it); + } break; case SMDSAbs_Face: if (IdToRemove >= 0) @@ -3269,8 +3256,10 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, myElementIDFactory->ReleaseID(IdToRemove, vtkid); if (const SMDS_VtkFace* vtkElem = dynamic_cast(*it)) myFacePool->destroy((SMDS_VtkFace*) vtkElem); - else + else { + ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse delete (*it); + } break; case SMDSAbs_Volume: if (IdToRemove >= 0) @@ -3282,8 +3271,10 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, myElementIDFactory->ReleaseID(IdToRemove, vtkid); if (const SMDS_VtkVolume* vtkElem = dynamic_cast(*it)) myVolumePool->destroy((SMDS_VtkVolume*) vtkElem); - else + else { + ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse delete (*it); + } break; case SMDSAbs_Ball: if (IdToRemove >= 0) @@ -3295,43 +3286,46 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, myElementIDFactory->ReleaseID(IdToRemove, vtkid); if (const SMDS_BallElement* vtkElem = dynamic_cast(*it)) myBallPool->destroy(const_cast( vtkElem )); - else + else { + ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse delete (*it); + } break; + + case SMDSAbs_All: // avoid compilation warning + case SMDSAbs_NbElementTypes: break; } if (vtkid >= 0) - { - //MESSAGE("VTK_EMPTY_CELL in " << vtkid); - this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); - } + { + this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); + } it++; } // remove exclusive (free) nodes if (removenodes) + { + it = s2->begin(); + while (it != s2->end()) { - it = s2->begin(); - while (it != s2->end()) - { - int IdToRemove = (*it)->GetID(); - //MESSAGE( "SMDS: RM node " << IdToRemove); - if (IdToRemove >= 0) - { - myNodes[IdToRemove] = 0; - myInfo.myNbNodes--; - } - myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId()); - 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++; - } + int IdToRemove = (*it)->GetID(); + if (IdToRemove >= 0) + { + myNodes[IdToRemove] = 0; + myInfo.myNbNodes--; + } + myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId()); + 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++; } + } delete s2; delete s1; @@ -3345,11 +3339,9 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) { int elemId = elem->GetID(); int vtkId = elem->getVtkId(); - //MESSAGE("RemoveFreeElement " << elemId); SMDSAbs_ElementType aType = elem->GetType(); SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem); if (aType == SMDSAbs_Node) { - //MESSAGE("Remove free node " << elemId); // only free node can be removed by this method const SMDS_MeshNode* n = static_cast(todest); SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator(); @@ -3366,7 +3358,6 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) // this methods is only for meshes without descendants return; - //MESSAGE("Remove free element " << elemId); // Remove element from of its nodes SMDS_ElemIteratorPtr itn = elem->nodesIterator(); while (itn->more()) { @@ -3376,11 +3367,12 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) } // in meshes without descendants elements are always free - switch (aType) { + switch (aType) { case SMDSAbs_0DElement: myCells[elemId] = 0; myInfo.remove(elem); delete elem; + elem = 0; break; case SMDSAbs_Edge: myCells[elemId] = 0; @@ -3409,6 +3401,9 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * 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( -1, -1, -1 ); // avoid reuse } } @@ -3478,7 +3473,6 @@ int SMDS_Mesh::MinElementID() const void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID) { - MESSAGE("Renumber"); if ( deltaID == 0 ) return; @@ -4636,7 +4630,7 @@ void SMDS_Mesh::updateNodeMinMax() myNodeMax=0; return; } - while (!myNodes[myNodeMin] && (myNodeMin=0)) @@ -4649,17 +4643,14 @@ void SMDS_Mesh::incrementNodesCapacity(int nbNodes) // MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes); // myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1 int val = myNodes.size(); - MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes); myNodes.resize(val +nbNodes, 0); } void SMDS_Mesh::incrementCellsCapacity(int nbCells) { int val = myCellIdVtkToSmds.size(); - MESSAGE(" ------------------- resize myCellIdVtkToSmds " << val << " --> " << val + nbCells); myCellIdVtkToSmds.resize(val + nbCells, -1); // fill new elements with -1 val = myCells.size(); - MESSAGE(" ------------------- resize myCells " << val << " --> " << val + nbCells); myNodes.resize(val +nbCells, 0); } @@ -4670,48 +4661,45 @@ void SMDS_Mesh::adjustStructure() void SMDS_Mesh::dumpGrid(string ficdump) { - MESSAGE("SMDS_Mesh::dumpGrid " << ficdump); -// vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); -// aWriter->SetFileName(ficdump.c_str()); -// aWriter->SetInput(myGrid); -// if(myGrid->GetNumberOfCells()) -// { -// aWriter->Write(); -// } -// aWriter->Delete(); + // vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New(); + // aWriter->SetFileName(ficdump.c_str()); + // aWriter->SetInput(myGrid); + // if(myGrid->GetNumberOfCells()) + // { + // aWriter->Write(); + // } + // aWriter->Delete(); ficdump = ficdump + "_connectivity"; ofstream ficcon(ficdump.c_str(), ios::out); int nbPoints = myGrid->GetNumberOfPoints(); ficcon << "-------------------------------- points " << nbPoints << endl; for (int i=0; iGetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl; + ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl; } int nbCells = myGrid->GetNumberOfCells(); ficcon << "-------------------------------- cells " << nbCells << endl; for (int i=0; iGetCell(i)); -// MESSAGE(" " << myGrid->GetCell(i)->GetCellType()); - ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -"; - int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints(); - vtkIdList *listid = myGrid->GetCell(i)->GetPointIds(); - for (int j=0; jGetId(j); - } - ficcon << endl; + ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -"; + int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints(); + vtkIdList *listid = myGrid->GetCell(i)->GetPointIds(); + for (int j=0; jGetId(j); + } + ficcon << endl; } ficcon << "-------------------------------- connectivity " << nbPoints << endl; - vtkCellLinks *links = myGrid->GetCellLinks(); + vtkCellLinks *links = myGrid->GetCellLinks(); for (int i=0; iGetNcells(i); - vtkIdType *cells = links->GetCells(i); - ficcon << i << " - " << ncells << " -"; - for (int j=0; jGetNcells(i); + vtkIdType *cells = links->GetCells(i); + ficcon << i << " - " << ncells << " -"; + for (int j=0; j= 0 && vtkid < myCellIdVtkToSmds.size()) + if (vtkid >= 0 && vtkid < (int)myCellIdVtkToSmds.size()) return myCellIdVtkToSmds[vtkid]; throw SALOME_Exception(LOCALIZED ("vtk id out of bounds")); } @@ -4760,7 +4748,6 @@ double SMDS_Mesh::getMaxDim() if ((xmax - xmin) > dmax) dmax = xmax -xmin; if ((ymax - ymin) > dmax) dmax = ymax -ymin; if ((zmax - zmin) > dmax) dmax = zmax -zmin; - MESSAGE("getMaxDim " << dmax); return dmax; } @@ -4768,11 +4755,10 @@ double SMDS_Mesh::getMaxDim() void SMDS_Mesh::Modified() { if (this->myModified) - { - this->myModifTime++; - MESSAGE("modified"); - myModified = false; - } + { + this->myModifTime++; + myModified = false; + } } //! get last modification timeStamp @@ -4784,10 +4770,9 @@ unsigned long SMDS_Mesh::GetMTime() const bool SMDS_Mesh::isCompacted() { if (this->myModifTime > this->myCompactTime) - { - MESSAGE(" *** isCompacted " << myCompactTime << " < " << myModifTime); - this->myCompactTime = this->myModifTime; - return false; - } + { + this->myCompactTime = this->myModifTime; + return false; + } return true; }