+// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
// SMESH SMDS : implementaion of Salome mesh data structure
//
-// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
-//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
-//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-//
-// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-
#ifdef _MSC_VER
#pragma warning(disable:4786)
#endif
#include <map>
using namespace std;
+#ifndef WIN32
+#include <sys/sysinfo.h>
+#endif
+
+// number of added entitis to check memory after
+#define CHECKMEMORY_INTERVAL 1000
+
+//================================================================================
+/*!
+ * \brief Raise an exception if free memory (ram+swap) too low
+ * \param doNotRaise - if true, suppres exception, just return free memory size
+ * \retval int - amount of available memory in MB or negative number in failure case
+ */
+//================================================================================
+
+int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
+{
+#ifndef WIN32
+ struct sysinfo si;
+ int err = sysinfo( &si );
+ if ( err )
+ return -1;
+
+ static int limit = -1;
+ if ( limit < 0 ) {
+ int status = system("SMDS_MemoryLimit"); // it returns lower limit of free RAM
+ if (status >= 0 ) {
+ limit = WEXITSTATUS(status);
+ }
+ if ( limit < 20 )
+ limit = 20;
+ else
+ limit = int( limit * 1.5 );
+#ifdef _DEBUG_
+ MESSAGE ( "SMDS_Mesh::CheckMemory() memory limit = " << limit << " MB" );
+#endif
+ }
+
+ const unsigned long Mbyte = 1024 * 1024;
+ // compute separately to avoid overflow
+ int freeMb =
+ ( si.freeram * si.mem_unit ) / Mbyte +
+ ( si.freeswap * si.mem_unit ) / Mbyte;
+
+ if ( freeMb > limit )
+ return freeMb - limit;
+
+ if ( doNotRaise )
+ return 0;
+#ifdef _DEBUG_
+ MESSAGE ("SMDS_Mesh::CheckMemory() throws as free memory too low: " << freeMb <<" MB" );
+#endif
+ throw std::bad_alloc();
+#else
+ return -1;
+#endif
+}
+
///////////////////////////////////////////////////////////////////////////////
/// Create a new mesh object
///////////////////////////////////////////////////////////////////////////////
// find the MeshNode corresponding to ID
const SMDS_MeshElement *node = myNodeIDFactory->MeshElement(ID);
if(!node){
+ if ( myNodes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
SMDS_MeshNode * node=new SMDS_MeshNode(x, y, z);
myNodes.Add(node);
myNodeIDFactory->BindID(ID,node);
+ myInfo.myNbNodes++;
return node;
}else
return NULL;
{
if ( !n1 || !n2 ) return 0;
+ if ( myEdges.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
+
SMDS_MeshEdge * edge=new SMDS_MeshEdge(n1,n2);
if(myElementIDFactory->BindID(ID, edge)) {
SMDS_MeshNode *node1,*node2;
node1->AddInverseElement(edge);
node2->AddInverseElement(edge);
myEdges.Add(edge);
+ myInfo.myNbEdges++;
return edge;
}
else {
return NULL;
if ( !e1 || !e2 || !e3 ) return 0;
+ if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
+
SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
myFaces.Add(face);
+ myInfo.myNbTriangles++;
if (!registerElement(ID, face)) {
RemoveElement(face, false);
if (!hasConstructionEdges())
return NULL;
if ( !e1 || !e2 || !e3 || !e4 ) return 0;
+ if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);
myFaces.Add(face);
+ myInfo.myNbQuadrangles++;
if (!registerElement(ID, face))
{
{
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4) return volume;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if(hasConstructionFaces()) {
SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3);
SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n4);
SMDS_MeshFace * f4=FindFaceOrCreate(n2,n3,n4);
volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
myVolumes.Add(volume);
+ myInfo.myNbTetras++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
else {
volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4);
myVolumes.Add(volume);
+ myInfo.myNbTetras++;
}
if (!registerElement(ID, volume)) {
{
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if(hasConstructionFaces()) {
SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4);
SMDS_MeshFace * f2=FindFaceOrCreate(n1,n2,n5);
SMDS_MeshFace * f4=FindFaceOrCreate(n3,n4,n5);
volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4);
myVolumes.Add(volume);
+ myInfo.myNbPyramids++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
else {
volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4,n5);
myVolumes.Add(volume);
+ myInfo.myNbPyramids++;
}
if (!registerElement(ID, volume)) {
{
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if(hasConstructionFaces()) {
SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3);
SMDS_MeshFace * f2=FindFaceOrCreate(n4,n5,n6);
SMDS_MeshFace * f5=FindFaceOrCreate(n3,n6,n4,n1);
volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
myVolumes.Add(volume);
+ myInfo.myNbPrisms++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
else {
volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4,n5,n6);
myVolumes.Add(volume);
+ myInfo.myNbPrisms++;
}
if (!registerElement(ID, volume)) {
{
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if(hasConstructionFaces()) {
SMDS_MeshFace * f1=FindFaceOrCreate(n1,n2,n3,n4);
SMDS_MeshFace * f2=FindFaceOrCreate(n5,n6,n7,n8);
SMDS_MeshFace * f6=FindFaceOrCreate(n3,n4,n8,n7);
volume=new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
myVolumes.Add(volume);
+ myInfo.myNbHexas++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
// volume=new SMDS_HexahedronOfNodes(n1,n2,n3,n4,n5,n6,n7,n8);
volume=new SMDS_VolumeOfNodes(n1,n2,n3,n4,n5,n6,n7,n8);
myVolumes.Add(volume);
+ myInfo.myNbHexas++;
}
if (!registerElement(ID, volume)) {
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4) return 0;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4);
myVolumes.Add(volume);
+ myInfo.myNbTetras++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5);
myVolumes.Add(volume);
+ myInfo.myNbPyramids++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
SMDS_MeshVolume * volume = new SMDS_VolumeOfFaces(f1,f2,f3,f4,f5,f6);
myVolumes.Add(volume);
+ myInfo.myNbPrisms++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
{
SMDS_MeshFace * face;
+ if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionEdges())
{
MESSAGE("Error : Not implemented");
if ( !nodes[ i ] ) return 0;
face = new SMDS_PolygonalFaceOfNodes(nodes);
myFaces.Add(face);
+ myInfo.myNbPolygons++;
}
if (!registerElement(ID, face)) {
const int ID)
{
SMDS_MeshVolume* volume;
+ if ( myVolumes.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionFaces()) {
MESSAGE("Error : Not implemented");
return NULL;
if ( !nodes[ i ] ) return 0;
volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
myVolumes.Add(volume);
+ myInfo.myNbPolyhedrons++;
}
if (!registerElement(ID, volume)) {
const SMDS_MeshNode * node3)
{
if ( !node1 || !node2 || !node3) return 0;
- if(hasConstructionEdges())
- {
- SMDS_MeshEdge *edge1, *edge2, *edge3;
- edge1=FindEdgeOrCreate(node1,node2);
- edge2=FindEdgeOrCreate(node2,node3);
- edge3=FindEdgeOrCreate(node3,node1);
-
- SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
- myFaces.Add(face);
- return face;
- }
- else
- {
- SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3);
- myFaces.Add(face);
- return face;
- }
+ if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
+ if(hasConstructionEdges())
+ {
+ SMDS_MeshEdge *edge1, *edge2, *edge3;
+ edge1=FindEdgeOrCreate(node1,node2);
+ edge2=FindEdgeOrCreate(node2,node3);
+ edge3=FindEdgeOrCreate(node3,node1);
+
+ SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3);
+ myFaces.Add(face);
+ myInfo.myNbTriangles++;
+ return face;
+ }
+ else
+ {
+ SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3);
+ myFaces.Add(face);
+ myInfo.myNbTriangles++;
+ return face;
+ }
}
///////////////////////////////////////////////////////////////////////////////
const SMDS_MeshNode * node4)
{
if ( !node1 || !node2 || !node3 || !node4 ) return 0;
- if(hasConstructionEdges())
- {
- SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
- edge1=FindEdgeOrCreate(node1,node2);
- edge2=FindEdgeOrCreate(node2,node3);
- edge3=FindEdgeOrCreate(node3,node4);
- edge4=FindEdgeOrCreate(node4,node1);
-
- SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
- myFaces.Add(face);
- return face;
- }
- else
- {
- SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4);
- myFaces.Add(face);
- return face;
- }
+ if ( myFaces.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
+ if(hasConstructionEdges())
+ {
+ SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
+ edge1=FindEdgeOrCreate(node1,node2);
+ edge2=FindEdgeOrCreate(node2,node3);
+ edge3=FindEdgeOrCreate(node3,node4);
+ edge4=FindEdgeOrCreate(node4,node1);
+
+ SMDS_MeshFace * face = new SMDS_FaceOfEdges(edge1,edge2,edge3,edge4);
+ myFaces.Add(face);
+ myInfo.myNbQuadrangles++;
+ return face;
+ }
+ else
+ {
+ SMDS_MeshFace * face = new SMDS_FaceOfNodes(node1,node2,node3,node4);
+ myFaces.Add(face);
+ myInfo.myNbQuadrangles++;
+ return face;
+ }
}
///////////////////////////////////////////////////////////////////////////////
//purpose :
//=======================================================================
-bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
+bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element,
const SMDS_MeshNode * nodes[],
const int nbnodes)
{
// keep current nodes of elem
set<const SMDS_MeshElement*> oldNodes;
- SMDS_ElemIteratorPtr itn = elem->nodesIterator();
+ SMDS_ElemIteratorPtr itn = element->nodesIterator();
while(itn->more())
oldNodes.insert( itn->next() );
+ if ( !element->IsPoly() )
+ myInfo.remove( element ); // element may change type
+
// change nodes
bool Ok = false;
+ SMDS_MeshElement* elem = const_cast<SMDS_MeshElement*>(element);
switch ( elem->GetType() )
{
case SMDSAbs_Edge: {
if ( nbnodes == 2 ) {
- const SMDS_MeshEdge* edge = dynamic_cast<const SMDS_MeshEdge*>( elem );
- if ( edge )
- Ok = const_cast<SMDS_MeshEdge*>( edge )->ChangeNodes( nodes[0], nodes[1] );
+ if ( SMDS_MeshEdge* edge = dynamic_cast<SMDS_MeshEdge*>( elem ))
+ Ok = edge->ChangeNodes( nodes[0], nodes[1] );
}
else if ( nbnodes == 3 ) {
- const SMDS_QuadraticEdge* edge = dynamic_cast<const SMDS_QuadraticEdge*>( elem );
- if ( edge )
- Ok = const_cast<SMDS_QuadraticEdge*>( edge )->ChangeNodes( nodes[0], nodes[1], nodes[2] );
+ if ( SMDS_QuadraticEdge* edge = dynamic_cast<SMDS_QuadraticEdge*>( elem ))
+ Ok = edge->ChangeNodes( nodes[0], nodes[1], nodes[2] );
}
break;
}
case SMDSAbs_Face: {
- const SMDS_FaceOfNodes* face = dynamic_cast<const SMDS_FaceOfNodes*>( elem );
- if ( face ) {
- Ok = const_cast<SMDS_FaceOfNodes*>( face )->ChangeNodes( nodes, nbnodes );
- }
- else {
- const SMDS_QuadraticFaceOfNodes* QF =
- dynamic_cast<const SMDS_QuadraticFaceOfNodes*>( elem );
- if ( QF ) {
- Ok = const_cast<SMDS_QuadraticFaceOfNodes*>( QF )->ChangeNodes( nodes, nbnodes );
- }
- else {
- /// ??? begin
- const SMDS_PolygonalFaceOfNodes* face = dynamic_cast<const SMDS_PolygonalFaceOfNodes*>(elem);
- if (face) {
- Ok = const_cast<SMDS_PolygonalFaceOfNodes*>(face)->ChangeNodes(nodes, nbnodes);
- }
- /// ??? end
- }
- }
+ if ( SMDS_FaceOfNodes* face = dynamic_cast<SMDS_FaceOfNodes*>( elem ))
+ Ok = face->ChangeNodes( nodes, nbnodes );
+ else
+ if ( SMDS_QuadraticFaceOfNodes* QF = dynamic_cast<SMDS_QuadraticFaceOfNodes*>( elem ))
+ Ok = QF->ChangeNodes( nodes, nbnodes );
+ else
+ if (SMDS_PolygonalFaceOfNodes* face = dynamic_cast<SMDS_PolygonalFaceOfNodes*>(elem))
+ Ok = face->ChangeNodes(nodes, nbnodes);
break;
}
- //case SMDSAbs_PolygonalFace: {
- // const SMDS_PolygonalFaceOfNodes* face = dynamic_cast<const SMDS_PolygonalFaceOfNodes*>(elem);
- // if (face) {
- // Ok = const_cast<SMDS_PolygonalFaceOfNodes*>(face)->ChangeNodes(nodes, nbnodes);
- // }
- // break;
- //}
case SMDSAbs_Volume: {
- const SMDS_VolumeOfNodes* vol = dynamic_cast<const SMDS_VolumeOfNodes*>( elem );
- if ( vol ) {
- Ok = const_cast<SMDS_VolumeOfNodes*>( vol )->ChangeNodes( nodes, nbnodes );
- }
- else {
- const SMDS_QuadraticVolumeOfNodes* QV = dynamic_cast<const SMDS_QuadraticVolumeOfNodes*>( elem );
- if ( QV ) {
- Ok = const_cast<SMDS_QuadraticVolumeOfNodes*>( QV )->ChangeNodes( nodes, nbnodes );
- }
- }
+ if ( SMDS_VolumeOfNodes* vol = dynamic_cast<SMDS_VolumeOfNodes*>( elem ))
+ Ok = vol->ChangeNodes( nodes, nbnodes );
+ else
+ if ( SMDS_QuadraticVolumeOfNodes* QV = dynamic_cast<SMDS_QuadraticVolumeOfNodes*>( elem ))
+ Ok = QV->ChangeNodes( nodes, nbnodes );
break;
}
default:
if ( Ok ) { // update InverseElements
+ set<const SMDS_MeshElement*>::iterator it;
+
// AddInverseElement to new nodes
- for ( int i = 0; i < nbnodes; i++ )
- if ( oldNodes.find( nodes[i] ) == oldNodes.end() )
+ for ( int i = 0; i < nbnodes; i++ ) {
+ it = oldNodes.find( nodes[i] );
+ if ( it == oldNodes.end() )
// new node
const_cast<SMDS_MeshNode*>( nodes[i] )->AddInverseElement( elem );
else
// remove from oldNodes a node that remains in elem
- oldNodes.erase( nodes[i] );
-
-
+ oldNodes.erase( it );
+ }
// RemoveInverseElement from the nodes removed from elem
- set<const SMDS_MeshElement*>::iterator it;
for ( it = oldNodes.begin(); it != oldNodes.end(); it++ )
{
SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
}
}
- //MESSAGE ( "::ChangeNodes() Ok = " << Ok);
+ if ( !element->IsPoly() )
+ myInfo.add( element ); // element may change type
return Ok;
}
//function : ChangePolyhedronNodes
//purpose : to change nodes of polyhedral volume
//=======================================================================
-bool SMDS_Mesh::ChangePolyhedronNodes (const SMDS_MeshElement * elem,
- std::vector<const SMDS_MeshNode*> nodes,
- std::vector<int> quantities)
+bool SMDS_Mesh::ChangePolyhedronNodes (const SMDS_MeshElement * elem,
+ const vector<const SMDS_MeshNode*>& nodes,
+ const vector<int> & quantities)
{
if (elem->GetType() != SMDSAbs_Volume) {
MESSAGE("WRONG ELEM TYPE");
// AddInverseElement to new nodes
int nbnodes = nodes.size();
+ set<const SMDS_MeshElement*>::iterator it;
for (int i = 0; i < nbnodes; i++) {
- if (oldNodes.find(nodes[i]) == oldNodes.end()) {
+ it = oldNodes.find(nodes[i]);
+ if (it == oldNodes.end()) {
// new node
const_cast<SMDS_MeshNode*>(nodes[i])->AddInverseElement(elem);
} else {
// remove from oldNodes a node that remains in elem
- oldNodes.erase(nodes[i]);
+ oldNodes.erase(it);
}
}
// RemoveInverseElement from the nodes removed from elem
- set<const SMDS_MeshElement*>::iterator it;
for (it = oldNodes.begin(); it != oldNodes.end(); it++) {
SMDS_MeshNode * n = static_cast<SMDS_MeshNode *>
(const_cast<SMDS_MeshElement *>( *it ));
const SMDS_MeshEdge* SMDS_Mesh::FindEdge(const SMDS_MeshNode * node1,
const SMDS_MeshNode * node2)
{
+ if ( !node1 ) return 0;
const SMDS_MeshEdge * toReturn=NULL;
//PROFILER_Init();
//PROFILER_Set();
- SMDS_ElemIteratorPtr it1=node1->edgesIterator();
+ SMDS_ElemIteratorPtr it1=node1->GetInverseElementIterator(SMDSAbs_Edge);
//PROFILER_Get(0);
//PROFILER_Set();
while(it1->more()) {
- const SMDS_MeshEdge * e=static_cast<const SMDS_MeshEdge *> (it1->next());
- SMDS_ElemIteratorPtr it2=e->nodesIterator();
- while(it2->more()) {
- if(it2->next()->GetID()==node2->GetID()) {
- toReturn = e;
- break;
- }
+ const SMDS_MeshElement * e = it1->next();
+ if ( e->NbNodes() == 2 && e->GetNodeIndex( node2 ) >= 0 ) {
+ toReturn = static_cast<const SMDS_MeshEdge*>( e );
+ break;
}
}
//PROFILER_Get(1);
SMDS_MeshEdge * toReturn=NULL;
toReturn=const_cast<SMDS_MeshEdge*>(FindEdge(node1,node2));
if(toReturn==NULL) {
+ if ( myEdges.Extent() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
toReturn=new SMDS_MeshEdge(node1,node2);
myEdges.Add(toReturn);
- }
+ myInfo.myNbEdges++;
+ }
return toReturn;
}
const SMDS_MeshNode * node2,
const SMDS_MeshNode * node3)
{
- if ( !node1 || !node2 || !node3 ) return 0;
- const SMDS_MeshEdge * toReturn = NULL;
- SMDS_ElemIteratorPtr it1 = node1->edgesIterator();
+ if ( !node1 ) return 0;
+ SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Edge);
while(it1->more()) {
- const SMDS_MeshEdge * e = static_cast<const SMDS_MeshEdge *> (it1->next());
- SMDS_ElemIteratorPtr it2 = e->nodesIterator();
- int tmp = 0;
- while(it2->more()) {
- int nID = it2->next()->GetID();
- if( nID==node2->GetID() || nID==node3->GetID() ) {
- tmp++;
- if(tmp==2) {
- toReturn = e;
+ const SMDS_MeshElement * e = it1->next();
+ if ( e->NbNodes() == 3 ) {
+ SMDS_ElemIteratorPtr it2 = e->nodesIterator();
+ while(it2->more()) {
+ const SMDS_MeshElement* n = it2->next();
+ if( n!=node1 &&
+ n!=node2 &&
+ n!=node3 )
+ {
+ e = 0;
break;
}
}
+ if ( e )
+ return static_cast<const SMDS_MeshEdge *> (e);
}
}
- return toReturn;
+ return 0;
}
const SMDS_MeshNode *node2,
const SMDS_MeshNode *node3)
{
- if ( !node1 || !node2 || !node3 ) return 0;
- const SMDS_MeshFace * face;
- const SMDS_MeshElement * node;
- bool node2found, node3found;
-
- SMDS_ElemIteratorPtr it1 = node1->facesIterator();
+ if ( !node1 ) return 0;
+ SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
while(it1->more()) {
- face = static_cast<const SMDS_MeshFace*>(it1->next());
- if(face->NbNodes()!=3) continue;
- SMDS_ElemIteratorPtr it2 = face->nodesIterator();
- node2found = false;
- node3found = false;
- while(it2->more()) {
- node = it2->next();
- if(node->GetID()==node2->GetID()) node2found = true;
- if(node->GetID()==node3->GetID()) node3found = true;
+ const SMDS_MeshElement * e = it1->next();
+ if ( e->NbNodes() == 3 ) {
+ SMDS_ElemIteratorPtr it2 = e->nodesIterator();
+ while(it2->more()) {
+ const SMDS_MeshElement* n = it2->next();
+ if( n!=node1 &&
+ n!=node2 &&
+ n!=node3 )
+ {
+ e = 0;
+ break;
+ }
+ }
+ if ( e )
+ return static_cast<const SMDS_MeshFace *> (e);
}
- if( node2found && node3found )
- return face;
}
- return NULL;
+ return 0;
}
SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1,
const SMDS_MeshNode *node3,
const SMDS_MeshNode *node4)
{
- if( (node1==NULL) || (node2==NULL) || (node3==NULL) || (node4==NULL) )
- return NULL;
- const SMDS_MeshFace * face;
- const SMDS_MeshElement * node;
- bool node2found, node3found, node4found;
- SMDS_ElemIteratorPtr it1 = node1->facesIterator();
+ if ( !node1 ) return 0;
+ SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
while(it1->more()) {
- face = static_cast<const SMDS_MeshFace *>(it1->next());
- if(face->NbNodes()!=4) continue;
- SMDS_ElemIteratorPtr it2 = face->nodesIterator();
- node2found = false;
- node3found = false;
- node4found = false;
- while(it2->more()) {
- node=it2->next();
- if(node->GetID()==node2->GetID()) node2found = true;
- if(node->GetID()==node3->GetID()) node3found = true;
- if(node->GetID()==node4->GetID()) node4found = true;
+ const SMDS_MeshElement * e = it1->next();
+ if ( e->NbNodes() == 4 ) {
+ SMDS_ElemIteratorPtr it2 = e->nodesIterator();
+ while(it2->more()) {
+ const SMDS_MeshElement* n = it2->next();
+ if( n!=node1 &&
+ n!=node2 &&
+ n!=node3 &&
+ n!=node4 )
+ {
+ e = 0;
+ break;
+ }
+ }
+ if ( e )
+ return static_cast<const SMDS_MeshFace *> (e);
}
- if( node2found && node3found && node4found )
- return face;
}
- return NULL;
+ return 0;
}
SMDS_MeshFace* SMDS_Mesh::FindFaceOrCreate(const SMDS_MeshNode *node1,
const SMDS_MeshNode *node5,
const SMDS_MeshNode *node6)
{
- if( (node1==NULL) || (node2==NULL) || (node3==NULL) ||
- (node4==NULL) || (node5==NULL) || (node6==NULL) ) return NULL;
- const SMDS_MeshFace * face;
- const SMDS_MeshElement * node;
- SMDS_ElemIteratorPtr it1 = node1->facesIterator();
+ if ( !node1 ) return 0;
+ SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
while(it1->more()) {
- face = static_cast<const SMDS_MeshFace*>(it1->next());
- if(face->NbNodes()!=6) continue;
- SMDS_ElemIteratorPtr it2 = face->nodesIterator();
- int tmp = 0;
- while(it2->more()) {
- node = it2->next();
- if(node->GetID()==node2->GetID()) tmp++;
- if(node->GetID()==node3->GetID()) tmp++;
- if(node->GetID()==node4->GetID()) tmp++;
- if(node->GetID()==node5->GetID()) tmp++;
- if(node->GetID()==node6->GetID()) tmp++;
+ const SMDS_MeshElement * e = it1->next();
+ if ( e->NbNodes() == 6 ) {
+ SMDS_ElemIteratorPtr it2 = e->nodesIterator();
+ while(it2->more()) {
+ const SMDS_MeshElement* n = it2->next();
+ if( n!=node1 &&
+ n!=node2 &&
+ n!=node3 &&
+ n!=node4 &&
+ n!=node5 &&
+ n!=node6 )
+ {
+ e = 0;
+ break;
+ }
+ }
+ if ( e )
+ return static_cast<const SMDS_MeshFace *> (e);
}
- if( tmp==5 )
- return static_cast<const SMDS_MeshFace*>(face);
}
- return NULL;
+ return 0;
}
const SMDS_MeshNode *node7,
const SMDS_MeshNode *node8)
{
- if( (node1==NULL) || (node2==NULL) || (node3==NULL) || (node4==NULL) ||
- (node5==NULL) || (node6==NULL) || (node7==NULL) || (node8==NULL) )
- return NULL;
- const SMDS_MeshFace * face;
- const SMDS_MeshElement * node;
- SMDS_ElemIteratorPtr it1 = node1->facesIterator();
+ if ( !node1 ) return 0;
+ SMDS_ElemIteratorPtr it1 = node1->GetInverseElementIterator(SMDSAbs_Face);
while(it1->more()) {
- face = static_cast<const SMDS_MeshFace *>(it1->next());
- if(face->NbNodes()!=8) continue;
- SMDS_ElemIteratorPtr it2 = face->nodesIterator();
- int tmp = 0;
- while(it2->more()) {
- node = it2->next();
- if(node->GetID()==node2->GetID()) tmp++;
- if(node->GetID()==node3->GetID()) tmp++;
- if(node->GetID()==node4->GetID()) tmp++;
- if(node->GetID()==node5->GetID()) tmp++;
- if(node->GetID()==node6->GetID()) tmp++;
- if(node->GetID()==node7->GetID()) tmp++;
- if(node->GetID()==node8->GetID()) tmp++;
+ const SMDS_MeshElement * e = it1->next();
+ if ( e->NbNodes() == 8 ) {
+ SMDS_ElemIteratorPtr it2 = e->nodesIterator();
+ while(it2->more()) {
+ const SMDS_MeshElement* n = it2->next();
+ if( n!=node1 &&
+ n!=node2 &&
+ n!=node3 &&
+ n!=node4 &&
+ n!=node5 &&
+ n!=node6 &&
+ n!=node7 &&
+ n!=node8 )
+ {
+ e = 0;
+ break;
+ }
+ }
+ if ( e )
+ return static_cast<const SMDS_MeshFace *> (e);
}
- if( tmp==7 )
- return face;
}
- return NULL;
+ return 0;
}
const SMDS_MeshFace* SMDS_Mesh::FindFace (std::vector<const SMDS_MeshNode *> nodes)
{
- int nbNodes = nodes.size();
- if (nbNodes < 1) return NULL;
-
- bool isFound = true;
- const SMDS_MeshFace * face;
- set<const SMDS_MeshFace *> faces;
-
- for (int inode = 0; inode < nbNodes && isFound; inode++) {
- if ( !nodes[ inode ]) return 0;
-
- set<const SMDS_MeshFace *> new_faces;
-
- SMDS_ElemIteratorPtr itF = nodes[inode]->facesIterator();
+ if ( nodes.size() > 2 && nodes[0] ) {
+ SMDS_ElemIteratorPtr itF = nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
while (itF->more()) {
- face = static_cast<const SMDS_MeshFace *>(itF->next());
- if (face->NbNodes() == nbNodes) {
- if (inode == 0 || faces.find(face) != faces.end()) {
- new_faces.insert(face);
+ const SMDS_MeshElement* f = itF->next();
+ if ( f->NbNodes() == nodes.size() ) {
+ SMDS_ElemIteratorPtr it2 = f->nodesIterator();
+ while(it2->more()) {
+ if ( find( nodes.begin(), nodes.end(), it2->next() ) == nodes.end() ) {
+ f = 0;
+ break;
+ }
}
+ if ( f )
+ return static_cast<const SMDS_MeshFace *> (f);
}
}
- faces = new_faces;
- if (new_faces.size() == 0) {
- isFound = false;
- }
}
-
- if (isFound)
- return face;
-
return NULL;
}
itc++;
}
+ if(myParent==NULL)
+ {
+ delete myNodeIDFactory;
+ delete myElementIDFactory;
+ }
+ else
+ {
+ SMDS_ElemIteratorPtr eIt = elementsIterator();
+ while ( eIt->more() )
+ myElementIDFactory->ReleaseID(eIt->next()->GetID());
+ SMDS_NodeIteratorPtr itn = nodesIterator();
+ while (itn->more())
+ myNodeIDFactory->ReleaseID(itn->next()->GetID());
+ }
SetOfNodes::Iterator itn(myNodes);
for (; itn.More(); itn.Next())
delete itn.Value();
for (; ite.More(); ite.Next())
{
SMDS_MeshElement* elem = ite.Value();
- if(myParent!=NULL)
- myElementIDFactory->ReleaseID(elem->GetID());
delete elem;
}
for (; itf.More(); itf.Next())
{
SMDS_MeshElement* elem = itf.Value();
- if(myParent!=NULL)
- myElementIDFactory->ReleaseID(elem->GetID());
delete elem;
}
for (; itv.More(); itv.Next())
{
SMDS_MeshElement* elem = itv.Value();
- if(myParent!=NULL)
- myElementIDFactory->ReleaseID(elem->GetID());
delete elem;
}
- if(myParent==NULL)
- {
- delete myNodeIDFactory;
- delete myElementIDFactory;
+}
+
+//================================================================================
+/*!
+ * \brief Clear all data
+ */
+//================================================================================
+
+void SMDS_Mesh::Clear()
+{
+ if (myParent!=NULL) {
+ SMDS_ElemIteratorPtr eIt = elementsIterator();
+ while ( eIt->more() )
+ myElementIDFactory->ReleaseID(eIt->next()->GetID());
+ SMDS_NodeIteratorPtr itn = nodesIterator();
+ while (itn->more())
+ myNodeIDFactory->ReleaseID(itn->next()->GetID());
+ }
+ else {
+ myNodeIDFactory->Clear();
+ myElementIDFactory->Clear();
}
+ SMDS_VolumeIteratorPtr itv = volumesIterator();
+ while (itv->more())
+ delete itv->next();
+ myVolumes.Clear();
+
+ SMDS_FaceIteratorPtr itf = facesIterator();
+ while (itf->more())
+ delete itf->next();
+ myFaces.Clear();
+
+ SMDS_EdgeIteratorPtr ite = edgesIterator();
+ while (ite->more())
+ delete ite->next();
+ myEdges.Clear();
+
+ SMDS_NodeIteratorPtr itn = nodesIterator();
+ while (itn->more())
+ delete itn->next();
+ myNodes.Clear();
+
+ list<SMDS_Mesh*>::iterator itc=myChildren.begin();
+ while(itc!=myChildren.end())
+ (*itc)->Clear();
+
+ myInfo.Clear();
}
///////////////////////////////////////////////////////////////////////////////
}
///////////////////////////////////////////////////////////////////////////////
-/// Return an iterator on elements of the current mesh factory
+///Iterator on NCollection_Map
///////////////////////////////////////////////////////////////////////////////
-SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator() const
+template <class MAP, typename ELEM=const SMDS_MeshElement*, class FATHER=SMDS_ElemIterator>
+struct MYNCollection_Map_Iterator: public FATHER
{
- return myElementIDFactory->elementsIterator();
-}
+ typename MAP::Iterator myIterator;
-///////////////////////////////////////////////////////////////////////////////
-///Return an iterator on edges of the current mesh.
-///////////////////////////////////////////////////////////////////////////////
-class SMDS_Mesh_MyEdgeIterator:public SMDS_EdgeIterator
-{
- typedef SMDS_Mesh::SetOfEdges SetOfEdges;
- SetOfEdges::Iterator myIterator;
- public:
- SMDS_Mesh_MyEdgeIterator(const SetOfEdges& s):myIterator(s)
- {}
+ MYNCollection_Map_Iterator(const MAP& map):myIterator(map){}
bool more()
{
return false;
}
- const SMDS_MeshEdge* next()
+ ELEM next()
{
- const SMDS_MeshEdge* current = myIterator.Value();
+ ELEM current = (ELEM) myIterator.Value();
myIterator.Next();
return current;
}
};
+///////////////////////////////////////////////////////////////////////////////
+///Return an iterator on edges of the current mesh.
+///////////////////////////////////////////////////////////////////////////////
+
SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator() const
{
- return SMDS_EdgeIteratorPtr(new SMDS_Mesh_MyEdgeIterator(myEdges));
+ typedef MYNCollection_Map_Iterator
+ < SetOfEdges, const SMDS_MeshEdge*, SMDS_EdgeIterator > TIterator;
+ return SMDS_EdgeIteratorPtr(new TIterator(myEdges));
}
///////////////////////////////////////////////////////////////////////////////
///Return an iterator on faces of the current mesh.
///////////////////////////////////////////////////////////////////////////////
-class SMDS_Mesh_MyFaceIterator:public SMDS_FaceIterator
-{
- typedef SMDS_Mesh::SetOfFaces SetOfFaces;
- SetOfFaces::Iterator myIterator;
- public:
- SMDS_Mesh_MyFaceIterator(const SetOfFaces& s):myIterator(s)
- {}
-
- bool more()
- {
- while(myIterator.More())
- {
- if(myIterator.Value()->GetID()!=-1)
- return true;
- myIterator.Next();
- }
- return false;
- }
-
- const SMDS_MeshFace* next()
- {
- const SMDS_MeshFace* current = myIterator.Value();
- myIterator.Next();
- return current;
- }
-};
SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator() const
{
- return SMDS_FaceIteratorPtr(new SMDS_Mesh_MyFaceIterator(myFaces));
+ typedef MYNCollection_Map_Iterator
+ < SetOfFaces, const SMDS_MeshFace*, SMDS_FaceIterator > TIterator;
+ return SMDS_FaceIteratorPtr(new TIterator(myFaces));
}
///////////////////////////////////////////////////////////////////////////////
///Return an iterator on volumes of the current mesh.
///////////////////////////////////////////////////////////////////////////////
-class SMDS_Mesh_MyVolumeIterator:public SMDS_VolumeIterator
-{
- typedef SMDS_Mesh::SetOfVolumes SetOfVolumes;
- SetOfVolumes::Iterator myIterator;
- public:
- SMDS_Mesh_MyVolumeIterator(const SetOfVolumes& s):myIterator(s)
- {}
-
- bool more()
- {
- return myIterator.More() != Standard_False;
- }
-
- const SMDS_MeshVolume* next()
- {
- const SMDS_MeshVolume* current = myIterator.Value();
- myIterator.Next();
- return current;
- }
-};
SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator() const
{
- return SMDS_VolumeIteratorPtr(new SMDS_Mesh_MyVolumeIterator(myVolumes));
+ typedef MYNCollection_Map_Iterator
+ < SetOfVolumes, const SMDS_MeshVolume*, SMDS_VolumeIterator > TIterator;
+ return SMDS_VolumeIteratorPtr(new TIterator(myVolumes));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Return an iterator on elements of the current mesh factory
+///////////////////////////////////////////////////////////////////////////////
+SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
+{
+ switch (type) {
+ case SMDSAbs_All:
+ break;
+ case SMDSAbs_Volume:
+ return SMDS_ElemIteratorPtr (new MYNCollection_Map_Iterator< SetOfVolumes >(myVolumes));
+ case SMDSAbs_Face:
+ return SMDS_ElemIteratorPtr (new MYNCollection_Map_Iterator< SetOfFaces >(myFaces));
+ case SMDSAbs_Edge:
+ return SMDS_ElemIteratorPtr (new MYNCollection_Map_Iterator< SetOfEdges >(myEdges));
+ case SMDSAbs_Node:
+ return myNodeIDFactory->elementsIterator();
+ default:;
+ }
+ return myElementIDFactory->elementsIterator();
}
///////////////////////////////////////////////////////////////////////////////
case SMDSAbs_Edge:
myEdges.Remove(static_cast<SMDS_MeshEdge*>
(const_cast<SMDS_MeshElement*>(*it)));
+ myInfo.RemoveEdge(*it);
break;
case SMDSAbs_Face:
myFaces.Remove(static_cast<SMDS_MeshFace*>
(const_cast<SMDS_MeshElement*>(*it)));
+ myInfo.RemoveFace(*it);
break;
case SMDSAbs_Volume:
myVolumes.Remove(static_cast<SMDS_MeshVolume*>
(const_cast<SMDS_MeshElement*>(*it)));
+ myInfo.RemoveVolume(*it);
break;
}
//MESSAGE( "SMDS: RM elem " << (*it)->GetID() );
//MESSAGE( "SMDS: RM node " << (*it)->GetID() );
myNodes.Remove(static_cast<SMDS_MeshNode*>
(const_cast<SMDS_MeshElement*>(*it)));
+ myInfo.myNbNodes--;
myNodeIDFactory->ReleaseID((*it)->GetID());
removedNodes.push_back( (*it) );
delete *it;
SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
if (!itFe->more()) { // free node
myNodes.Remove(const_cast<SMDS_MeshNode*>(n));
+ myInfo.myNbNodes--;
myNodeIDFactory->ReleaseID(elem->GetID());
delete elem;
}
case SMDSAbs_Edge:
myEdges.Remove(static_cast<SMDS_MeshEdge*>
(const_cast<SMDS_MeshElement*>(elem)));
+ myInfo.RemoveEdge(elem);
break;
case SMDSAbs_Face:
myFaces.Remove(static_cast<SMDS_MeshFace*>
(const_cast<SMDS_MeshElement*>(elem)));
+ myInfo.RemoveFace(elem);
break;
case SMDSAbs_Volume:
myVolumes.Remove(static_cast<SMDS_MeshVolume*>
(const_cast<SMDS_MeshElement*>(elem)));
+ myInfo.RemoveVolume(elem);
break;
default:
break;
}
// release their ids
map<int,SMDS_MeshElement*>::iterator elemIt = elemMap.begin();
- for ( ; elemIt != elemMap.end(); elemIt++ )
- {
- int id = (*elemIt).first;
- idFactory->ReleaseID( id );
- }
+ idFactory->Clear();
+// for ( ; elemIt != elemMap.end(); elemIt++ )
+// {
+// int id = (*elemIt).first;
+// idFactory->ReleaseID( id );
+// }
// set new IDs
int ID = startID;
elemIt = elemMap.begin();
node2->AddInverseElement(edge);
node12->AddInverseElement(edge);
myEdges.Add(edge);
+ myInfo.myNbQuadEdges++;
return edge;
}
else {
SMDS_QuadraticFaceOfNodes* face =
new SMDS_QuadraticFaceOfNodes(n1,n2,n3,n12,n23,n31);
myFaces.Add(face);
+ myInfo.myNbQuadTriangles++;
if (!registerElement(ID, face)) {
RemoveElement(face, false);
SMDS_QuadraticFaceOfNodes* face =
new SMDS_QuadraticFaceOfNodes(n1,n2,n3,n4,n12,n23,n34,n41);
myFaces.Add(face);
+ myInfo.myNbQuadQuadrangles++;
if (!registerElement(ID, face)) {
RemoveElement(face, false);
SMDS_QuadraticVolumeOfNodes * volume =
new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
myVolumes.Add(volume);
+ myInfo.myNbQuadTetras++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n5,n12,n23,
n34,n41,n15,n25,n35,n45);
myVolumes.Add(volume);
+ myInfo.myNbQuadPyramids++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n5,n6,n12,n23,n31,
n45,n56,n64,n14,n25,n36);
myVolumes.Add(volume);
+ myInfo.myNbQuadPrisms++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
new SMDS_QuadraticVolumeOfNodes(n1,n2,n3,n4,n5,n6,n7,n8,n12,n23,n34,n41,
n56,n67,n78,n85,n15,n26,n37,n48);
myVolumes.Add(volume);
+ myInfo.myNbQuadHexas++;
if (!registerElement(ID, volume)) {
RemoveElement(volume, false);
}
return volume;
}
-
