#pragma warning(disable:4786)
#endif
-#include "utilities.h"
-#include "SMDS_Mesh.hxx"
-#include "SMDS_VolumeOfNodes.hxx"
-#include "SMDS_VolumeOfFaces.hxx"
-#include "SMDS_FaceOfNodes.hxx"
#include "SMDS_FaceOfEdges.hxx"
-#include "SMDS_PolyhedralVolumeOfNodes.hxx"
+#include "SMDS_FaceOfNodes.hxx"
+#include "SMDS_Mesh.hxx"
#include "SMDS_PolygonalFaceOfNodes.hxx"
+#include "SMDS_PolyhedralVolumeOfNodes.hxx"
#include "SMDS_QuadraticEdge.hxx"
#include "SMDS_QuadraticFaceOfNodes.hxx"
#include "SMDS_QuadraticVolumeOfNodes.hxx"
+#include "SMDS_SetIterator.hxx"
#include "SMDS_SpacePosition.hxx"
#include "SMDS_UnstructuredGrid.hxx"
+#include "SMDS_VolumeOfFaces.hxx"
+#include "SMDS_VolumeOfNodes.hxx"
+
+#include "utilities.h"
#include <vtkUnstructuredGrid.h>
#include <vtkUnstructuredGridWriter.h>
myHasConstructionEdges(false), myHasConstructionFaces(false),
myHasInverseElements(true),
myNodeMin(0), myNodeMax(0),
- myNodePool(0), myEdgePool(0), myFacePool(0), myVolumePool(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)
{
myEdgePool = new ObjectPool<SMDS_VtkEdge>(SMDS_Mesh::chunkSize);
myFacePool = new ObjectPool<SMDS_VtkFace>(SMDS_Mesh::chunkSize);
myVolumePool = new ObjectPool<SMDS_VtkVolume>(SMDS_Mesh::chunkSize);
+ myBallPool = new ObjectPool<SMDS_BallElement>(SMDS_Mesh::chunkSize);
myNodes.clear();
myCells.clear();
myNodePool(parent->myNodePool),
myEdgePool(parent->myEdgePool),
myFacePool(parent->myFacePool),
- myVolumePool(parent->myVolumePool)
+ myVolumePool(parent->myVolumePool),
+ myBallPool(parent->myBallPool)
{
}
return NULL;
}
+///////////////////////////////////////////////////////////////////////////////
+/// create a Ball and add it to the current Mesh
+/// @return : The created Ball
+///////////////////////////////////////////////////////////////////////////////
+SMDS_BallElement* SMDS_Mesh::AddBallWithID(int idnode, double diameter, int ID)
+{
+ SMDS_MeshNode * node = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode);
+ if (!node) return NULL;
+ return SMDS_Mesh::AddBallWithID(node, diameter, ID);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// create a Ball and add it to the current Mesh
+/// @return : The created Ball
+///////////////////////////////////////////////////////////////////////////////
+SMDS_BallElement* SMDS_Mesh::AddBall(const SMDS_MeshNode * node, double diameter)
+{
+ return SMDS_Mesh::AddBallWithID(node, diameter, myElementIDFactory->GetFreeID());
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Create a new Ball and at it to the mesh
+/// @param idnode ID of the node
+// @param diameter ball diameter
+/// @param ID ID of the 0D element to create
+/// @return The created 0D element or NULL if an element with this
+/// ID already exists or if input node is not found.
+///////////////////////////////////////////////////////////////////////////////
+SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID)
+{
+ if (!n) return 0;
+
+ if (NbBalls() % CHECKMEMORY_INTERVAL == 0) CheckMemory();
+
+ 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;
+ }
+ adjustmyCellsCapacity(ID);
+ myCells[ID] = ball;
+ myInfo.myNbBalls++;
+ return ball;
+}
+
///////////////////////////////////////////////////////////////////////////////
/// create a MeshEdge and add it to the current Mesh
/// @return : The created MeshEdge
return toReturn;
}
+//=======================================================================
+//function : FindBall
+//purpose :
+//=======================================================================
+
+const SMDS_BallElement* SMDS_Mesh::FindBall(int idnode) const
+{
+ const SMDS_MeshNode * node = FindNode(idnode);
+ if(node == NULL) return NULL;
+ return FindBall(node);
+}
+
+const SMDS_BallElement* SMDS_Mesh::FindBall(const SMDS_MeshNode * node)
+{
+ if (!node) return 0;
+ const SMDS_BallElement* toReturn = NULL;
+ SMDS_ElemIteratorPtr it1 = node->GetInverseElementIterator(SMDSAbs_Ball);
+ while (it1->more() && (toReturn == NULL)) {
+ const SMDS_MeshElement* e = it1->next();
+ if (e->GetGeomType() == SMDSGeom_BALL)
+ toReturn = static_cast<const SMDS_BallElement*>(e);
+ }
+ return toReturn;
+}
+
//=======================================================================
//function : Find0DElementOrCreate
//purpose :
void SMDS_Mesh::Dump0DElements() const
{
MESSAGE("dump 0D elements of mesh : ");
- SMDS_0DElementIteratorPtr it0d = elements0dIterator();
+ SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
while(it0d->more()) ; //MESSAGE(it0d->next());
}
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::Nb0DElements() const
{
- return myInfo.Nb0DElements(); // -PR- a verfier
+ return myInfo.Nb0DElements();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Return the number of 0D elements
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_Mesh::NbBalls() const
+{
+ return myInfo.NbBalls();
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbEdges() const
{
- return myInfo.NbEdges(); // -PR- a verfier
+ return myInfo.NbEdges();
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbFaces() const
{
- return myInfo.NbFaces(); // -PR- a verfier
+ return myInfo.NbFaces();
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbVolumes() const
{
- return myInfo.NbVolumes(); // -PR- a verfier
+ return myInfo.NbVolumes();
}
///////////////////////////////////////////////////////////////////////////////
/// Return the number of child mesh of this mesh.
-/// Note that the tree structure of SMDS_Mesh seems to be unused in this version
-/// (2003-09-08) of SMESH
+/// Note that the tree structure of SMDS_Mesh is unused in SMESH
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbSubMesh() const
{
- return myChildren.size();
+ return myChildren.size();
}
///////////////////////////////////////////////////////////////////////////////
myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
}
}
-
-// SetOfNodes::Iterator itn(myNodes);
-// for (; itn.More(); itn.Next())
-// delete itn.Value();
-
-// SetOf0DElements::Iterator it0d (my0DElements);
-// for (; it0d.More(); it0d.Next())
-// {
-// SMDS_MeshElement* elem = it0d.Value();
-// delete elem;
-// }
-
-// SetOfEdges::Iterator ite(myEdges);
-// for (; ite.More(); ite.Next())
-// {
-// SMDS_MeshElement* elem = ite.Value();
-// delete elem;
-// }
-
-// SetOfFaces::Iterator itf(myFaces);
-// for (; itf.More(); itf.Next())
-// {
-// SMDS_MeshElement* elem = itf.Value();
-// delete elem;
-// }
-
-// SetOfVolumes::Iterator itv(myVolumes);
-// for (; itv.More(); itv.Next())
-// {
-// SMDS_MeshElement* elem = itv.Value();
-// delete elem;
-// }
}
//================================================================================
case SMDSAbs_Volume:
myVolumePool->destroy(static_cast<SMDS_VtkVolume*>(elem));
break;
+ case SMDSAbs_Ball:
+ myBallPool->destroy(static_cast<SMDS_BallElement*>(elem));
+ break;
default:
break;
}
namespace {
-///////////////////////////////////////////////////////////////////////////////
-///Iterator on NCollection_Map
-///////////////////////////////////////////////////////////////////////////////
-template <class MAP, typename ELEM=const SMDS_MeshElement*, class FATHER=SMDS_ElemIterator>
-struct MYNode_Map_Iterator: public FATHER
-{
- int _ctr;
- const MAP& _map;
- MYNode_Map_Iterator(const MAP& map): _map(map) // map is a std::vector<ELEM>
- {
- _ctr = 0;
- }
-
- bool more()
- {
- while (_ctr < _map.size())
- {
- if (_map[_ctr])
- return true;
- _ctr++;
- }
- return false;
- }
-
- ELEM next()
- {
- ELEM current = _map[_ctr];
- _ctr++;
- return current;
- }
-};
-
- template <class MAP, typename ELEM=const SMDS_MeshElement*, class FATHER=SMDS_ElemIterator>
- struct MYElem_Map_Iterator: public FATHER
- {
- size_t _ctr;
- int _type, _more;
- const MAP& _map;
- MYElem_Map_Iterator(const MAP& map, int typ): _map(map) // map is a std::vector<ELEM>
- {
- _ctr = 0;
- _type = typ;
- _more = _ctr < _map.size();
- if ( _more && ( !_map[_ctr] || ( _type != SMDSAbs_All && _map[_ctr]->GetType() != _type)))
- next();
- }
-
- bool more()
- {
- return _more;
- }
-
- ELEM next()
- {
- if ( !_more ) return NULL;
- ELEM current = dynamic_cast<ELEM> (_map[_ctr]);
- _more = 0;
- while ( !_more && ++_ctr < _map.size() )
- _more = ( _map[_ctr] && (_type == SMDSAbs_All || _map[_ctr]->GetType() == _type));
- return current;
- }
- };
-
//================================================================================
/*!
* \brief Iterator on elements in id increasing order
return current;
}
};
+
+ typedef SMDS::NonNullFilter<const SMDS_MeshNode*> NonNullNodeFilter;
+ typedef SMDS::NonNullFilter<const SMDS_MeshElement*> NonNullElemFilter;
+ typedef SMDS_Mesh::SetOfNodes::const_iterator SetOfNodesIter;
+ typedef SMDS_Mesh::SetOfCells::const_iterator SetOfCellsIter;
+ typedef SMDS::SimpleAccessor<const SMDS_MeshNode*, SetOfNodesIter> NodeInSetOfNodes;
+ typedef SMDS::SimpleAccessor<const SMDS_MeshElement*,SetOfCellsIter> CellInSetOfCells;
+
+#define TypedElemIterator(elemType) \
+ SMDS_SetIterator < const elemType*, \
+ SetOfCellsIter, \
+ SMDS::SimpleAccessor<const elemType*,SetOfCellsIter>, \
+ SMDS_MeshElement::TypeFilter \
+ >
}
///////////////////////////////////////////////////////////////////////////////
SMDS_NodeIteratorPtr SMDS_Mesh::nodesIterator(bool idInceasingOrder) const
{
- typedef MYNode_Map_Iterator
- < SetOfNodes, const SMDS_MeshNode*, SMDS_NodeIterator > TIterator;
- return SMDS_NodeIteratorPtr( new TIterator(myNodes)); // naturally always sorted by ID
+ typedef SMDS_SetIterator
+ <const SMDS_MeshNode*, SetOfNodesIter, NodeInSetOfNodes, NonNullNodeFilter> TIterator;
+ // naturally always sorted by ID
+ return SMDS_NodeIteratorPtr( new TIterator(myNodes.begin(), myNodes.end()));
+}
+
+SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) const
+{
+ typedef SMDS_SetIterator
+ < const SMDS_MeshElement*, SetOfCellsIter, CellInSetOfCells, SMDS_MeshElement::GeomFilter >
+ TIterator;
+ // naturally always sorted by ID
+ return SMDS_ElemIteratorPtr
+ (new TIterator(myCells.begin(), myCells.end(), SMDS_MeshElement::GeomFilter( type )));
+}
-// typedef IdSortedIterator< const SMDS_MeshNode* > TSortedIterator;
-// return ( idInceasingOrder ?
-// SMDS_NodeIteratorPtr( new TSortedIterator( *myNodeIDFactory, SMDSAbs_Node, NbNodes())) :
-// SMDS_NodeIteratorPtr( new TIterator(myNodes)));
+SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) const
+{
+ typedef SMDS_SetIterator
+ < const SMDS_MeshElement*, SetOfCellsIter, CellInSetOfCells, SMDS_MeshElement::EntityFilter >
+ TIterator;
+ // naturally always sorted by ID
+ return SMDS_ElemIteratorPtr
+ (new TIterator(myCells.begin(), myCells.end(), SMDS_MeshElement::EntityFilter( type )));
}
///////////////////////////////////////////////////////////////////////////////
-///Return an iterator on 0D elements of the current mesh.
+/// Return an iterator on elements of the current mesh factory
///////////////////////////////////////////////////////////////////////////////
-
-SMDS_0DElementIteratorPtr SMDS_Mesh::elements0dIterator(bool idInceasingOrder) const
+SMDS_ElemIteratorPtr SMDS_Mesh::elementsIterator(SMDSAbs_ElementType type) const
{
- typedef MYElem_Map_Iterator
- < SetOfCells, const SMDS_Mesh0DElement*, SMDS_0DElementIterator > TIterator;
- return SMDS_0DElementIteratorPtr(new TIterator(myCells, SMDSAbs_0DElement)); // naturally always sorted by ID
-
-// typedef MYNCollection_Map_Iterator
-// < SetOf0DElements, const SMDS_Mesh0DElement*, SMDS_0DElementIterator > TIterator;
-// typedef IdSortedIterator< const SMDS_Mesh0DElement* > TSortedIterator;
-// return ( idInceasingOrder ?
-// SMDS_0DElementIteratorPtr( new TSortedIterator( *myElementIDFactory,
-// SMDSAbs_0DElement,
-// Nb0DElements() )) :
-// SMDS_0DElementIteratorPtr( new TIterator(my0DElements)));
+ // naturally always sorted by ID
+ if ( type == SMDSAbs_All )
+ {
+ typedef SMDS_SetIterator
+ < const SMDS_MeshElement*, SetOfCellsIter, CellInSetOfCells, NonNullElemFilter >
+ TIterator;
+ return SMDS_ElemIteratorPtr (new TIterator(myCells.begin(), myCells.end()));
+ }
+ else
+ {
+ typedef SMDS_SetIterator
+ < const SMDS_MeshElement*, SetOfCellsIter, CellInSetOfCells, SMDS_MeshElement::TypeFilter >
+ TIterator;
+ // naturally always sorted by ID
+ return SMDS_ElemIteratorPtr
+ (new TIterator(myCells.begin(), myCells.end(), SMDS_MeshElement::TypeFilter( type )));
+ }
}
///////////////////////////////////////////////////////////////////////////////
SMDS_EdgeIteratorPtr SMDS_Mesh::edgesIterator(bool idInceasingOrder) const
{
- typedef MYElem_Map_Iterator
- < SetOfCells, const SMDS_MeshEdge*, SMDS_EdgeIterator > TIterator;
- return SMDS_EdgeIteratorPtr(new TIterator(myCells, SMDSAbs_Edge)); // naturally always sorted by ID
-
-// typedef MYNCollection_Map_Iterator
-// < SetOfEdges, const SMDS_MeshEdge*, SMDS_EdgeIterator > TIterator;
-// typedef IdSortedIterator< const SMDS_MeshEdge* > TSortedIterator;
-// return ( idInceasingOrder ?
-// SMDS_EdgeIteratorPtr( new TSortedIterator( *myElementIDFactory,
-// SMDSAbs_Edge,
-// NbEdges() )) :
-// SMDS_EdgeIteratorPtr(new TIterator(myEdges)));
+ // naturally always sorted by ID
+ typedef TypedElemIterator( SMDS_MeshEdge ) TIterator;
+ return SMDS_EdgeIteratorPtr
+ (new TIterator(myCells.begin(), myCells.end(), SMDS_MeshElement::TypeFilter( SMDSAbs_Edge )));
}
///////////////////////////////////////////////////////////////////////////////
SMDS_FaceIteratorPtr SMDS_Mesh::facesIterator(bool idInceasingOrder) const
{
- typedef MYElem_Map_Iterator
- < SetOfCells, const SMDS_MeshFace*, SMDS_FaceIterator > TIterator;
- return SMDS_FaceIteratorPtr(new TIterator(myCells, SMDSAbs_Face)); // naturally always sorted by ID
-
-// typedef MYNCollection_Map_Iterator
-// < SetOfFaces, const SMDS_MeshFace*, SMDS_FaceIterator > TIterator;
-// typedef IdSortedIterator< const SMDS_MeshFace* > TSortedIterator;
-// return ( idInceasingOrder ?
-// SMDS_FaceIteratorPtr( new TSortedIterator( *myElementIDFactory,
-// SMDSAbs_Face,
-// NbFaces() )) :
-// SMDS_FaceIteratorPtr(new TIterator(myFaces)));
+ // naturally always sorted by ID
+ typedef TypedElemIterator( SMDS_MeshFace ) TIterator;
+ return SMDS_FaceIteratorPtr
+ (new TIterator(myCells.begin(), myCells.end(), SMDS_MeshElement::TypeFilter( SMDSAbs_Face )));
}
///////////////////////////////////////////////////////////////////////////////
SMDS_VolumeIteratorPtr SMDS_Mesh::volumesIterator(bool idInceasingOrder) const
{
- typedef MYElem_Map_Iterator
- < SetOfCells, const SMDS_MeshVolume*, SMDS_VolumeIterator > TIterator;
- return SMDS_VolumeIteratorPtr(new TIterator(myCells, SMDSAbs_Volume)); // naturally always sorted by ID
-
- // typedef MYNCollection_Map_Iterator
-// < SetOfVolumes, const SMDS_MeshVolume*, SMDS_VolumeIterator > TIterator;
-// typedef IdSortedIterator< const SMDS_MeshVolume* > TSortedIterator;
-// return ( idInceasingOrder ?
-// SMDS_VolumeIteratorPtr( new TSortedIterator( *myElementIDFactory,
-// SMDSAbs_Volume,
-// NbVolumes() )) :
-// 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:
- return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_All));
- break;
- case SMDSAbs_Volume:
- return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_Volume));
- case SMDSAbs_Face:
- return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_Face));
- case SMDSAbs_Edge:
- return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_Edge));
- case SMDSAbs_0DElement:
- return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfCells >(myCells, SMDSAbs_0DElement));
- case SMDSAbs_Node:
- return SMDS_ElemIteratorPtr (new MYElem_Map_Iterator< SetOfNodes >(myNodes, SMDSAbs_All));
- //return myNodeIDFactory->elementsIterator();
- default:;
- }
- return myElementIDFactory->elementsIterator();
+ // naturally always sorted by ID
+ typedef TypedElemIterator( SMDS_MeshVolume ) TIterator;
+ return SMDS_VolumeIteratorPtr
+ (new TIterator(myCells.begin(), myCells.end(), SMDS_MeshElement::TypeFilter( SMDSAbs_Volume )));
}
///////////////////////////////////////////////////////////////////////////////
else
delete (*it);
break;
+ case SMDSAbs_Ball:
+ if (IdToRemove >= 0)
+ {
+ myCells[IdToRemove] = 0;
+ myInfo.remove(*it);
+ }
+ removedElems.push_back((*it));
+ myElementIDFactory->ReleaseID(IdToRemove, vtkid);
+ if (const SMDS_BallElement* vtkElem = dynamic_cast<const SMDS_BallElement*>(*it))
+ myBallPool->destroy(const_cast<SMDS_BallElement*>( vtkElem ));
+ else
+ delete (*it);
+ break;
}
if (vtkid >= 0)
{
myInfo.RemoveVolume(elem);
myVolumePool->destroy(static_cast<SMDS_VtkVolume*>(todest));
break;
+ case SMDSAbs_Ball:
+ myCells[elemId] = 0;
+ myInfo.remove(elem);
+ myBallPool->destroy(static_cast<SMDS_BallElement*>(todest));
+ break;
default:
break;
}
while (itn->more())
if (elem == itn->next())
return true;
- SMDS_0DElementIteratorPtr it0d = elements0dIterator();
- while (it0d->more())
- if (elem == it0d->next())
- return true;
- SMDS_EdgeIteratorPtr ite = edgesIterator();
+ SMDS_ElemIteratorPtr ite = elementsIterator();
while (ite->more())
if (elem == ite->next())
return true;
- SMDS_FaceIteratorPtr itf = facesIterator();
- while (itf->more())
- if (elem == itf->next())
- return true;
- SMDS_VolumeIteratorPtr itv = volumesIterator();
- while (itv->more())
- if (elem == itv->next())
- return true;
return false;
}
#include "SMDS_VtkVolume.hxx"
#include "ObjectPool.hxx"
#include "SMDS_UnstructuredGrid.hxx"
+#include "SMDS_BallElement.hxx"
#include <boost/shared_ptr.hpp>
#include <set>
#include <cassert>
#include "Utils_SALOME_Exception.hxx"
+
#define MYASSERT(val) if (!(val)) throw SALOME_Exception(LOCALIZED("assertion not verified"));
-class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
+class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject
+{
public:
friend class SMDS_MeshIDFactory;
friend class SMDS_MeshNodeIDFactory;
inline SMDS_UnstructuredGrid* getGrid() {return myGrid; }
inline int getMeshId() {return myMeshId; }
- virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const;
- virtual SMDS_0DElementIteratorPtr elements0dIterator(bool idInceasingOrder=false) const;
- virtual SMDS_EdgeIteratorPtr edgesIterator (bool idInceasingOrder=false) const;
- virtual SMDS_FaceIteratorPtr facesIterator (bool idInceasingOrder=false) const;
- virtual SMDS_VolumeIteratorPtr volumesIterator (bool idInceasingOrder=false) const;
+ virtual SMDS_NodeIteratorPtr nodesIterator (bool idInceasingOrder=false) const;
+ virtual SMDS_EdgeIteratorPtr edgesIterator (bool idInceasingOrder=false) const;
+ virtual SMDS_FaceIteratorPtr facesIterator (bool idInceasingOrder=false) const;
+ virtual SMDS_VolumeIteratorPtr volumesIterator (bool idInceasingOrder=false) const;
virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType type=SMDSAbs_All) const;
+ virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;
+ virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;
SMDSAbs_ElementType GetElementType( const int id, const bool iselem ) const;
SMDS_Mesh *AddSubMesh();
virtual SMDS_MeshNode* AddNodeWithID(double x, double y, double z, int ID);
- virtual SMDS_MeshNode* AddNode(double x, double y, double z);
+ virtual SMDS_MeshNode* AddNode (double x, double y, double z);
- virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
+ virtual SMDS_Mesh0DElement* Add0DElementWithID(int n, int ID);
virtual SMDS_Mesh0DElement* Add0DElementWithID(const SMDS_MeshNode * n, int ID);
virtual SMDS_Mesh0DElement* Add0DElement (const SMDS_MeshNode * n);
+ virtual SMDS_BallElement* AddBallWithID(int n, double diameter, int ID);
+ virtual SMDS_BallElement* AddBallWithID(const SMDS_MeshNode * n, double diameter, int ID);
+ virtual SMDS_BallElement* AddBall (const SMDS_MeshNode * n, double diameter);
+
virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode *FindNode(int idnode) const;
const SMDS_MeshNode *FindNodeVtk(int idnode) const;
const SMDS_Mesh0DElement* Find0DElement(int idnode) const;
+ const SMDS_BallElement* FindBall(int idnode) const;
const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2) const;
const SMDS_MeshEdge *FindEdge(int idnode1, int idnode2, int idnode3) const;
const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3) const;
int idnode5, int idnode6, int idnode7, int idnode8) const;
const SMDS_MeshElement *FindElement(int IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
+ static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
virtual int NbNodes() const;
virtual int Nb0DElements() const;
+ virtual int NbBalls() const;
virtual int NbEdges() const;
virtual int NbFaces() const;
virtual int NbVolumes() const;
const SMDS_MeshNode * node3,
const SMDS_MeshNode * node4,
int ID);
-// SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2);
SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
ObjectPool<SMDS_MeshNode>* myNodePool;
//! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
- ObjectPool<SMDS_VtkVolume>* myVolumePool;
- ObjectPool<SMDS_VtkFace>* myFacePool;
- ObjectPool<SMDS_VtkEdge>* myEdgePool;
+ ObjectPool<SMDS_VtkVolume>* myVolumePool;
+ ObjectPool<SMDS_VtkFace>* myFacePool;
+ ObjectPool<SMDS_VtkEdge>* myEdgePool;
+ ObjectPool<SMDS_BallElement>* myBallPool;
//! SMDS_MeshNodes refer to vtk nodes (vtk id = index in myNodes),store reference to this mesh, and sub-shape
SetOfNodes myNodes;
