-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
//
#include "SMESHDS_Mesh.hxx"
-#include "SMESHDS_Group.hxx"
-#include "SMDS_VertexPosition.hxx"
+#include "SMDS_Downward.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
#include "SMDS_SpacePosition.hxx"
-#include "SMDS_Downward.hxx"
+#include "SMDS_VertexPosition.hxx"
+#include "SMESHDS_Group.hxx"
#include "SMESHDS_GroupOnGeom.hxx"
#include "SMESHDS_Script.hxx"
+#include "SMESHDS_TSubMeshHolder.hxx"
#include <Standard_ErrorHandler.hxx>
#include <Standard_OutOfRange.hxx>
using namespace std;
+class SMESHDS_Mesh::SubMeshHolder : public SMESHDS_TSubMeshHolder< const SMESHDS_SubMesh >
+{
+};
+
//=======================================================================
//function : Create
//purpose :
//=======================================================================
SMESHDS_Mesh::SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode):
myMeshID(theMeshID),
- myIsEmbeddedMode(theIsEmbeddedMode),
- myCurSubID(-1)
+ mySubMeshHolder( new SubMeshHolder ),
+ myIsEmbeddedMode(theIsEmbeddedMode)
{
myScript = new SMESHDS_Script(theIsEmbeddedMode);
- myCurSubMesh = 0;
SetPersistentId(theMeshID);
}
// - hypotheses
myShapeToHypothesis.Clear();
// - shape indices in SMDS_Position of nodes
- map<int,SMESHDS_SubMesh*>::iterator i_sub = myShapeIndexToSubMesh.begin();
- for ( ; i_sub != myShapeIndexToSubMesh.end(); i_sub++ ) {
- if ( !i_sub->second->IsComplexSubmesh() ) {
- SMDS_NodeIteratorPtr nIt = i_sub->second->GetNodes();
+ SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
+ while ( SMESHDS_SubMesh* sm = const_cast< SMESHDS_SubMesh* >( smIt->next() )) {
+ if ( !sm->IsComplexSubmesh() ) {
+ SMDS_NodeIteratorPtr nIt = sm->GetNodes();
while ( nIt->more() )
- i_sub->second->RemoveNode(nIt->next(), false);
+ sm->RemoveNode(nIt->next(), false);
}
}
// - sub-meshes
- TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
- for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
- delete i_sm->second;
- myShapeIndexToSubMesh.clear();
+ mySubMeshHolder->DeleteAll();
+
myIndexToShape.Clear();
// - groups on geometry
set<SMESHDS_GroupBase*>::iterator gr = myGroups.begin();
bool SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape & SS,
const SMESHDS_Hypothesis * H)
{
- if (!myShapeToHypothesis.IsBound(SS.Oriented(TopAbs_FORWARD))) {
+ if (!myShapeToHypothesis.IsBound(SS/*.Oriented(TopAbs_FORWARD)*/)) {
list<const SMESHDS_Hypothesis *> aList;
- myShapeToHypothesis.Bind(SS.Oriented(TopAbs_FORWARD), aList);
+ myShapeToHypothesis.Bind(SS/*.Oriented(TopAbs_FORWARD)*/, aList);
}
list<const SMESHDS_Hypothesis *>& alist =
- myShapeToHypothesis(SS.Oriented(TopAbs_FORWARD)); // ignore orientation of SS
+ myShapeToHypothesis(SS/*.Oriented(TopAbs_FORWARD)*/); // ignore orientation of SS
//Check if the Hypothesis is still present
list<const SMESHDS_Hypothesis*>::iterator ith = find(alist.begin(),alist.end(), H );
bool SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape & S,
const SMESHDS_Hypothesis * H)
{
- if( myShapeToHypothesis.IsBound( S.Oriented(TopAbs_FORWARD) ) )
+ if( myShapeToHypothesis.IsBound( S/*.Oriented(TopAbs_FORWARD)*/ ) )
{
- list<const SMESHDS_Hypothesis *>& alist=myShapeToHypothesis.ChangeFind( S.Oriented(TopAbs_FORWARD) );
+ list<const SMESHDS_Hypothesis *>& alist=myShapeToHypothesis.ChangeFind( S/*.Oriented(TopAbs_FORWARD)*/ );
list<const SMESHDS_Hypothesis*>::iterator ith=find(alist.begin(),alist.end(), H );
if (ith != alist.end())
{
//function : MoveNode
//purpose :
//=======================================================================
+
void SMESHDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
{
- SMDS_MeshNode * node=const_cast<SMDS_MeshNode*>(n);
- node->setXYZ(x,y,z);
+ SMDS_Mesh::MoveNode( n, x, y, z );
myScript->MoveNode(n->GetID(), x, y, z);
}
//=======================================================================
//function : ChangeElementNodes
-//purpose :
+//purpose : Changed nodes of an element provided that nb of nodes does not change
//=======================================================================
bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
return anElem;
}
-SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID
- (const std::vector<const SMDS_MeshNode*>& nodes,
- const int ID)
+SMDS_MeshFace*
+SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
+ const int ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
if (anElem) {
return anElem;
}
-SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFace
- (const std::vector<const SMDS_MeshNode*>& nodes)
+SMDS_MeshFace*
+SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
if (anElem) {
return anElem;
}
+
+//=======================================================================
+//function : AddQuadPolygonalFace
+//purpose :
+//=======================================================================
+SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>& nodes_ids,
+ const int ID)
+{
+ SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes_ids, ID);
+ if (anElem) {
+ myScript->AddQuadPolygonalFace(ID, nodes_ids);
+ }
+ return anElem;
+}
+
+SMDS_MeshFace*
+SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
+ const int ID)
+{
+ SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
+ if (anElem) {
+ int i, len = nodes.size();
+ std::vector<int> nodes_ids (len);
+ for (i = 0; i < len; i++) {
+ nodes_ids[i] = nodes[i]->GetID();
+ }
+ myScript->AddQuadPolygonalFace(ID, nodes_ids);
+ }
+ return anElem;
+}
+
+SMDS_MeshFace*
+SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
+{
+ SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFace(nodes);
+ if (anElem) {
+ int i, len = nodes.size();
+ std::vector<int> nodes_ids (len);
+ for (i = 0; i < len; i++) {
+ nodes_ids[i] = nodes[i]->GetID();
+ }
+ myScript->AddQuadPolygonalFace(anElem->GetID(), nodes_ids);
+ }
+ return anElem;
+}
+
+
//=======================================================================
//function : AddPolyhedralVolume
//purpose :
//purpose :
//=======================================================================
-static void removeFromContainers (map<int,SMESHDS_SubMesh*>& theSubMeshes,
+static void removeFromContainers (SMESHDS_Mesh* theMesh,
set<SMESHDS_GroupBase*>& theGroups,
list<const SMDS_MeshElement*>& theElems,
const bool isNode)
// Rm from sub-meshes
// Element should belong to only one sub-mesh
- if ( !theSubMeshes.empty() )
+ if ( theMesh->SubMeshes()->more() )
{
- SMESHDS_Mesh* mesh = theSubMeshes.begin()->second->getParent();
list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
if ( isNode ) {
for ( ; elIt != theElems.end(); ++elIt )
- if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
+ if ( SMESHDS_SubMesh* sm = theMesh->MeshElements( (*elIt)->getshapeId() ))
sm->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
}
else {
for ( ; elIt != theElems.end(); ++elIt )
- if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
+ if ( SMESHDS_SubMesh* sm = theMesh->MeshElements( (*elIt)->getshapeId() ))
sm->RemoveElement( *elIt, deleted );
}
}
//=======================================================================
//function : RemoveNode
-//purpose :
+//purpose :
//=======================================================================
void SMESHDS_Mesh::RemoveNode(const SMDS_MeshNode * n)
{
if ( n->NbInverseElements() == 0 && !(hasConstructionEdges() || hasConstructionFaces()))
{
- SMESHDS_SubMesh* subMesh=0;
- map<int,SMESHDS_SubMesh*>::iterator SubIt =
- myShapeIndexToSubMesh.find( n->getshapeId() );
- if ( SubIt != myShapeIndexToSubMesh.end() )
- subMesh = SubIt->second;
- else
- SubIt = myShapeIndexToSubMesh.begin();
- for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
- if (!SubIt->second->IsComplexSubmesh() && SubIt->second->Contains( n ))
- subMesh = SubIt->second;
-
- RemoveFreeNode( n, subMesh, true);
+ RemoveFreeNode( n, 0, true );
return;
}
-
+
myScript->RemoveNode(n->GetID());
-
+
list<const SMDS_MeshElement *> removedElems;
list<const SMDS_MeshElement *> removedNodes;
SMDS_Mesh::RemoveElement( n, removedElems, removedNodes, true );
- removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
- removeFromContainers( myShapeIndexToSubMesh, myGroups, removedNodes, true );
+ removeFromContainers( this, myGroups, removedElems, false );
+ removeFromContainers( this, myGroups, removedNodes, true );
}
//=======================================================================
set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
for (; GrIt != myGroups.end(); GrIt++) {
SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>(*GrIt);
- if (!group || group->IsEmpty()) continue;
- group->SMDSGroup().Remove(n);
+ if (group && !group->IsEmpty())
+ group->SMDSGroup().Remove(n);
}
}
// Rm from sub-mesh
// Node should belong to only one sub-mesh
- if( subMesh )
- subMesh->RemoveNode(n,/*deleted=*/false);
+ if ( !subMesh || !subMesh->RemoveNode(n,/*deleted=*/false))
+ if (( subMesh = MeshElements( n->getshapeId() )))
+ subMesh->RemoveNode(n,/*deleted=*/false );
SMDS_Mesh::RemoveFreeElement(n);
}
if (!hasConstructionEdges() && !hasConstructionFaces())
{
SMESHDS_SubMesh* subMesh=0;
- map<int,SMESHDS_SubMesh*>::iterator SubIt = myShapeIndexToSubMesh.begin();
- for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
- if (!SubIt->second->IsComplexSubmesh() && SubIt->second->Contains( elt ))
- subMesh = SubIt->second;
- //MESSAGE("subMesh " << elt->getshapeId());
- RemoveFreeElement( elt, subMesh, true);
+ if ( elt->getshapeId() > 0 )
+ subMesh = MeshElements( elt->getshapeId() );
+
+ RemoveFreeElement( elt, subMesh, true );
return;
}
list<const SMDS_MeshElement *> removedElems;
list<const SMDS_MeshElement *> removedNodes;
- SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes, false);
+ SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes, false );
- removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
+ removeFromContainers( this, myGroups, removedElems, false );
}
//=======================================================================
myScript->RemoveElement(elt->GetID());
// Rm from group
- // Node can belong to several groups
+ // Element can belong to several groups
if ( fromGroups && !myGroups.empty() ) {
set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
for (; GrIt != myGroups.end(); GrIt++) {
// Rm from sub-mesh
// Element should belong to only one sub-mesh
- if( subMesh )
- subMesh->RemoveElement(elt, /*deleted=*/false);
+ if ( !subMesh && elt->getshapeId() > 0 )
+ subMesh = MeshElements( elt->getshapeId() );
+ if ( subMesh )
+ subMesh->RemoveElement( elt, /*deleted=*/false );
- SMDS_Mesh::RemoveFreeElement(elt);
+ SMDS_Mesh::RemoveFreeElement( elt );
}
//================================================================================
SMDS_Mesh::Clear();
// clear submeshes
- map<int,SMESHDS_SubMesh*>::iterator sub, subEnd = myShapeIndexToSubMesh.end();
- for ( sub = myShapeIndexToSubMesh.begin(); sub != subEnd; ++sub )
- sub->second->Clear();
+ SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
+ while ( SMESHDS_SubMesh* sm = const_cast< SMESHDS_SubMesh* >( smIt->next() ))
+ sm->Clear();
// clear groups
TGroups::iterator group, groupEnd = myGroups.end();
g->Clear();
g->SetType( groupType );
}
+ else
+ {
+ (*group)->Extent(); // to free cashed elements in GroupOnFilter's
+ }
}
}
* \brief return submesh by shape
* \param shape - the sub-shape
* \retval SMESHDS_SubMesh* - the found submesh
- *
- * search of submeshes is optimized
*/
//================================================================================
if ( shape.IsNull() )
return 0;
- if ( !myCurSubShape.IsNull() && shape.IsSame( myCurSubShape ))
- return myCurSubMesh;
-
- getSubmesh( ShapeToIndex( shape ));
- myCurSubShape = shape;
- return myCurSubMesh;
-}
-
-//================================================================================
-/*!
- * \brief return submesh by sub-shape index
- * \param Index - the sub-shape index
- * \retval SMESHDS_SubMesh* - the found submesh
- * search of submeshes is optimized
- */
-//================================================================================
-
-SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const int Index )
-{
- //Update or build submesh
- if ( Index != myCurSubID ) {
- map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
- if ( it == myShapeIndexToSubMesh.end() )
- it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
- myCurSubMesh = it->second;
- myCurSubID = Index;
- myCurSubShape.Nullify(); // myCurSubShape no more corresponds to submesh
- }
- return myCurSubMesh;
+ return NewSubMesh( ShapeToIndex( shape ));
}
//================================================================================
//function : SetNodeOnVolume
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeInVolume(SMDS_MeshNode * aNode,
+void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode,
const TopoDS_Shell & S)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition() );
}
//=======================================================================
//function : SetNodeOnVolume
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeInVolume(SMDS_MeshNode * aNode,
+void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode * aNode,
const TopoDS_Solid & S)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition() );
}
//=======================================================================
//function : SetNodeOnFace
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeOnFace(SMDS_MeshNode * aNode,
+void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode * aNode,
const TopoDS_Face & S,
double u,
double v)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
}
//=======================================================================
//function : SetNodeOnEdge
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeOnEdge(SMDS_MeshNode * aNode,
+void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode * aNode,
const TopoDS_Edge & S,
double u)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
}
//=======================================================================
//function : SetNodeOnVertex
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode * aNode,
+void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode * aNode,
const TopoDS_Vertex & S)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
}
//=======================================================================
void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
{
int shapeId = aNode->getshapeId();
- if (shapeId >= 0)
- {
- map<int, SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find(shapeId);
- if (it != myShapeIndexToSubMesh.end())
- it->second->RemoveNode(aNode, /*deleted=*/false);
- }
+ if (shapeId > 0)
+ if ( SMESHDS_SubMesh* sm = MeshElements( shapeId ))
+ sm->RemoveNode(aNode, /*deleted=*/false);
}
//=======================================================================
void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
const TopoDS_Shape & S)
{
- int Index = myIndexToShape.FindIndex(S);
-
- map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
- if ( it != myShapeIndexToSubMesh.end() )
- {
- if (elem->GetType() == SMDSAbs_Node)
- it->second->RemoveNode(static_cast<const SMDS_MeshNode*> (elem), /*deleted=*/false);
- else
- it->second->RemoveElement(elem, /*deleted=*/false);
- }
+ if ( SMESHDS_SubMesh* sm = MeshElements( S ))
+ {
+ if (elem->GetType() == SMDSAbs_Node)
+ sm->RemoveNode(static_cast<const SMDS_MeshNode*> (elem), /*deleted=*/false);
+ else
+ sm->RemoveElement(elem, /*deleted=*/false);
+ }
}
//=======================================================================
//=======================================================================
TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() const
{
- return myShape;
+ return myShape;
}
//=======================================================================
SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const TopoDS_Shape & S) const
{
int Index = ShapeToIndex(S);
- TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
- if (anIter != myShapeIndexToSubMesh.end())
- return anIter->second;
- else
- return NULL;
+ return (SMESHDS_SubMesh *) ( Index ? mySubMeshHolder->Get( Index ) : 0 );
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
{
- TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
- if (anIter != myShapeIndexToSubMesh.end())
- return anIter->second;
- else
- return NULL;
+ return const_cast< SMESHDS_SubMesh* >( mySubMeshHolder->Get( Index ));
}
//=======================================================================
list<int> SMESHDS_Mesh::SubMeshIndices() const
{
list<int> anIndices;
- std::map<int,SMESHDS_SubMesh*>::const_iterator anIter = myShapeIndexToSubMesh.begin();
- for (; anIter != myShapeIndexToSubMesh.end(); anIter++) {
- anIndices.push_back((*anIter).first);
- }
+ SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
+ while ( const SMESHDS_SubMesh* sm = smIt->next() )
+ anIndices.push_back( sm->GetID() );
+
return anIndices;
}
+//=======================================================================
+//function : SubMeshes
+//purpose :
+//=======================================================================
+
+SMESHDS_SubMeshIteratorPtr SMESHDS_Mesh::SubMeshes() const
+{
+ return SMESHDS_SubMeshIteratorPtr( mySubMeshHolder->GetIterator() );
+}
+
//=======================================================================
//function : GetHypothesis
//purpose :
const list<const SMESHDS_Hypothesis*>&
SMESHDS_Mesh::GetHypothesis(const TopoDS_Shape & S) const
{
- if ( myShapeToHypothesis.IsBound( S.Oriented(TopAbs_FORWARD) ) ) // ignore orientation of S
- return myShapeToHypothesis.Find( S.Oriented(TopAbs_FORWARD) );
+ if ( myShapeToHypothesis.IsBound( S/*.Oriented(TopAbs_FORWARD)*/ ) ) // ignore orientation of S
+ return myShapeToHypothesis.Find( S/*.Oriented(TopAbs_FORWARD)*/ );
static list<const SMESHDS_Hypothesis*> empty;
return empty;
//=======================================================================
bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
{
- if (myShape.IsNull()) MESSAGE("myShape is NULL");
- int Index = myIndexToShape.FindIndex(S);
- return myShapeIndexToSubMesh.find(Index)!=myShapeIndexToSubMesh.end();
+ int Index = myIndexToShape.FindIndex(S);
+ return mySubMeshHolder->Get( Index );
}
//=======================================================================
//=======================================================================
bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
{
- return myShapeToHypothesis.IsBound(S.Oriented(TopAbs_FORWARD));
+ return myShapeToHypothesis.IsBound(S/*.Oriented(TopAbs_FORWARD)*/);
}
//=======================================================================
//=======================================================================
SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
{
- SMESHDS_SubMesh* SM = 0;
- TShapeIndexToSubMesh::iterator anIter = myShapeIndexToSubMesh.find(Index);
- if (anIter == myShapeIndexToSubMesh.end())
+ SMESHDS_SubMesh* SM = MeshElements( Index );
+ if ( !SM )
{
SM = new SMESHDS_SubMesh(this, Index);
- myShapeIndexToSubMesh[Index]=SM;
+ mySubMeshHolder->Add( Index, SM );
}
- else
- SM = anIter->second;
return SM;
}
{
try
{
- return myIndexToShape.FindKey(ShapeIndex);
+ if ( ShapeIndex > 0 )
+ return myIndexToShape.FindKey(ShapeIndex);
}
catch ( Standard_OutOfRange )
{
int SMESHDS_Mesh::MaxSubMeshIndex() const
{
- return myShapeIndexToSubMesh.empty() ? 0 : myShapeIndexToSubMesh.rbegin()->first;
+ return mySubMeshHolder->GetMaxID();
}
//=======================================================================
//=======================================================================
void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
{
- //add(aNode, getSubmesh(Index));
- if ( add( aNode, getSubmesh( Index )))
+ if ( add( aNode, NewSubMesh( Index )))
((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition());
}
//function : SetNodeOnFace
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeOnFace(SMDS_MeshNode* aNode, int Index, double u, double v)
+void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode* aNode, int Index, double u, double v)
{
//Set Position on Node
- if ( add( aNode, getSubmesh( Index )))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
+ if ( add( aNode, NewSubMesh( Index )))
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
}
//=======================================================================
//function : SetNodeOnEdge
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeOnEdge(SMDS_MeshNode* aNode,
- int Index,
- double u)
+void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode* aNode,
+ int Index,
+ double u)
{
//Set Position on Node
- if ( add( aNode, getSubmesh( Index )))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
+ if ( add( aNode, NewSubMesh( Index )))
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
}
//=======================================================================
//function : SetNodeOnVertex
//purpose :
//=======================================================================
-void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode* aNode, int Index)
+void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode* aNode, int Index)
{
//Set Position on Node
- if ( add( aNode, getSubmesh( Index )))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
+ if ( add( aNode, NewSubMesh( Index )))
+ const_cast< SMDS_MeshNode* >
+ ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
}
//=======================================================================
void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
int Index)
{
- add( anElement, getSubmesh( Index ));
+ add( anElement, NewSubMesh( Index ));
}
//=======================================================================
// myScript
delete myScript;
// submeshes
- TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
- for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
- delete i_sm->second;
+ delete mySubMeshHolder;
}
ID);
}
+//=======================================================================
+//function : AddFace
+//purpose :
+//=======================================================================
+SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
+ const SMDS_MeshNode * n2,
+ const SMDS_MeshNode * n3,
+ const SMDS_MeshNode * n12,
+ const SMDS_MeshNode * n23,
+ const SMDS_MeshNode * n31,
+ const SMDS_MeshNode * nCenter)
+{
+ SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31,nCenter);
+ if(anElem) myScript->AddFace(anElem->GetID(),
+ n1->GetID(), n2->GetID(), n3->GetID(),
+ n12->GetID(), n23->GetID(), n31->GetID(),
+ nCenter->GetID());
+ return anElem;
+}
+
+//=======================================================================
+//function : AddFaceWithID
+//purpose :
+//=======================================================================
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
+ int n12,int n23,int n31, int nCenter, int ID)
+{
+ SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
+ if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
+ return anElem;
+}
+
+//=======================================================================
+//function : AddFaceWithID
+//purpose :
+//=======================================================================
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
+ const SMDS_MeshNode * n2,
+ const SMDS_MeshNode * n3,
+ const SMDS_MeshNode * n12,
+ const SMDS_MeshNode * n23,
+ const SMDS_MeshNode * n31,
+ const SMDS_MeshNode * nCenter,
+ int ID)
+{
+ return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
+ n12->GetID(), n23->GetID(), n31->GetID(),
+ nCenter->GetID(), ID);
+}
+
//=======================================================================
//function : AddFace
int myCellsSize = myCells.size();
int newSmdsId = 0;
for (int i = 0; i < myCellsSize; i++)
+ {
+ if (myCells[i])
{
- if (myCells[i])
- {
- newSmdsId++; // SMDS id start to 1
- assert(newSmdsId <= newCellSize);
- newCells[newSmdsId] = myCells[i];
- newCells[newSmdsId]->setId(newSmdsId);
- //MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
- int idvtk = myCells[i]->getVtkId();
- //newSmdsToVtk[newSmdsId] = idvtk;
- assert(idvtk < newCellSize);
- newVtkToSmds[idvtk] = newSmdsId;
- }
+ newSmdsId++; // SMDS id start to 1
+ assert(newSmdsId <= newCellSize);
+ newCells[newSmdsId] = myCells[i];
+ newCells[newSmdsId]->setId(newSmdsId);
+ //MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
+ int idvtk = myCells[i]->getVtkId();
+ //newSmdsToVtk[newSmdsId] = idvtk;
+ assert(idvtk < newCellSize);
+ newVtkToSmds[idvtk] = newSmdsId;
}
+ }
myCells.swap(newCells);
//myCellIdSmdsToVtk.swap(newSmdsToVtk);
// --- compact list myNodes and myElements in submeshes
- map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.begin();
- for(; it != myShapeIndexToSubMesh.end(); ++it)
- {
- (*it).second->compactList();
- }
-
+ SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
+ while ( SMESHDS_SubMesh* sm = const_cast< SMESHDS_SubMesh* >( smIt->next() ))
+ sm->compactList();
}
void SMESHDS_Mesh::CleanDownWardConnectivity()
