#include <iterator>
using namespace std;
-#ifndef WIN32
+#if !defined WIN32 && !defined __APPLE__
#include <sys/sysinfo.h>
#endif
int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
{
-#ifndef WIN32
+#if !defined WIN32 && !defined __APPLE__
struct sysinfo si;
int err = sysinfo( &si );
if ( err )
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)
points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/);
myGrid->SetPoints( points );
points->Delete();
- myGrid->BuildLinks();
+ //myGrid->BuildLinks();
this->Modified();
+
+ // initialize static maps in SMDS_MeshCell, to be thread-safe
+ if ( myMeshId == 0 )
+ {
+ SMDS_MeshCell::toVtkType( SMDSEntity_Node );
+ SMDS_MeshCell::toVtkOrder( SMDSEntity_Node );
+ SMDS_MeshCell::reverseSmdsOrder( SMDSEntity_Node );
+ SMDS_MeshCell::interlacedSmdsOrder( SMDSEntity_Node );
+ SMDS_MeshCell::toSmdsType( VTK_VERTEX );
+ SMDS_MeshCell::fromVtkOrder( SMDSEntity_Node );
+ }
}
///////////////////////////////////////////////////////////////////////////////
return myInfo.NbNodes();
}
+///////////////////////////////////////////////////////////////////////////////
+/// Return the number of elements
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_Mesh::NbElements() const
+{
+ return myInfo.NbElements();
+}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of 0D elements
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::Clear()
{
if (myParent!=NULL)
- {
+ {
SMDS_ElemIteratorPtr eIt = elementsIterator();
while ( eIt->more() )
- {
- const SMDS_MeshElement *elem = eIt->next();
- myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
- }
+ {
+ const SMDS_MeshElement *elem = eIt->next();
+ myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
+ }
SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more())
- {
- const SMDS_MeshNode *node = itn->next();
- myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
- }
+ {
+ const SMDS_MeshNode *node = itn->next();
+ myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
}
+ }
else
- {
+ {
myNodeIDFactory->Clear();
myElementIDFactory->Clear();
- }
+ }
- // SMDS_ElemIteratorPtr itv = elementsIterator();
- // while (itv->more())
- // {
- // SMDS_MeshElement* elem = (SMDS_MeshElement*)(itv->next());
- // SMDSAbs_ElementType aType = elem->GetType();
- // switch (aType)
- // {
- // case SMDSAbs_0DElement:
- // delete elem;
- // break;
- // case SMDSAbs_Edge:
- // myEdgePool->destroy(static_cast<SMDS_VtkEdge*>(elem));
- // break;
- // case SMDSAbs_Face:
- // myFacePool->destroy(static_cast<SMDS_VtkFace*>(elem));
- // break;
- // case SMDSAbs_Volume:
- // myVolumePool->destroy(static_cast<SMDS_VtkVolume*>(elem));
- // break;
- // case SMDSAbs_Ball:
- // myBallPool->destroy(static_cast<SMDS_BallElement*>(elem));
- // break;
- // default:
- // break;
- // }
- // }
myVolumePool->clear();
myFacePool->clear();
myEdgePool->clear();
SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more())
- {
- SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
- node->SetPosition(SMDS_SpacePosition::originSpacePosition());
- //myNodePool->destroy(node);
- }
+ {
+ SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
+ node->SetPosition(SMDS_SpacePosition::originSpacePosition());
+ //myNodePool->destroy(node);
+ }
myNodePool->clear();
clearVector( myNodes );
// rnv: to fix bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
// using double type for storing coordinates of nodes instead float.
points->SetDataType(VTK_DOUBLE);
- points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/);
+ points->SetNumberOfPoints( 0 );
myGrid->SetPoints( points );
points->Delete();
- myGrid->BuildLinks();
+ myGrid->DeleteLinks();
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
bool SMDS_Mesh::hasConstructionEdges()
{
- return myHasConstructionEdges;
+ return myHasConstructionEdges;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
bool SMDS_Mesh::hasConstructionFaces()
{
- return myHasConstructionFaces;
+ return myHasConstructionFaces;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
bool SMDS_Mesh::hasInverseElements()
{
- return myHasInverseElements;
+ return myHasInverseElements;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::setConstructionEdges(bool b)
{
- myHasConstructionEdges=b;
+ myHasConstructionEdges=b;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
void SMDS_Mesh::setConstructionFaces(bool b)
{
- myHasConstructionFaces=b;
+ myHasConstructionFaces=b;
}
///////////////////////////////////////////////////////////////////////////////
IdSortedIterator(const SMDS_MeshElementIDFactory& fact,
const SMDSAbs_ElementType type, // SMDSAbs_All NOT allowed!!!
const int totalNb)
- :myIDFact( fact ),
+ :myIDFact( const_cast<SMDS_MeshElementIDFactory&>(fact) ),
myID(1), myMaxID( myIDFact.GetMaxID() ),myNbFound(0), myTotalNb( totalNb ),
myType( type ),
myElem(0)
void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
{
int elemId = elem->GetID();
- int vtkId = elem->getVtkId();
+ int vtkId = elem->getVtkId();
SMDSAbs_ElementType aType = elem->GetType();
- SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
- if (aType == SMDSAbs_Node) {
+ SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
+ if ( aType == SMDSAbs_Node )
+ {
// only free node can be removed by this method
const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
- SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
- if (!itFe->more()) { // free node
+ if ( n->NbInverseElements() == 0 ) { // free node
myNodes[elemId] = 0;
myInfo.myNbNodes--;
((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition());
myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
myNodeIDFactory->ReleaseID(elemId, vtkId);
}
- } else {
+ }
+ else
+ {
if (hasConstructionEdges() || hasConstructionFaces())
// this methods is only for meshes without descendants
return;
*/
bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
{
- // we should not imply on validity of *elem, so iterate on containers
+ // we should not rely on validity of *elem, so iterate on containers
// of all types in the hope of finding <elem> somewhere there
SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more())
int SMDS_Mesh::MaxNodeID() const
{
- return myNodeMax;
+ return myNodeIDFactory->GetMaxID();
}
//=======================================================================
int SMDS_Mesh::MinNodeID() const
{
- return myNodeMin;
+ return myNodeIDFactory->GetMinID();
}
//=======================================================================
return volvtk;
}
-
-void SMDS_Mesh::updateNodeMinMax()
-{
- myNodeMin = 0;
- if (myNodes.size() == 0)
- {
- myNodeMax=0;
- return;
- }
- while ( !myNodes[myNodeMin] && myNodeMin < (int)myNodes.size() )
- myNodeMin++;
- myNodeMax=myNodes.size()-1;
- while (!myNodes[myNodeMax] && (myNodeMin>=0))
- myNodeMin--;
-}
-
-void SMDS_Mesh::incrementNodesCapacity(int nbNodes)
-{
-// int val = myCellIdSmdsToVtk.size();
-// MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
-// myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
- int val = myNodes.size();
- myNodes.resize(val +nbNodes, 0);
-}
-
-void SMDS_Mesh::incrementCellsCapacity(int nbCells)
-{
- int val = myCellIdVtkToSmds.size();
- myCellIdVtkToSmds.resize(val + nbCells, -1); // fill new elements with -1
- val = myCells.size();
- myNodes.resize(val +nbCells, 0);
-}
-
-void SMDS_Mesh::adjustStructure()
-{
- myGrid->GetPoints()->GetData()->SetNumberOfTuples(myNodeIDFactory->GetMaxID());
-}
-
void SMDS_Mesh::dumpGrid(string ficdump)
{
// vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
ficcon << endl;
}
ficcon << "-------------------------------- connectivity " << nbPoints << endl;
- vtkCellLinks *links = myGrid->GetCellLinks();
+ vtkCellLinks *links = myGrid->GetLinks();
for (int i=0; i<nbPoints; i++)
{
int ncells = links->GetNcells(i);
for (int j=0; j<ncells; j++)
{
ficcon << " " << cells[j];
- }
- ficcon << endl;
+ }
+ ficcon << endl;
}
ficcon.close();
void SMDS_Mesh::compactMesh()
{
- MESSAGE("SMDS_Mesh::compactMesh do nothing!");
+ this->myCompactTime = this->myModifTime;
}
int SMDS_Mesh::fromVtkToSmds(int vtkid)
throw SALOME_Exception(LOCALIZED ("vtk id out of bounds"));
}
-void SMDS_Mesh::updateBoundingBox()
-{
- xmin = 0; xmax = 0;
- ymin = 0; ymax = 0;
- zmin = 0; zmax = 0;
- vtkPoints *points = myGrid->GetPoints();
- int myNodesSize = this->myNodes.size();
- for (int i = 0; i < myNodesSize; i++)
- {
- if (SMDS_MeshNode *n = myNodes[i])
- {
- double coords[3];
- points->GetPoint(n->myVtkID, coords);
- if (coords[0] < xmin) xmin = coords[0];
- else if (coords[0] > xmax) xmax = coords[0];
- if (coords[1] < ymin) ymin = coords[1];
- else if (coords[1] > ymax) ymax = coords[1];
- if (coords[2] < zmin) zmin = coords[2];
- else if (coords[2] > zmax) zmax = coords[2];
- }
- }
-}
+// void SMDS_Mesh::updateBoundingBox()
+// {
+// xmin = 0; xmax = 0;
+// ymin = 0; ymax = 0;
+// zmin = 0; zmax = 0;
+// vtkPoints *points = myGrid->GetPoints();
+// int myNodesSize = this->myNodes.size();
+// for (int i = 0; i < myNodesSize; i++)
+// {
+// if (SMDS_MeshNode *n = myNodes[i])
+// {
+// double coords[3];
+// points->GetPoint(n->myVtkID, coords);
+// if (coords[0] < xmin) xmin = coords[0];
+// else if (coords[0] > xmax) xmax = coords[0];
+// if (coords[1] < ymin) ymin = coords[1];
+// else if (coords[1] > ymax) ymax = coords[1];
+// if (coords[2] < zmin) zmin = coords[2];
+// else if (coords[2] > zmax) zmax = coords[2];
+// }
+// }
+// }
double SMDS_Mesh::getMaxDim()
{
}
//! get last modification timeStamp
-unsigned long SMDS_Mesh::GetMTime() const
+vtkMTimeType SMDS_Mesh::GetMTime() const
{
return this->myModifTime;
}
bool SMDS_Mesh::isCompacted()
{
- if (this->myModifTime > this->myCompactTime)
- {
- this->myCompactTime = this->myModifTime;
- return false;
- }
- return true;
+ return this->myCompactTime == this->myModifTime;
}
