-// 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
///////////////////////////////////////////////////////////////////////////////
/// 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);
/// 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)
{
}
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;
}
///////////////////////////////////////////////////////////////////////////////
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);
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++;
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);
{
if (!hasConstructionEdges())
return NULL;
- //MESSAGE("AddFaceWithID" );
return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
}
{
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);
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;
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);
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();
myInfo.myNbTetras++;
}
else if(hasConstructionEdges()) {
- MESSAGE("Error : Not implemented");
return NULL;
}
else {
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n3->getVtkId()); // order SMDS-->VTK
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n4->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
volume = volvtk;
adjustmyCellsCapacity(ID);
myCells[ID] = volume;
myInfo.myNbTetras++;
}
-// if (!registerElement(ID, volume)) {
-// RemoveElement(volume, false);
-// volume = NULL;
-// }
+ // if (!registerElement(ID, volume)) {
+ // RemoveElement(volume, false);
+ // volume = NULL;
+ // }
return volume;
}
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;
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);
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();
myInfo.myNbPyramids++;
}
else if(hasConstructionEdges()) {
- MESSAGE("Error : Not implemented");
return NULL;
}
else {
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n5->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
volume = volvtk;
adjustmyCellsCapacity(ID);
myCells[ID] = volume;
myInfo.myNbPyramids++;
}
-// if (!registerElement(ID, volume)) {
-// RemoveElement(volume, false);
-// volume = NULL;
-// }
+ // if (!registerElement(ID, volume)) {
+ // RemoveElement(volume, false);
+ // volume = NULL;
+ // }
return volume;
}
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;
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);
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();
myInfo.myNbPrisms++;
}
else if(hasConstructionEdges()) {
- MESSAGE("Error : Not implemented");
return NULL;
}
else {
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n5->getVtkId());
- nodeIds.push_back(n6->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
volume = volvtk;
adjustmyCellsCapacity(ID);
myCells[ID] = volume;
myInfo.myNbPrisms++;
}
-// if (!registerElement(ID, volume)) {
-// RemoveElement(volume, false);
-// volume = NULL;
-// }
+ // if (!registerElement(ID, volume)) {
+ // RemoveElement(volume, false);
+ // volume = NULL;
+ // }
return volume;
}
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
- vector<vtkIdType> nodeIds;
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n6->getVtkId());
- nodeIds.push_back(n5->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
-
- nodeIds.push_back(n7->getVtkId());
- nodeIds.push_back(n12->getVtkId());
- nodeIds.push_back(n11->getVtkId());
- nodeIds.push_back(n10->getVtkId());
- nodeIds.push_back(n9->getVtkId());
- nodeIds.push_back(n8->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
volume = volvtk;
adjustmyCellsCapacity(ID);
myCells[ID] = volume;
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);
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();
myInfo.myNbHexas++;
}
else if(hasConstructionEdges()) {
- MESSAGE("Error : Not implemented");
return NULL;
}
else {
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n5->getVtkId());
- nodeIds.push_back(n8->getVtkId());
- nodeIds.push_back(n7->getVtkId());
- nodeIds.push_back(n6->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ 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;
-// }
+
+ // if (!registerElement(ID, volume)) {
+ // RemoveElement(volume, false);
+ // volume = NULL;
+ // }
return volume;
}
const SMDS_MeshFace * f3,
const SMDS_MeshFace * f4)
{
- //MESSAGE("AddVolumeWithID");
if (!hasConstructionFaces())
return NULL;
return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());
const SMDS_MeshFace * f4,
int ID)
{
- MESSAGE("AddVolumeWithID" << ID);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4) return 0;
const SMDS_MeshFace * f4,
const SMDS_MeshFace * f5)
{
- //MESSAGE("AddVolumeWithID");
if (!hasConstructionFaces())
return NULL;
return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());
const SMDS_MeshFace * f5,
int ID)
{
- MESSAGE("AddVolumeWithID" << ID);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
const SMDS_MeshFace * f5,
const SMDS_MeshFace * f6)
{
- //MESSAGE("AddVolumeWithID" );
if (!hasConstructionFaces())
return NULL;
return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());
const SMDS_MeshFace * f6,
int ID)
{
- MESSAGE("AddVolumeWithID" << ID);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
/// Add a polygon defined by its nodes
///////////////////////////////////////////////////////////////////////////////
-SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID
- (const vector<const SMDS_MeshNode*> & nodes,
- const int ID)
+SMDS_MeshFace*
+SMDS_Mesh::AddPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
+ const int ID)
{
SMDS_MeshFace * face;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionEdges())
- {
- MESSAGE("Error : Not implemented");
- return NULL;
- }
+ {
+ return NULL;
+ }
else
- {
-//#ifdef VTK_HAVE_POLYHEDRON
- //MESSAGE("AddPolygonalFaceWithID vtk " << ID);
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- vector<const SMDS_MeshNode*>::const_iterator it = nodes.begin();
- for ( ; it != nodes.end(); ++it)
- nodeIds.push_back((*it)->getVtkId());
+ {
+ 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(nodeIds, this);
+ 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;
-//#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++;
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
}
+ face = facevtk;
-//#ifndef VTK_HAVE_POLYHEDRON
-// if (!registerElement(ID, face))
-// {
-// registerElement(myElementIDFactory->GetFreeID(), face);
-// //RemoveElement(face, false);
-// //face = NULL;
-// }
-//#endif
- return face;
+ adjustmyCellsCapacity(ID);
+ myCells[ID] = face;
+ myInfo.myNbPolygons++;
+ }
+
+ return face;
}
///////////////////////////////////////////////////////////////////////////////
return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID());
}
+///////////////////////////////////////////////////////////////////////////////
+/// Add a quadratic polygon defined by its nodes IDs
+///////////////////////////////////////////////////////////////////////////////
+
+SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<int> & nodes_ids,
+ const int ID)
+{
+ vector<const SMDS_MeshNode*> 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<const SMDS_MeshNode*> & 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<const SMDS_MeshNode*> & 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
/// @return The created volume
///////////////////////////////////////////////////////////////////////////////
-SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolumeWithID
- (const vector<const SMDS_MeshNode*>& nodes,
- const vector<int> & quantities,
- const int ID)
+SMDS_MeshVolume*
+SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
+ const vector<int> & quantities,
+ const int ID)
{
SMDS_MeshVolume* volume = 0;
if ( nodes.empty() || quantities.empty() )
return NULL;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionFaces())
- {
- MESSAGE("Error : Not implemented");
- return NULL;
- }
+ {
+ return NULL;
+ }
else if (hasConstructionEdges())
- {
- MESSAGE("Error : Not implemented");
- return NULL;
- }
+ {
+ return NULL;
+ }
else
+ {
+ //#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))
{
-//#ifdef VTK_HAVE_POLYHEDRON
- //MESSAGE("AddPolyhedralVolumeWithID vtk " << ID);
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- vector<const SMDS_MeshNode*>::const_iterator it = nodes.begin();
- for (; it != nodes.end(); ++it)
- nodeIds.push_back((*it)->getVtkId());
-
- SMDS_VtkVolume *volvtk = myVolumePool->getNew();
- volvtk->initPoly(nodeIds, quantities, this);
- if (!this->registerElement(ID, volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
- 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);
-//#endif
- adjustmyCellsCapacity(ID);
- myCells[ID] = volume;
- myInfo.myNbPolyhedrons++;
+ 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;
+ myInfo.myNbPolyhedrons++;
+ }
-//#ifndef VTK_HAVE_POLYHEDRON
-// if (!registerElement(ID, volume))
-// {
-// registerElement(myElementIDFactory->GetFreeID(), volume);
-// //RemoveElement(volume, false);
-// //volume = NULL;
-// }
-//#endif
+ //#ifndef VTK_HAVE_POLYHEDRON
+ // if (!registerElement(ID, volume))
+ // {
+ // registerElement(myElementIDFactory->GetFreeID(), volume);
+ // //RemoveElement(volume, false);
+ // //volume = NULL;
+ // }
+ //#endif
return volume;
}
///////////////////////////////////////////////////////////////////////////////
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;
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;
///////////////////////////////////////////////////////////////////////////////
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];
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());
else
{
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(node1->getVtkId());
- nodeIds.push_back(node2->getVtkId());
- nodeIds.push_back(node3->getVtkId());
+ 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(nodeIds, this); // put in vtkUnstructuredGrid
+ 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;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
+ }
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
- //MESSAGE("createTriangle " << ID << " " << face);
myInfo.myNbTriangles++;
return face;
}
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);
else
{
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(node1->getVtkId());
- nodeIds.push_back(node2->getVtkId());
- nodeIds.push_back(node3->getVtkId());
- nodeIds.push_back(node4->getVtkId());
+ 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(nodeIds, this);
+ facevtk->init(myNodeIds, this);
if (!this->registerElement(ID,facevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
- myFacePool->destroy(facevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
+ }
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
{
- MESSAGE("RemoveNode");
- RemoveElement(node, true);
+ RemoveElement(node, true);
}
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
{
- MESSAGE("Remove0DElement");
RemoveElement(elem0d,true);
}
void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
{
- MESSAGE("RemoveEdge");
- RemoveElement(edge,true);
+ RemoveElement(edge,true);
}
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
{
- MESSAGE("RemoveFace");
- RemoveElement(face, true);
+ RemoveElement(face, true);
}
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
{
- MESSAGE("RemoveVolume");
- RemoveElement(volume, true);
+ RemoveElement(volume, true);
}
//=======================================================================
bool SMDS_Mesh::RemoveFromParent()
{
- if (myParent==NULL) return false;
- else return (myParent->RemoveSubMesh(this));
+ if (myParent==NULL) return false;
+ else return (myParent->RemoveSubMesh(this));
}
//=======================================================================
bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
{
- bool found = false;
+ bool found = false;
- list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
- for (; itmsh!=myChildren.end() && !found; itmsh++)
- {
- SMDS_Mesh * submesh = *itmsh;
- if (submesh == aMesh)
- {
- found = true;
- myChildren.erase(itmsh);
- }
- }
+ list<SMDS_Mesh *>::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;
}
//=======================================================================
const SMDS_MeshNode * nodes[],
const int nbnodes)
{
- MESSAGE("SMDS_Mesh::ChangeElementNodes");
// keep current nodes of elem
set<const SMDS_MeshNode*> oldNodes( element->begin_nodes(), element->end_nodes() );
bool Ok = false;
SMDS_MeshCell* cell = dynamic_cast<SMDS_MeshCell*>((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
if ( NbEdges() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element
adjustmyCellsCapacity(ID);
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(node1->getVtkId());
- nodeIds.push_back(node2->getVtkId());
+ myNodeIds.resize(2);
+ myNodeIds[0] = node1->getVtkId();
+ myNodeIds[1] = node2->getVtkId();
SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
- edgevtk->init(nodeIds, this);
+ edgevtk->init(myNodeIds, this);
if (!this->registerElement(ID,edgevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
- myEdgePool->destroy(edgevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
+ myEdgePool->destroy(edgevtk);
+ return 0;
+ }
toReturn = edgevtk;
myCells[ID] = toReturn;
myInfo.myNbEdges++;
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];
{
const SMDS_MeshElement* e = itF->next();
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 )
void SMDS_Mesh::DumpNodes() const
{
- MESSAGE("dump nodes of mesh : ");
- SMDS_NodeIteratorPtr itnode=nodesIterator();
- while(itnode->more()) ; //MESSAGE(itnode->next());
+ SMDS_NodeIteratorPtr itnode=nodesIterator();
+ while(itnode->more()) ; //MESSAGE(itnode->next());
}
//=======================================================================
//=======================================================================
void SMDS_Mesh::Dump0DElements() const
{
- MESSAGE("dump 0D elements of mesh : ");
SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
while(it0d->more()) ; //MESSAGE(it0d->next());
}
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());
}
//=======================================================================
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());
}
//=======================================================================
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());
}
//=======================================================================
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbNodes() const
{
- //MESSAGE(myGrid->GetNumberOfPoints());
- //MESSAGE(myInfo.NbNodes());
- //MESSAGE(myNodeMax);
- return myInfo.NbNodes();
+ return myInfo.NbNodes();
}
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::Clear()
{
- MESSAGE("SMDS_Mesh::Clear");
if (myParent!=NULL)
{
SMDS_ElemIteratorPtr eIt = elementsIterator();
///////////////////////////////////////////////////////////////////////////////
static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
{
- int numberOfSets=element->NbNodes();
- set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
+ int numberOfSets=element->NbNodes();
+ set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[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<const SMDS_MeshNode*>(node);
- SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
-
- //initSet[i]=set<const SMDS_MeshElement*>();
- 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<const SMDS_MeshNode*>(node);
+ SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
- }
+ while ( itFe->more() )
+ {
+ const SMDS_MeshElement* elem = itFe->next();
+ MYASSERT(elem);
+ initSet[i].insert(elem);
+ }
- i++;
- }
- set<const SMDS_MeshElement*> *retSet=intersectionOfSets(initSet, numberOfSets);
-// MESSAGE("nb elems " << i << " intersection " << retSet->size());
- delete [] initSet;
- return retSet;
+ i++;
+ }
+ set<const SMDS_MeshElement*> *retSet = intersectionOfSets( initSet, numberOfSets );
+ delete [] initSet;
+ return retSet;
}
///////////////////////////////////////////////////////////////////////////////
/// Return the list of nodes used only by the given elements
///////////////////////////////////////////////////////////////////////////////
-static set<const SMDS_MeshElement*> * getExclusiveNodes(
- set<const SMDS_MeshElement*>& elements)
+static set<const SMDS_MeshElement*> * getExclusiveNodes(set<const SMDS_MeshElement*>& elements)
{
- set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
- set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
+ set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
+ set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
- while(itElements!=elements.end())
- {
- SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator();
- itElements++;
-
- while(itNodes->more())
- {
- const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
- SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
- set<const SMDS_MeshElement*> 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<const SMDS_MeshNode*>(itNodes->next());
+ SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
+ set<const SMDS_MeshElement*> s;
+ while(itFe->more())
+ s.insert(itFe->next());
+ if(s==elements) toReturn->insert(n);
+ }
+ }
+ return toReturn;
}
///////////////////////////////////////////////////////////////////////////////
set<const SMDS_MeshElement*>& 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;
+ }
}
///////////////////////////////////////////////////////////////////////////////
list<const SMDS_MeshElement *>& removedNodes,
bool removenodes)
{
- //MESSAGE("SMDS_Mesh::RemoveElement " << elem->getVtkId() << " " << removenodes);
// get finite elements built on elem
set<const SMDS_MeshElement*> * s1;
if ( (elem->GetType() == SMDSAbs_0DElement)
// Remove element from <InverseElements> of its nodes
SMDS_ElemIteratorPtr itn = (*it)->nodesIterator();
while (itn->more())
- {
- SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (itn->next()));
- n->RemoveInverseElement((*it));
- }
+ {
+ SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (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)
myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*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)
myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*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)
myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*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)
myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_BallElement* vtkElem = dynamic_cast<const SMDS_BallElement*>(*it))
myBallPool->destroy(const_cast<SMDS_BallElement*>( 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<const SMDS_MeshNode*>(*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<const SMDS_MeshNode*>(*it))
+ {
+ ((SMDS_MeshNode*)vtkElem)->SetPosition(SMDS_SpacePosition::originSpacePosition());
+ myNodePool->destroy((SMDS_MeshNode*) vtkElem);
+ }
+ else
+ delete (*it);
+ it++;
}
+ }
delete s2;
delete s1;
{
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<SMDS_MeshNode*>(todest);
SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
// this methods is only for meshes without descendants
return;
- //MESSAGE("Remove free element " << elemId);
// Remove element from <InverseElements> of its nodes
SMDS_ElemIteratorPtr itn = elem->nodesIterator();
while (itn->more()) {
}
// 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;
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
}
}
void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
{
- MESSAGE("Renumber");
if ( deltaID == 0 )
return;
if ( !n1 || !n2 || !n12 ) return 0;
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n12->getVtkId());
+ 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(nodeIds, this);
+ edgevtk->init(myNodeIds, this);
if (!this->registerElement(ID,edgevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
- myEdgePool->destroy(edgevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
+ myEdgePool->destroy(edgevtk);
+ return 0;
+ }
edge = edgevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = edge;
myInfo.myNbQuadEdges++;
-// if (!registerElement(ID, edge)) {
-// RemoveElement(edge, false);
-// edge = NULL;
-// }
+ // if (!registerElement(ID, edge)) {
+ // RemoveElement(edge, false);
+ // edge = NULL;
+ // }
return edge;
}
else
{
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n12->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n31->getVtkId());
+ 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(nodeIds, this);
+ facevtk->init(myNodeIds, this);
if (!this->registerElement(ID,facevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
- myFacePool->destroy(facevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
+ }
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
myInfo.myNbQuadTriangles++;
-// if (!registerElement(ID, face)) {
-// RemoveElement(face, false);
-// face = NULL;
-// }
+ // if (!registerElement(ID, face)) {
+ // RemoveElement(face, false);
+ // face = NULL;
+ // }
return face;
}
}
else
{
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n12->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n31->getVtkId());
- nodeIds.push_back(nCenter->getVtkId());
+ 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(nodeIds, this);
+ facevtk->init(myNodeIds, this);
if (!this->registerElement(ID,facevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
- myFacePool->destroy(facevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
+ }
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
myInfo.myNbBiQuadTriangles++;
-// if (!registerElement(ID, face)) {
-// RemoveElement(face, false);
-// face = NULL;
-// }
+ // if (!registerElement(ID, face)) {
+ // RemoveElement(face, false);
+ // face = NULL;
+ // }
return face;
}
}
if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0;
if(hasConstructionEdges()) {
// creation quadratic edges - not implemented
- return 0;
+ return 0;
}
else
{
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n12->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n34->getVtkId());
- nodeIds.push_back(n41->getVtkId());
+ 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(nodeIds, this);
+ facevtk->init(myNodeIds, this);
if (!this->registerElement(ID,facevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
- myFacePool->destroy(facevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
+ }
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
myInfo.myNbQuadQuadrangles++;
-// if (!registerElement(ID, face)) {
-// RemoveElement(face, false);
-// face = NULL;
-// }
+ // if (!registerElement(ID, face)) {
+ // RemoveElement(face, false);
+ // face = NULL;
+ // }
return face;
}
}
if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41 || !nCenter) return 0;
if(hasConstructionEdges()) {
// creation quadratic edges - not implemented
- return 0;
+ return 0;
}
else
{
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n12->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n34->getVtkId());
- nodeIds.push_back(n41->getVtkId());
- nodeIds.push_back(nCenter->getVtkId());
+ 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(nodeIds, this);
+ facevtk->init(myNodeIds, this);
if (!this->registerElement(ID,facevtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
- myFacePool->destroy(facevtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+ myFacePool->destroy(facevtk);
+ return 0;
+ }
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
myInfo.myNbBiQuadQuadrangles++;
-// if (!registerElement(ID, face)) {
-// RemoveElement(face, false);
-// face = NULL;
-// }
+ // if (!registerElement(ID, face)) {
+ // RemoveElement(face, false);
+ // face = NULL;
+ // }
return face;
}
}
return 0;
}
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n4->getVtkId());
+ myNodeIds.resize(10);
+ myNodeIds[0] = n1->getVtkId();
+ myNodeIds[1] = n3->getVtkId();
+ myNodeIds[2] = n2->getVtkId();
+ myNodeIds[3] = n4->getVtkId();
- nodeIds.push_back(n31->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n12->getVtkId());
+ myNodeIds[4] = n31->getVtkId();
+ myNodeIds[5] = n23->getVtkId();
+ myNodeIds[6] = n12->getVtkId();
- nodeIds.push_back(n14->getVtkId());
- nodeIds.push_back(n34->getVtkId());
- nodeIds.push_back(n24->getVtkId());
+ myNodeIds[7] = n14->getVtkId();
+ myNodeIds[8] = n34->getVtkId();
+ myNodeIds[9] = n24->getVtkId();
SMDS_VtkVolume *volvtk = myVolumePool->getNew();
- volvtk->init(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
myInfo.myNbQuadTetras++;
-// if (!registerElement(ID, volvtk)) {
-// RemoveElement(volvtk, false);
-// volvtk = NULL;
-// }
+ // if (!registerElement(ID, volvtk)) {
+ // RemoveElement(volvtk, false);
+ // volvtk = NULL;
+ // }
return volvtk;
}
return 0;
}
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n5->getVtkId());
-
- nodeIds.push_back(n41->getVtkId());
- nodeIds.push_back(n34->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n12->getVtkId());
-
- nodeIds.push_back(n15->getVtkId());
- nodeIds.push_back(n45->getVtkId());
- nodeIds.push_back(n35->getVtkId());
- nodeIds.push_back(n25->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
myInfo.myNbQuadPyramids++;
-// if (!registerElement(ID, volvtk)) {
-// RemoveElement(volvtk, false);
-// volvtk = NULL;
-// }
+ // if (!registerElement(ID, volvtk)) {
+ // RemoveElement(volvtk, false);
+ // volvtk = NULL;
+ // }
return volvtk;
}
return 0;
}
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n2->getVtkId());
- nodeIds.push_back(n3->getVtkId());
+ myNodeIds.resize(15);
+ myNodeIds[0] = n1->getVtkId();
+ myNodeIds[1] = n2->getVtkId();
+ myNodeIds[2] = n3->getVtkId();
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n5->getVtkId());
- nodeIds.push_back(n6->getVtkId());
+ myNodeIds[3] = n4->getVtkId();
+ myNodeIds[4] = n5->getVtkId();
+ myNodeIds[5] = n6->getVtkId();
- nodeIds.push_back(n12->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n31->getVtkId());
+ myNodeIds[6] = n12->getVtkId();
+ myNodeIds[7] = n23->getVtkId();
+ myNodeIds[8] = n31->getVtkId();
- nodeIds.push_back(n45->getVtkId());
- nodeIds.push_back(n56->getVtkId());
- nodeIds.push_back(n64->getVtkId());
+ myNodeIds[9] = n45->getVtkId();
+ myNodeIds[10] = n56->getVtkId();
+ myNodeIds[11] = n64->getVtkId();
- nodeIds.push_back(n14->getVtkId());
- nodeIds.push_back(n25->getVtkId());
- nodeIds.push_back(n36->getVtkId());
+ myNodeIds[12] = n14->getVtkId();
+ myNodeIds[13] = n25->getVtkId();
+ myNodeIds[14] = n36->getVtkId();
SMDS_VtkVolume *volvtk = myVolumePool->getNew();
- volvtk->init(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
myInfo.myNbQuadPrisms++;
-// if (!registerElement(ID, volvtk)) {
-// RemoveElement(volvtk, false);
-// volvtk = NULL;
-// }
+ // if (!registerElement(ID, volvtk)) {
+ // RemoveElement(volvtk, false);
+ // volvtk = NULL;
+ // }
return volvtk;
}
// creation quadratic faces - not implemented
}
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
-
- nodeIds.push_back(n5->getVtkId());
- nodeIds.push_back(n8->getVtkId());
- nodeIds.push_back(n7->getVtkId());
- nodeIds.push_back(n6->getVtkId());
-
- nodeIds.push_back(n41->getVtkId());
- nodeIds.push_back(n34->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n12->getVtkId());
-
- nodeIds.push_back(n85->getVtkId());
- nodeIds.push_back(n78->getVtkId());
- nodeIds.push_back(n67->getVtkId());
- nodeIds.push_back(n56->getVtkId());
-
- nodeIds.push_back(n15->getVtkId());
- nodeIds.push_back(n48->getVtkId());
- nodeIds.push_back(n37->getVtkId());
- nodeIds.push_back(n26->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
myInfo.myNbQuadHexas++;
-// if (!registerElement(ID, volvtk)) {
-// RemoveElement(volvtk, false);
-// volvtk = NULL;
-// }
+ // if (!registerElement(ID, volvtk)) {
+ // RemoveElement(volvtk, false);
+ // volvtk = NULL;
+ // }
return volvtk;
}
// creation quadratic faces - not implemented
}
// --- retrieve nodes ID
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- nodeIds.push_back(n1->getVtkId());
- nodeIds.push_back(n4->getVtkId());
- nodeIds.push_back(n3->getVtkId());
- nodeIds.push_back(n2->getVtkId());
-
- nodeIds.push_back(n5->getVtkId());
- nodeIds.push_back(n8->getVtkId());
- nodeIds.push_back(n7->getVtkId());
- nodeIds.push_back(n6->getVtkId());
-
- nodeIds.push_back(n41->getVtkId());
- nodeIds.push_back(n34->getVtkId());
- nodeIds.push_back(n23->getVtkId());
- nodeIds.push_back(n12->getVtkId());
-
- nodeIds.push_back(n85->getVtkId());
- nodeIds.push_back(n78->getVtkId());
- nodeIds.push_back(n67->getVtkId());
- nodeIds.push_back(n56->getVtkId());
-
- nodeIds.push_back(n15->getVtkId());
- nodeIds.push_back(n48->getVtkId());
- nodeIds.push_back(n37->getVtkId());
- nodeIds.push_back(n26->getVtkId());
-
- nodeIds.push_back(n1256->getVtkId());
- nodeIds.push_back(n3478->getVtkId());
- nodeIds.push_back(n1458->getVtkId());
- nodeIds.push_back(n2367->getVtkId());
- nodeIds.push_back(n1234->getVtkId());
- nodeIds.push_back(n5678->getVtkId());
- nodeIds.push_back(nCenter->getVtkId());
+ 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(nodeIds, this);
+ volvtk->init(myNodeIds, this);
if (!this->registerElement(ID,volvtk))
- {
- this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
- myVolumePool->destroy(volvtk);
- return 0;
- }
+ {
+ this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+ myVolumePool->destroy(volvtk);
+ return 0;
+ }
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
myInfo.myNbTriQuadHexas++;
myNodeMin = 0;
if (myNodes.size() == 0)
{
- myNodeMax=0;
- return;
+ myNodeMax=0;
+ return;
}
- while (!myNodes[myNodeMin] && (myNodeMin<myNodes.size()))
+ while ( !myNodes[myNodeMin] && myNodeMin < (int)myNodes.size() )
myNodeMin++;
myNodeMax=myNodes.size()-1;
while (!myNodes[myNodeMax] && (myNodeMin>=0))
// 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);
}
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; i<nbPoints; i++)
{
- ficcon << i << " " << *(myGrid->GetPoint(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; i<nbCells; i++)
{
-// MESSAGE(i << " " << myGrid->GetCell(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; j<nbptcell; j++)
- {
- ficcon << " " << listid->GetId(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; j<nbptcell; j++)
+ {
+ ficcon << " " << listid->GetId(j);
+ }
+ ficcon << endl;
}
ficcon << "-------------------------------- connectivity " << nbPoints << endl;
- vtkCellLinks *links = myGrid->GetCellLinks();
+ vtkCellLinks *links = myGrid->GetCellLinks();
for (int i=0; i<nbPoints; i++)
{
- int ncells = links->GetNcells(i);
- vtkIdType *cells = links->GetCells(i);
- ficcon << i << " - " << ncells << " -";
- for (int j=0; j<ncells; j++)
- {
- ficcon << " " << cells[j];
+ int ncells = links->GetNcells(i);
+ vtkIdType *cells = links->GetCells(i);
+ ficcon << i << " - " << ncells << " -";
+ for (int j=0; j<ncells; j++)
+ {
+ ficcon << " " << cells[j];
}
ficcon << endl;
}
int SMDS_Mesh::fromVtkToSmds(int vtkid)
{
- if (vtkid >= 0 && vtkid < myCellIdVtkToSmds.size())
+ if (vtkid >= 0 && vtkid < (int)myCellIdVtkToSmds.size())
return myCellIdVtkToSmds[vtkid];
throw SALOME_Exception(LOCALIZED ("vtk id out of bounds"));
}
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;
}
void SMDS_Mesh::Modified()
{
if (this->myModified)
- {
- this->myModifTime++;
- MESSAGE("modified");
- myModified = false;
- }
+ {
+ this->myModifTime++;
+ myModified = false;
+ }
}
//! get last modification timeStamp
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;
}
