for(; anIter != aDataSet2411.end(); anIter++){
const TNodeLab& aLabel = anIter->first;
const TRecord& aRec = anIter->second;
- MESSAGE("AddNodeWithID " << aLabel << " " << aRec.coord[0] << " " << aRec.coord[1] << " " << aRec.coord[2]);
+ //MESSAGE("AddNodeWithID " << aLabel << " " << aRec.coord[0] << " " << aRec.coord[1] << " " << aRec.coord[2]);
myMesh->AddNodeWithID(aRec.coord[0],aRec.coord[1],aRec.coord[2],aLabel);
}
}
if(IsBeam(aRec.fe_descriptor_id)) {
switch ( aRec.node_labels.size() ) {
case 2: // edge with two nodes
- MESSAGE("add edge " << aLabel << " " << aRec.node_labels[0] << " " << aRec.node_labels[1]);
+ //MESSAGE("add edge " << aLabel << " " << aRec.node_labels[0] << " " << aRec.node_labels[1]);
anElement = myMesh->AddEdgeWithID(aRec.node_labels[0],
aRec.node_labels[1],
aLabel);
break;
case 3: // quadratic edge (with 3 nodes)
- MESSAGE("add edge " << aLabel << " " << aRec.node_labels[0] << " " << aRec.node_labels[1] << " " << aRec.node_labels[2]);
+ //MESSAGE("add edge " << aLabel << " " << aRec.node_labels[0] << " " << aRec.node_labels[1] << " " << aRec.node_labels[2]);
anElement = myMesh->AddEdgeWithID(aRec.node_labels[0],
aRec.node_labels[2],
aRec.node_labels[1],
}
}
else if(IsFace(aRec.fe_descriptor_id)) {
- MESSAGE("add face " << aLabel);
+ //MESSAGE("add face " << aLabel);
switch(aRec.fe_descriptor_id){
case 71: // TRI3
case 72:
case 42: // Plane Stress Quadratic Triangle - TRI6
case 92: // Thin Shell Quadratic Triangle - TRI6
- MESSAGE("add face " << aLabel << " " << aRec.node_labels[0] << " " << aRec.node_labels[1] << " " << aRec.node_labels[2] << " " << aRec.node_labels[3] << " " << aRec.node_labels[4] << " " << aRec.node_labels[5]);
+ //MESSAGE("add face " << aLabel << " " << aRec.node_labels[0] << " " << aRec.node_labels[1] << " " << aRec.node_labels[2] << " " << aRec.node_labels[3] << " " << aRec.node_labels[4] << " " << aRec.node_labels[5]);
anElement = myMesh->AddFaceWithID(aRec.node_labels[0],
aRec.node_labels[2],
aRec.node_labels[4],
}
}
else if(IsVolume(aRec.fe_descriptor_id)){
- MESSAGE("add volume " << aLabel);
+ //MESSAGE("add volume " << aLabel);
switch(aRec.fe_descriptor_id){
case 111: // Solid Linear Tetrahedron - TET4
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
const SMDS_MeshNode * n3,
int ID)
{
- //MESSAGE("AddFaceWithID " << ID)
+ //MESSAGE("AddFaceWithID " << ID)
SMDS_MeshFace * face=createTriangle(n1, n2, n3, ID);
// if (face && !registerElement(ID, face)) {
SMDS_MeshFace * face;
//if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
- MESSAGE("AddPolygonalFaceWithID " << ID);
if (hasConstructionEdges())
- {
- MESSAGE("Error : Not implemented");
- return NULL;
- }
+ {
+ MESSAGE("Error : Not implemented");
+ return NULL;
+ }
else
- {
- for ( int i = 0; i < nodes.size(); ++i )
+ {
+#ifdef VTK_HAVE_POLYHEDRON
+ MESSAGE("AddPolygonalFaceWithID vtk " << ID);
+ vector<vtkIdType> nodeIds;
+ nodeIds.clear();
+ vector<const SMDS_MeshNode*>::iterator it = nodes.begin();
+ for ( ; it != nodes.end(); ++it)
+ nodeIds.push_back((*it)->getId());
+
+ SMDS_VtkFace *facevtk = myFacePool->getNew();
+ facevtk->initPoly(nodeIds, 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);
- adjustmyCellsCapacity(ID);
- myCells[ID] = face;
- myInfo.myNbPolygons++;
- }
+ face = new SMDS_PolygonalFaceOfNodes(nodes);
+#endif
+ adjustmyCellsCapacity(ID);
+ myCells[ID] = face;
+ myInfo.myNbPolygons++;
+ }
- if (!registerElement(ID, face)) {
- registerElement(myElementIDFactory->GetFreeID(), face);
- //RemoveElement(face, false);
- //face = NULL;
- }
- return face;
+#ifndef VTK_HAVE_POLYHEDRON
+ if (!registerElement(ID, face))
+ {
+ registerElement(myElementIDFactory->GetFreeID(), face);
+ //RemoveElement(face, false);
+ //face = NULL;
+ }
+#endif
+ return face;
}
///////////////////////////////////////////////////////////////////////////////
vector<int> quantities,
const int ID)
{
- MESSAGE("AddPolyhedralVolumeWithID" << ID);
SMDS_MeshVolume* volume;
//if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
- if (hasConstructionFaces()) {
- MESSAGE("Error : Not implemented");
- return NULL;
- } else if (hasConstructionEdges()) {
- MESSAGE("Error : Not implemented");
- return NULL;
- } else {
+ if (hasConstructionFaces())
+ {
+ MESSAGE("Error : Not implemented");
+ return NULL;
+ }
+ else if (hasConstructionEdges())
+ {
+ MESSAGE("Error : Not implemented");
+ return NULL;
+ }
+ else
+ {
#ifdef VTK_HAVE_POLYHEDRON
- vector<vtkIdType> nodeIds;
- nodeIds.clear();
- vector<const SMDS_MeshNode*>::iterator it = nodes.begin();
- for ( ; it != nodes.end(); ++it)
- nodeIds.push_back((*it)->getId());
-
- 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;
+ MESSAGE("AddPolyhedralVolumeWithID vtk " << ID);
+ vector<vtkIdType> nodeIds;
+ nodeIds.clear();
+ vector<const SMDS_MeshNode*>::iterator it = nodes.begin();
+ for (; it != nodes.end(); ++it)
+ nodeIds.push_back((*it)->getId());
+
+ 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
- for ( int i = 0; i < nodes.size(); ++i )
+ MESSAGE("AddPolyhedralVolumeWithID smds " << ID);
+ for ( int i = 0; i < nodes.size(); ++i )
if ( !nodes[ i ] ) return 0;
- volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
+ volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
#endif
- adjustmyCellsCapacity(ID);
- myCells[ID] = volume;
- myInfo.myNbPolyhedrons++;
- }
+ adjustmyCellsCapacity(ID);
+ myCells[ID] = volume;
+ myInfo.myNbPolyhedrons++;
+ }
#ifndef VTK_HAVE_POLYHEDRON
- if (!registerElement(ID, volume)) {
- registerElement(myElementIDFactory->GetFreeID(), volume);
- //RemoveElement(volume, false);
- //volume = NULL;
- }
+ if (!registerElement(ID, volume))
+ {
+ registerElement(myElementIDFactory->GetFreeID(), volume);
+ //RemoveElement(volume, false);
+ //volume = NULL;
+ }
#endif
return volume;
}
switch(element->GetType())
{
case SMDSAbs_Node:
- MESSAGE("Internal Error: This should not happend");
+ MESSAGE("Internal Error: This should not happen");
break;
case SMDSAbs_0DElement:
{
//MESSAGE("SMDS_Mesh::RemoveElement " << elem->GetID() << " " << removenodes);
// get finite elements built on elem
set<const SMDS_MeshElement*> * s1;
- if (elem->GetType() == SMDSAbs_0DElement ||
- elem->GetType() == SMDSAbs_Edge && !hasConstructionEdges() ||
- elem->GetType() == SMDSAbs_Face && !hasConstructionFaces() ||
- elem->GetType() == SMDSAbs_Volume)
- {
- s1 = new set<const SMDS_MeshElement*>();
- s1->insert(elem);
- }
+ if (elem->GetType() == SMDSAbs_0DElement || elem->GetType() == SMDSAbs_Edge && !hasConstructionEdges()
+ || elem->GetType() == SMDSAbs_Face && !hasConstructionFaces() || elem->GetType() == SMDSAbs_Volume)
+ {
+ s1 = new set<const SMDS_MeshElement*> ();
+ s1->insert(elem);
+ }
else
s1 = getFinitElements(elem);
// get exclusive nodes (which would become free afterwards)
set<const SMDS_MeshElement*> * s2;
if (elem->GetType() == SMDSAbs_Node) // a node is removed
- {
- // do not remove nodes except elem
- s2 = new set<const SMDS_MeshElement*>();
- s2->insert(elem);
- removenodes = true;
- }
+ {
+ // do not remove nodes except elem
+ s2 = new set<const SMDS_MeshElement*> ();
+ s2->insert(elem);
+ removenodes = true;
+ }
else
s2 = getExclusiveNodes(*s1);
// form the set of finite and construction elements to remove
set<const SMDS_MeshElement*> s3;
- set<const SMDS_MeshElement*>::iterator it=s1->begin();
- while(it!=s1->end())
- {
- addChildrenWithNodes(s3, *it ,*s2);
- s3.insert(*it);
- it++;
- }
- if(elem->GetType()!=SMDSAbs_Node) s3.insert(elem);
-
- // remove finite and construction elements
- it=s3.begin();
- while(it!=s3.end())
- {
- // Remove element from <InverseElements> of its nodes
- SMDS_ElemIteratorPtr itn=(*it)->nodesIterator();
- while(itn->more())
+ set<const SMDS_MeshElement*>::iterator it = s1->begin();
+ while (it != s1->end())
{
- SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
- (const_cast<SMDS_MeshElement *>(itn->next()));
- n->RemoveInverseElement( (*it) );
+ addChildrenWithNodes(s3, *it, *s2);
+ s3.insert(*it);
+ it++;
}
- int IdToRemove = (*it)->GetID();
- MESSAGE("elem Id to remove " << IdToRemove << " vtktype " << (*it)->GetVtkType());
- switch((*it)->GetType())
+ if (elem->GetType() != SMDSAbs_Node)
+ s3.insert(elem);
+
+ // remove finite and construction elements
+ it = s3.begin();
+ while (it != s3.end())
{
- case SMDSAbs_Node:
- MYASSERT("Internal Error: This should not happen");
- break;
- case SMDSAbs_0DElement:
- if (IdToRemove >= 0)
- {
- myCells[IdToRemove] = 0; // -PR- ici ou dans myElementIDFactory->ReleaseID ?
- myInfo.remove(*it);
- }
- removedElems.push_back( (*it) );
- myElementIDFactory->ReleaseID(IdToRemove);
- delete (*it);
- break;
- case SMDSAbs_Edge:
- if (IdToRemove >= 0)
- {
- myCells[IdToRemove] = 0;
- myInfo.RemoveEdge(*it);
- }
- removedElems.push_back( (*it) );
- myElementIDFactory->ReleaseID(IdToRemove);
- if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
- myEdgePool->destroy((SMDS_VtkEdge*)vtkElem);
- else delete (*it);
- break;
- case SMDSAbs_Face:
- if (IdToRemove >= 0)
+ // Remove element from <InverseElements> of its nodes
+ SMDS_ElemIteratorPtr itn = (*it)->nodesIterator();
+ while (itn->more())
{
- myCells[IdToRemove] = 0;
- myInfo.RemoveFace(*it);
+ SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (itn->next()));
+ n->RemoveInverseElement((*it));
}
- removedElems.push_back( (*it) );
- myElementIDFactory->ReleaseID(IdToRemove);
- if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
- myFacePool->destroy((SMDS_VtkFace*)vtkElem);
- else delete (*it);
- break;
- case SMDSAbs_Volume:
- if (IdToRemove >= 0)
+ int IdToRemove = (*it)->GetID();
+ int vtkid = this->fromSmdsToVtk(IdToRemove);
+ //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")
+ ;
+ break;
+ case SMDSAbs_0DElement:
+ if (IdToRemove >= 0)
+ {
+ myCells[IdToRemove] = 0; // -PR- ici ou dans myElementIDFactory->ReleaseID ?
+ myInfo.remove(*it);
+ }
+ removedElems.push_back((*it));
+ myElementIDFactory->ReleaseID(IdToRemove);
+ delete (*it);
+ break;
+ case SMDSAbs_Edge:
+ if (IdToRemove >= 0)
+ {
+ myCells[IdToRemove] = 0;
+ myInfo.RemoveEdge(*it);
+ }
+ removedElems.push_back((*it));
+ myElementIDFactory->ReleaseID(IdToRemove);
+ if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
+ myEdgePool->destroy((SMDS_VtkEdge*) vtkElem);
+ else
+ delete (*it);
+ break;
+ case SMDSAbs_Face:
+ if (IdToRemove >= 0)
+ {
+ myCells[IdToRemove] = 0;
+ myInfo.RemoveFace(*it);
+ }
+ removedElems.push_back((*it));
+ myElementIDFactory->ReleaseID(IdToRemove);
+ if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
+ myFacePool->destroy((SMDS_VtkFace*) vtkElem);
+ else
+ delete (*it);
+ break;
+ case SMDSAbs_Volume:
+ if (IdToRemove >= 0)
+ {
+ myCells[IdToRemove] = 0;
+ myInfo.RemoveVolume(*it);
+ }
+ removedElems.push_back((*it));
+ myElementIDFactory->ReleaseID(IdToRemove);
+ if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
+ myVolumePool->destroy((SMDS_VtkVolume*) vtkElem);
+ else
+ delete (*it);
+ break;
+ }
+ if (vtkid >= 0)
{
- myCells[IdToRemove] = 0;
- myInfo.RemoveVolume(*it);
+ //MESSAGE("VTK_EMPTY_CELL in " << vtkid);
+ this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL);
}
- removedElems.push_back( (*it) );
- myElementIDFactory->ReleaseID(IdToRemove);
- if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
- myVolumePool->destroy((SMDS_VtkVolume*)vtkElem);
- else delete (*it);
- break;
+ it++;
}
- it++;
- }
// remove exclusive (free) nodes
- if(removenodes)
- {
- it=s2->begin();
- while(it!=s2->end())
+ if (removenodes)
{
- int IdToRemove = (*it)->GetID();
- MESSAGE( "SMDS: RM node " << IdToRemove);
- if (IdToRemove >= 0)
+ it = s2->begin();
+ while (it != s2->end())
{
- myNodes[IdToRemove] = 0;
- myInfo.myNbNodes--;
+ int IdToRemove = (*it)->GetID();
+ //MESSAGE( "SMDS: RM node " << IdToRemove);
+ if (IdToRemove >= 0)
+ {
+ myNodes[IdToRemove] = 0;
+ myInfo.myNbNodes--;
+ }
+ myNodeIDFactory->ReleaseID((*it)->GetID());
+ removedNodes.push_back((*it));
+ if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
+ myNodePool->destroy((SMDS_MeshNode*) vtkElem);
+ else
+ delete (*it);
+ it++;
}
- myNodeIDFactory->ReleaseID((*it)->GetID());
- removedNodes.push_back( (*it) );
- if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
- myNodePool->destroy((SMDS_MeshNode*)vtkElem);
- else delete (*it);
- it++;
}
- }
delete s2;
delete s1;
{
if (ID < 0)
{
- MESSAGE("~~~~~~~~~~~~~~ SMDS_MeshElementIDFactory::ReleaseID ID = " << ID);
+ //MESSAGE("~~~~~~~~~~~~~~ SMDS_MeshElementIDFactory::ReleaseID ID = " << ID);
return;
}
int vtkId = myMesh->myIDElements[ID];
MESSAGE(" -------- newCellSize, endBloc " << endBloc << " " << oldCellSize);
copyBloc(newTypes, idCellsOldToNew, idNodesOldToNew, newConnectivity, newLocations, pointsCell,
alreadyCopied, startBloc, endBloc);
- compactState = lookHoleStart;
+ compactState = lookHoleEnd;
}
break;
}
_cellId = vtkCellId;
_index = 0;
_type = aType;
- MESSAGE("SMDS_VtkCellInterlacedIterator " << _type);
+ //MESSAGE("SMDS_VtkCellInterlacedIterator " << _type);
_vtkIdList = vtkIdList::New();
vtkIdType* pts;
}
case SMDSEntity_Polygon:
case SMDSEntity_Quad_Polygon:
- {
- MESSAGE("SMDS_VtkCellIterator polygon");
- break;
- }
case SMDSEntity_Polyhedra:
case SMDSEntity_Quad_Polyhedra:
- {
- MESSAGE("SMDS_VtkCellIterator Polyhedra");
- break;
- }
default:
{
- static int id[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+ static int id[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29};
ids = id;
break;
}
return true;
}
+bool SMDS_VtkEdge::IsMediumNode(const SMDS_MeshNode* node) const
+{
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType npts = 0;
+ vtkIdType* pts = 0;
+ grid->GetCellPoints(myVtkID, npts, pts);
+ return ((npts == 3) && (node->GetID() == pts[2]));
+}
+
void SMDS_VtkEdge::Print(std::ostream & OS) const
{
OS << "edge <" << GetID() << "> : ";
const SMDS_MeshNode*
SMDS_VtkEdge::GetNode(const int ind) const
{
- return SMDS_MeshElement::GetNode(ind); // --- a optimiser !
+ // TODO optimize !!
+ return SMDS_MeshElement::GetNode(ind);
}
bool SMDS_VtkEdge::IsQuadratic() const
void init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh);
bool ChangeNodes(const SMDS_MeshNode * node1, const SMDS_MeshNode * node2);
virtual bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
+ virtual bool IsMediumNode(const SMDS_MeshNode* node) const;
void Print(std::ostream & OS) const;
int NbNodes() const;
aType = VTK_QUADRATIC_QUAD;
break;
default:
- aType = VTK_TRIANGLE;
+ aType = VTK_POLYGON;
break;
}
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
}
+void SMDS_VtkFace::initPoly(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
+{
+ vtkUnstructuredGrid* grid = mesh->getGrid();
+ myIdInShape = -1;
+ myMeshId = mesh->getMeshId();
+ myVtkID = grid->InsertNextLinkedCell(VTK_POLYGON, nodeIds.size(), &nodeIds[0]);
+}
+
bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
{
vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes);
return false;
}
- for (int i=0; i<nbNodes; i++)
+ for (int i = 0; i < nbNodes; i++)
{
pts[i] = nodes[i]->GetID();
}
void SMDS_VtkFace::Print(std::ostream & OS) const
{
- OS << "edge <" << GetID() << "> : ";
+ OS << "face <" << GetID() << "> : ";
}
int SMDS_VtkFace::NbEdges() const
{
- switch (NbNodes())
+ // TODO quadratic polygons ?
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ int nbEdges = 3;
+ switch (aVtkType)
{
- case 3:
- case 6:
- return 3;
- case 4:
- case 8:
- return 4;
+ case VTK_TRIANGLE:
+ case VTK_QUADRATIC_TRIANGLE:
+ nbEdges = 3;
+ break;
+ case VTK_QUAD:
+ case VTK_QUADRATIC_QUAD:
+ nbEdges = 4;
+ break;
+ case VTK_POLYGON:
default:
- MESSAGE("invalid number of nodes")
- ;
+ nbEdges = grid->GetCell(myVtkID)->GetNumberOfPoints();
+ break;
}
- return 0;
+ return nbEdges;
}
int SMDS_VtkFace::NbFaces() const
bool SMDS_VtkFace::IsQuadratic() const
{
- if (this->NbNodes() > 5)
- return true;
- else
- return false;
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ // TODO quadratic polygons ?
+ switch (aVtkType)
+ {
+ case VTK_QUADRATIC_TRIANGLE:
+ case VTK_QUADRATIC_QUAD:
+ return true;
+ break;
+ default:
+ return false;
+ }
+}
+
+bool SMDS_VtkFace::IsPoly() const
+{
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ return (aVtkType == VTK_POLYGON);
}
SMDSAbs_EntityType SMDS_VtkFace::GetEntityType() const
{
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
SMDSAbs_EntityType aType = SMDSEntity_Polygon;
- switch (NbNodes())
+ switch (aVtkType)
{
- case 3:
+ case VTK_TRIANGLE:
aType = SMDSEntity_Triangle;
break;
- case 6:
- aType = SMDSEntity_Quad_Triangle;
- break;
- case 4:
+ case VTK_QUAD:
aType = SMDSEntity_Quadrangle;
break;
- case 8:
+ case VTK_QUADRATIC_TRIANGLE:
+ aType = SMDSEntity_Quad_Triangle;
+ break;
+ case VTK_QUADRATIC_QUAD:
aType = SMDSEntity_Quad_Quadrangle;
break;
+ default:
+ aType = SMDSEntity_Polygon;
}
return aType;
}
-vtkIdType SMDS_VtkFace::GetVtkType() const
-{
- switch (NbNodes())
+ vtkIdType SMDS_VtkFace::GetVtkType() const
{
- case 3:
- return VTK_TRIANGLE;
- case 6:
- return VTK_QUADRATIC_TRIANGLE;
- case 4:
- return VTK_QUAD;
- case 8:
- return VTK_QUADRATIC_QUAD;
- default:
- return VTK_POLYGON;
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ return aVtkType;
}
-}
-SMDS_ElemIteratorPtr SMDS_VtkFace::elementsIterator(SMDSAbs_ElementType type) const
-{
- switch (type)
+ SMDS_ElemIteratorPtr SMDS_VtkFace::elementsIterator(SMDSAbs_ElementType type) const
{
- case SMDSAbs_Node:
- return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
- default:
- MESSAGE("ERROR : Iterator not implemented");
- return SMDS_ElemIteratorPtr((SMDS_ElemIterator*) NULL);
+ switch (type)
+ {
+ case SMDSAbs_Node:
+ return SMDS_ElemIteratorPtr(new SMDS_VtkCellIterator(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
+ default:
+ MESSAGE("ERROR : Iterator not implemented")
+ ;
+ return SMDS_ElemIteratorPtr((SMDS_ElemIterator*) NULL);
+ }
}
-}
-SMDS_ElemIteratorPtr SMDS_VtkFace::nodesIteratorToUNV() const
-{
- return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
-}
+ SMDS_ElemIteratorPtr SMDS_VtkFace::nodesIteratorToUNV() const
+ {
+ return SMDS_ElemIteratorPtr(new SMDS_VtkCellIteratorToUNV(SMDS_Mesh::_meshList[myMeshId], myVtkID, GetEntityType()));
+ }
SMDS_VtkFace(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh);
~SMDS_VtkFace();
void init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh);
+ void initPoly(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh);
bool ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes);
void Print(std::ostream & OS) const;
virtual SMDSAbs_EntityType GetEntityType() const;
virtual const SMDS_MeshNode* GetNode(const int ind) const;
virtual bool IsQuadratic() const;
+ virtual bool IsPoly() const;
protected:
virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const;
{
MESSAGE("SMDS_VtkVolume::initPoly");
SMDS_UnstructuredGrid* grid = mesh->getGrid();
+ // TODO is it useful to orient faces ?
+ double center[3];
+ this->gravityCenter(grid, &nodeIds[0], nodeIds.size(), ¢er[0]);
vector<vtkIdType> ptIds;
ptIds.clear();
vtkIdType nbFaces = nbNodesPerFace.size();
{
int nf = nbNodesPerFace[i];
ptIds.push_back(nf);
- for (int n = 0; n < nf; n++)
- {
- ptIds.push_back(nodeIds[k]);
- k++;
- }
+ double a[3];
+ double b[3];
+ double c[3];
+ grid->GetPoints()->GetPoint(nodeIds[k],a);
+ grid->GetPoints()->GetPoint(nodeIds[k+1],b);
+ grid->GetPoints()->GetPoint(nodeIds[k+2],c);
+ bool isFaceForward = this->isForward(a, b, c, center);
+ //MESSAGE("isFaceForward " << i << " " << isFaceForward);
+ vtkIdType *facePts = &nodeIds[k];
+ if (isFaceForward)
+ for (int n = 0; n < nf; n++)
+ ptIds.push_back(facePts[n]);
+ else
+ for (int n = nf-1; n >= 0; n--)
+ ptIds.push_back(facePts[n]);
+ k += nf;
}
myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
}
int SMDS_VtkVolume::NbFaces() const
{
- // TODO polyedres
- switch (NbNodes())
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ int nbFaces = 4;
+ switch (aVtkType)
{
- case 4:
- case 10:
- return 4;
- case 5:
- case 13:
- return 5;
- case 6:
- case 15:
- return 5;
- case 8:
- case 20:
- return 6;
+ case VTK_TETRA:
+ case VTK_QUADRATIC_TETRA:
+ nbFaces = 4;
+ break;
+ case VTK_PYRAMID:
+ case VTK_WEDGE:
+ case VTK_QUADRATIC_PYRAMID:
+ case VTK_QUADRATIC_WEDGE:
+ nbFaces = 5;
+ break;
+ case VTK_HEXAHEDRON:
+ case VTK_QUADRATIC_HEXAHEDRON:
+ nbFaces = 6;
+ break;
+ case VTK_POLYHEDRON:
+ {
+ vtkIdType nFaces = 0;
+ vtkIdType* ptIds = 0;
+ grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
+ nbFaces = nFaces;
+ }
default:
- MESSAGE("invalid number of nodes")
- ;
+ MESSAGE("invalid volume type");
+ nbFaces = 0;
+ break;
}
- return 0;
+ return nbFaces;
}
int SMDS_VtkVolume::NbNodes() const
int SMDS_VtkVolume::NbEdges() const
{
- // TODO polyedres
- switch (NbNodes())
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ int nbEdges = 6;
+ switch (aVtkType)
{
- case 4:
- case 10:
- return 6;
- case 5:
- case 13:
- return 8;
- case 6:
- case 15:
- return 9;
- case 8:
- case 20:
- return 12;
+ case VTK_TETRA:
+ case VTK_QUADRATIC_TETRA:
+ nbEdges = 6;
+ break;
+ case VTK_PYRAMID:
+ case VTK_QUADRATIC_PYRAMID:
+ nbEdges = 8;
+ break;
+ case VTK_WEDGE:
+ case VTK_QUADRATIC_WEDGE:
+ nbEdges = 9;
+ break;
+ case VTK_HEXAHEDRON:
+ case VTK_QUADRATIC_HEXAHEDRON:
+ nbEdges = 12;
+ break;
+ case VTK_POLYHEDRON:
+ {
+ vtkIdType nFaces = 0;
+ vtkIdType* ptIds = 0;
+ grid->GetFaceStream(this->myVtkID, nFaces, ptIds);
+ nbEdges = 0;
+ int id = 0;
+ for (int i = 0; i < nFaces; i++)
+ {
+ int edgesInFace = ptIds[id];
+ id += (edgesInFace + 1);
+ nbEdges += edgesInFace;
+ }
+ nbEdges = nbEdges / 2;
+ break;
+ }
default:
- MESSAGE("invalid number of nodes")
- ;
+ MESSAGE("invalid volume type");
+ nbEdges = 0;
+ break;
}
- return 0;
+ return nbEdges;
}
SMDS_ElemIteratorPtr SMDS_VtkVolume::elementsIterator(SMDSAbs_ElementType type) const
bool SMDS_VtkVolume::IsQuadratic() const
{
- // TODO polyedres
- if (this->NbNodes() > 9)
- return true;
- else
- return false;
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ // TODO quadratic polyhedrons ?
+ switch (aVtkType)
+ {
+ case VTK_QUADRATIC_TETRA:
+ case VTK_QUADRATIC_PYRAMID:
+ case VTK_QUADRATIC_WEDGE:
+ case VTK_QUADRATIC_HEXAHEDRON:
+ return true;
+ break;
+ default:
+ return false;
+ }
+}
+
+bool SMDS_VtkVolume::IsPoly() const
+{
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
+ return (aVtkType == VTK_POLYHEDRON);
}
SMDSAbs_EntityType SMDS_VtkVolume::GetEntityType() const
{
- // TODO see SMDS_MeshElementIDFactory::GetVtkCellType
- vtkIdType aVtkType = this->GetVtkType();
+ vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid();
+ vtkIdType aVtkType = grid->GetCellType(this->myVtkID);
SMDSAbs_EntityType aType = SMDSEntity_Tetra;
switch (aVtkType)
vtkIdType aType = grid->GetCellType(myVtkID);
return aType;
}
+
+ void SMDS_VtkVolume::gravityCenter(SMDS_UnstructuredGrid* grid, vtkIdType *nodeIds, int nbNodes, double* result)
+{
+ for (int j=0; j<3; j++)
+ result[j] = 0;
+ if (nbNodes <= 0)
+ return;
+ for (int i =0; i< nbNodes; i++)
+ {
+ double *coords = grid->GetPoint(nodeIds[i]);
+ for (int j=0; j<3; j++)
+ result[j] += coords[j];
+ }
+ for (int j=0; j<3; j++)
+ result[j] = result[j]/nbNodes;
+ //MESSAGE("center " << result[0] << " " << result[1] << " " << result[2]);
+ return;
+}
+
+ bool SMDS_VtkVolume::isForward(double* a,double* b,double* c,double* d)
+ {
+ double u[3], v[3], w[3];
+ for (int j = 0; j < 3; j++)
+ {
+ //MESSAGE("a,b,c,d " << a[j] << " " << b[j] << " " << c[j] << " " << d[j]);
+ u[j] = b[j] - a[j];
+ v[j] = c[j] - a[j];
+ w[j] = d[j] - a[j];
+ //MESSAGE("u,v,w " << u[j] << " " << v[j] << " " << w[j]);
+ }
+ double prodmixte = (u[2] * v[3] - u[3] * v[2]) * w[1]
+ + (u[3] * v[1] - u[1] * v[3]) * w[2]
+ + (u[1] * v[2] - u[2] * v[1]) * w[3];
+ return (prodmixte >= 0);
+}
virtual SMDSAbs_EntityType GetEntityType() const;
virtual const SMDS_MeshNode* GetNode(const int ind) const;
virtual bool IsQuadratic() const;
+ virtual bool IsPoly() const;
+ static void gravityCenter(SMDS_UnstructuredGrid* grid,
+ vtkIdType *nodeIds,
+ int nbNodes,
+ double* result);
+ static bool isForward(double* a,double* b,double* c,double* d);
protected:
virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type) const;
const bool isPoly,
const int ID)
{
+ //MESSAGE("AddElement " <<node.size() << " " << type << " " << isPoly << " " << ID);
SMDS_MeshElement* e = 0;
int nbnode = node.size();
SMESHDS_Mesh* mesh = GetMeshDS();
switch ( type ) {
case SMDSAbs_0DElement:
if ( nbnode == 1 )
- if ( ID ) e = mesh->Add0DElementWithID(node[0], ID);
+ if ( ID >= 0 ) e = mesh->Add0DElementWithID(node[0], ID);
else e = mesh->Add0DElement (node[0] );
break;
case SMDSAbs_Edge:
if ( nbnode == 2 )
- if ( ID ) e = mesh->AddEdgeWithID(node[0], node[1], ID);
+ if ( ID >= 0 ) e = mesh->AddEdgeWithID(node[0], node[1], ID);
else e = mesh->AddEdge (node[0], node[1] );
else if ( nbnode == 3 )
- if ( ID ) e = mesh->AddEdgeWithID(node[0], node[1], node[2], ID);
+ if ( ID >= 0 ) e = mesh->AddEdgeWithID(node[0], node[1], node[2], ID);
else e = mesh->AddEdge (node[0], node[1], node[2] );
break;
case SMDSAbs_Face:
if ( !isPoly ) {
if (nbnode == 3)
- if ( ID ) e = mesh->AddFaceWithID(node[0], node[1], node[2], ID);
+ if ( ID >= 0 ) e = mesh->AddFaceWithID(node[0], node[1], node[2], ID);
else e = mesh->AddFace (node[0], node[1], node[2] );
else if (nbnode == 4)
- if ( ID ) e = mesh->AddFaceWithID(node[0], node[1], node[2], node[3], ID);
+ if ( ID >= 0 ) e = mesh->AddFaceWithID(node[0], node[1], node[2], node[3], ID);
else e = mesh->AddFace (node[0], node[1], node[2], node[3] );
else if (nbnode == 6)
- if ( ID ) e = mesh->AddFaceWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddFaceWithID(node[0], node[1], node[2], node[3],
node[4], node[5], ID);
else e = mesh->AddFace (node[0], node[1], node[2], node[3],
node[4], node[5] );
else if (nbnode == 8)
- if ( ID ) e = mesh->AddFaceWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddFaceWithID(node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7], ID);
else e = mesh->AddFace (node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7] );
} else {
- if ( ID ) e = mesh->AddPolygonalFaceWithID(node, ID);
+ if ( ID >= 0 ) e = mesh->AddPolygonalFaceWithID(node, ID);
else e = mesh->AddPolygonalFace (node );
}
break;
case SMDSAbs_Volume:
if ( !isPoly ) {
if (nbnode == 4)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3], ID);
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3], ID);
else e = mesh->AddVolume (node[0], node[1], node[2], node[3] );
else if (nbnode == 5)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], ID);
else e = mesh->AddVolume (node[0], node[1], node[2], node[3],
node[4] );
else if (nbnode == 6)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], node[5], ID);
else e = mesh->AddVolume (node[0], node[1], node[2], node[3],
node[4], node[5] );
else if (nbnode == 8)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7], ID);
else e = mesh->AddVolume (node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7] );
else if (nbnode == 10)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7],
node[8], node[9], ID);
else e = mesh->AddVolume (node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7],
node[8], node[9] );
else if (nbnode == 13)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7],
node[8], node[9], node[10],node[11],
node[12],ID);
node[8], node[9], node[10],node[11],
node[12] );
else if (nbnode == 15)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7],
node[8], node[9], node[10],node[11],
node[12],node[13],node[14],ID);
node[8], node[9], node[10],node[11],
node[12],node[13],node[14] );
else if (nbnode == 20)
- if ( ID ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
+ if ( ID >= 0 ) e = mesh->AddVolumeWithID(node[0], node[1], node[2], node[3],
node[4], node[5], node[6], node[7],
node[8], node[9], node[10],node[11],
node[12],node[13],node[14],node[15],
// check case of quadratic faces
if (theTria1->GetEntityType() != SMDSEntity_Quad_Triangle)
return false;
- if (theTria2->GetEntityType() == SMDSEntity_Quad_Triangle)
+ if (theTria2->GetEntityType() != SMDSEntity_Quad_Triangle)
return false;
// 5
list<const SMDS_MeshNode*>& nodes = *grIt;
list<const SMDS_MeshNode*>::iterator nIt = nodes.begin();
const SMDS_MeshNode* nToKeep = *nIt;
+ //MESSAGE("node to keep " << nToKeep->GetID());
for ( ++nIt; nIt != nodes.end(); nIt++ ) {
const SMDS_MeshNode* nToRemove = *nIt;
nodeNodeMap.insert( TNodeNodeMap::value_type( nToRemove, nToKeep ));
if ( nToRemove != nToKeep ) {
+ //MESSAGE(" node to remove " << nToRemove->GetID());
rmNodeIds.push_back( nToRemove->GetID() );
AddToSameGroups( nToKeep, nToRemove, aMesh );
}
set<const SMDS_MeshElement*>::iterator eIt = elems.begin();
for ( ; eIt != elems.end(); eIt++ ) {
const SMDS_MeshElement* elem = *eIt;
+ //MESSAGE(" ---- inverse elem on node to remove " << elem->GetID());
int nbNodes = elem->NbNodes();
int aShapeId = FindShape( elem );
bool isOk = true;
int nbUniqueNodes = nodeSet.size();
+ //MESSAGE("nbNodes nbUniqueNodes " << nbNodes << " " << nbUniqueNodes);
if ( nbNodes != nbUniqueNodes ) { // some nodes stick
// Polygons and Polyhedral volumes
if (elem->IsPoly()) {
isOk = false;
else if ( nbRepl == 2 && iRepl[ 1 ] - iRepl[ 0 ] == 2 )
isOk = false; // opposite nodes stick
+ //MESSAGE("isOk " << isOk);
}
break;
case 6: ///////////////////////////////////// PENTAHEDRON
}
}
else {
- // Change regular element or polygon
- SMDS_MeshElement* newElem = 0;
- switch (nbUniqueNodes)
- {
- case 3:
- newElem = aMesh->AddFace(uniqueNodes[0], uniqueNodes[1], uniqueNodes[2]);
- break;
- case 4:
- newElem = aMesh->AddVolume(uniqueNodes[0], uniqueNodes[1], uniqueNodes[2],
- uniqueNodes[3]);
- break;
- case 5:
- newElem = aMesh->AddVolume(uniqueNodes[0], uniqueNodes[1], uniqueNodes[2],
- uniqueNodes[3], uniqueNodes[4]);
- break;
- case 6:
- newElem = aMesh->AddVolume(uniqueNodes[0], uniqueNodes[1], uniqueNodes[2],
- uniqueNodes[3], uniqueNodes[4], uniqueNodes[5]);
- break;
- default:
- MESSAGE("invalid number of nodes:" << nbUniqueNodes);
- }
+ //MESSAGE("Change regular element or polygon " << elem->GetID());
+ SMDSAbs_ElementType etyp = elem->GetType();
+ uniqueNodes.resize(nbUniqueNodes);
+ SMDS_MeshElement* newElem = this->AddElement(uniqueNodes, etyp, false);
if (newElem)
{
myLastCreatedElems.Append(newElem);
}
else {
// Remove invalid regular element or invalid polygon
+ //MESSAGE("Remove invalid " << elem->GetID());
rmElemIds.push_back( elem->GetID() );
}
// links of the free border
// -------------------------------------------------------------------------
- // 1. Since sewing may brake if there are volumes to split on the side 2,
+ // 1. Since sewing may break if there are volumes to split on the side 2,
// we wont move nodes but just compute new coordinates for them
typedef map<const SMDS_MeshNode*, gp_XYZ> TNodeXYZMap;
TNodeXYZMap nBordXYZ;
return;
}
+ SMESHDS_Mesh *aMesh = GetMeshDS();
if( !theFace->IsQuadratic() ) {
// put aNodesToInsert between theBetweenNode1 and theBetweenNode2
}
// create new elements
- SMESHDS_Mesh *aMesh = GetMeshDS();
int aShapeId = FindShape( theFace );
i1 = 0; i2 = 1;
newNodes[ 1 ] = linkNodes[ i2 ];
newNodes[ 2 ] = nodes[ iSplit >= iBestQuad ? i3 : i4 ];
newNodes[ 3 ] = nodes[ i4 ];
- // TODO problem ChangeElementNodes : not the same number of nodes, not the same type
- MESSAGE("ChangeElementNodes");
- aMesh->ChangeElementNodes( theFace, newNodes, iSplit == iBestQuad ? 4 : 3 );
- } // end if(!theFace->IsQuadratic())
+ //aMesh->ChangeElementNodes( theFace, newNodes, iSplit == iBestQuad ? 4 : 3 );
+ const SMDS_MeshElement* newElem = 0;
+ if (iSplit == iBestQuad)
+ newElem = aMesh->AddFace( newNodes[0], newNodes[1], newNodes[2], newNodes[3] );
+ else
+ newElem = aMesh->AddFace( newNodes[0], newNodes[1], newNodes[2] );
+ myLastCreatedElems.Append(newElem);
+ if ( aShapeId && newElem )
+ aMesh->SetMeshElementOnShape( newElem, aShapeId );
+} // end if(!theFace->IsQuadratic())
else { // theFace is quadratic
// we have to split theFace on simple triangles and one simple quadrangle
int tmp = il1/2;
// n4 n6 n5 n4
// create new elements
- SMESHDS_Mesh *aMesh = GetMeshDS();
int aShapeId = FindShape( theFace );
int n1,n2,n3;
if ( aShapeId && newElem )
aMesh->SetMeshElementOnShape( newElem, aShapeId );
}
- // remove old quadratic face
- aMesh->RemoveElement(theFace);
}
+ // remove old face
+ aMesh->RemoveElement(theFace);
}
//=======================================================================
// 1. Build set of faces representing each side:
// =======================================================================
// a. build set of nodes belonging to faces
- // b. complete set of faces: find missing fices whose nodes are in set of nodes
+ // b. complete set of faces: find missing faces whose nodes are in set of nodes
// c. create temporary faces representing side of volumes if correspondent
// face does not exist
// -----------------------------------------------------------
// 1a. Collect nodes of existing faces
// and build set of face nodes in order to detect missing
- // faces corresponing to sides of volumes
+ // faces corresponding to sides of volumes
// -----------------------------------------------------------
set< set <const SMDS_MeshNode*> > setOfFaceNodeSet;
volSet->insert( elem );
}
// ------------------------------------------------------------------------------
- // 1b. Complete set of faces: find missing fices whose nodes are in set of nodes
+ // 1b. Complete set of faces: find missing faces whose nodes are in set of nodes
// ------------------------------------------------------------------------------
for ( nIt = nodeSet->begin(); nIt != nodeSet->end(); nIt++ ) { // loop on nodes of iSide
fIt++;
}
else
- freeFaceList.erase( fIt++ ); // here fIt++ occures before erase
+ freeFaceList.erase( fIt++ ); // here fIt++ occurs before erase
}
if ( freeFaceList.size() > 1 )
{
// else
if ( nbReplaced )
{
- // TODO problem ChangeElementNodes : not the same number of nodes, not the same type
- MESSAGE("ChangeElementNodes");
- aMesh->ChangeElementNodes( e, & nodes[0], nbNodes );
+ SMDSAbs_ElementType etyp = e->GetType();
+ SMDS_MeshElement* newElem = this->AddElement(nodes, etyp, false);
+ if (newElem)
+ {
+ myLastCreatedElems.Append(newElem);
+ AddToSameGroups(newElem, e, aMesh);
+ }
+ aMesh->RemoveElement(e);
}
}
}
SMDS_MeshElement* AddElement(const std::vector<const SMDS_MeshNode*> & nodes,
const SMDSAbs_ElementType type,
const bool isPoly,
- const int ID = 0);
+ const int ID = -1);
/*!
* \brief Add element
*/
SMDS_MeshElement* AddElement(const std::vector<int> & nodeIDs,
const SMDSAbs_ElementType type,
const bool isPoly,
- const int ID = 0);
+ const int ID = -1);
bool Remove (const std::list< int >& theElemIDs, const bool isNodes);
// Remove a node or an element.
myIDElements.swap(newSmdsToVtk);
myVtkIndex.swap(newVtkToSmds);
MESSAGE("myCells.size()=" << myCells.size() << " myIDElements.size()=" << myIDElements.size() << " myVtkIndex.size()=" << myVtkIndex.size() );
+ this->myElementIDFactory->emptyPool(newSmdsId);
// ---TODO: myNodes, myElements in submeshes
//=======================================================================
void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
{
- if ( !IsComplexSubmesh() )
+ if (!IsComplexSubmesh())
{
int idInSubShape = ME->getIdInShape();
- assert(idInSubShape == -1);
- SMDS_MeshElement* elem = (SMDS_MeshElement*)(ME);
+ if (idInSubShape != -1)
+ {
+ MESSAGE("add element in subshape already belonging to a subshape "
+ << ME->GetID() << " " << ME->getIdInShape() << " " << ME->getshapeId());
+ throw SALOME_Exception(LOCALIZED("add element in subshape already belonging to a subshape"));
+ }
+ SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME);
elem->setIdInShape(myElements.size());
myElements.push_back(ME);
}
const TopoDS_Shape& aShape,
FaceQuadStruct* & quad) //throw (SALOME_Exception)
{
- // Algorithme décrit dans "Génération automatique de maillages"
- // P.L. GEORGE, MASSON, § 6.4.1 p. 84-85
- // traitement dans le domaine paramétrique 2d u,v
- // transport - projection sur le carré unité
+ // Algorithme décrit dans "Génération automatique de maillages"
+ // P.L. GEORGE, MASSON, § 6.4.1 p. 84-85
+ // traitement dans le domaine paramétrique 2d u,v
+ // transport - projection sur le carré unité
// MESSAGE("StdMeshers_Quadrangle_2D::SetNormalizedGrid");
// const TopoDS_Face& F = TopoDS::Face(aShape);
