Salome HOME
52457: Addition of hypotheses is 8 time longer than meshing.
authoreap <eap@opencascade.com>
Tue, 22 Jul 2014 12:40:10 +0000 (16:40 +0400)
committereap <eap@opencascade.com>
Tue, 22 Jul 2014 12:40:10 +0000 (16:40 +0400)
19 files changed:
src/DriverMED/DriverMED_Family.cxx
src/DriverMED/DriverMED_Family.h
src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx
src/DriverMED/DriverMED_W_SMESHDS_Mesh.h
src/SMESH/SMESH_Algo.cxx
src/SMESH/SMESH_Algo.hxx
src/SMESH/SMESH_Gen.cxx
src/SMESH/SMESH_HypoFilter.cxx
src/SMESH/SMESH_HypoFilter.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_Mesh.hxx
src/SMESH/SMESH_MeshEditor.cxx
src/SMESHDS/SMESHDS_Mesh.cxx
src/SMESHDS/SMESHDS_Mesh.hxx
src/SMESHDS/SMESHDS_TSubMeshHolder.hxx [new file with mode: 0644]
src/SMESH_I/SMESH_Gen_i.cxx
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
src/StdMeshers/StdMeshers_RadialQuadrangle_1D2D.cxx
src/StdMeshers/StdMeshers_Regular_1D.cxx

index 42f2f6a..2f9aceb 100644 (file)
@@ -145,7 +145,7 @@ DriverMED_Family
 //=============================================================================
 DriverMED_FamilyPtrList 
 DriverMED_Family
-::MakeFamilies(const SMESHDS_SubMeshPtrMap& theSubMeshes,
+::MakeFamilies(SMESHDS_SubMeshIteratorPtr      theSubMeshes,
                const SMESHDS_GroupBasePtrList& theGroups,
                const bool doGroupOfNodes,
                const bool doGroupOfEdges,
@@ -170,11 +170,10 @@ DriverMED_Family
   int aElemFamId = FIRST_ELEM_FAMILY;
 
   // Process sub-meshes
-  SMESHDS_SubMeshPtrMap::const_iterator aSMIter = theSubMeshes.begin();
-  for (; aSMIter != theSubMeshes.end(); aSMIter++)
+  while ( theSubMeshes->more() )
   {
-    const int anId = aSMIter->first;
-    SMESHDS_SubMesh* aSubMesh = aSMIter->second;
+    SMESHDS_SubMesh* aSubMesh = const_cast< SMESHDS_SubMesh* >( theSubMeshes->next() );
+    const int anId = aSubMesh->GetID();
     if ( aSubMesh->IsComplexSubmesh() )
       continue; // submesh containing other submeshs
     DriverMED_FamilyPtrList aSMFams = SplitByType(aSubMesh,anId);
index d774603..5a1c4d6 100644 (file)
@@ -69,7 +69,7 @@ class MESHDRIVERMED_EXPORT DriverMED_Family
   */
   static 
   DriverMED_FamilyPtrList
-  MakeFamilies (const SMESHDS_SubMeshPtrMap& theSubMeshes,
+  MakeFamilies (SMESHDS_SubMeshIteratorPtr      theSubMeshes,
                 const SMESHDS_GroupBasePtrList& theGroups,
                 const bool doGroupOfNodes,
                 const bool doGroupOfEdges,
index 47fa68b..aec74ad 100644 (file)
@@ -101,7 +101,7 @@ void DriverMED_W_SMESHDS_Mesh::AddAllSubMeshes()
 
 void DriverMED_W_SMESHDS_Mesh::AddSubMesh(SMESHDS_SubMesh* theSubMesh, int theID)
 {
-  mySubMeshes[theID] = theSubMesh;
+  mySubMeshes.push_back( theSubMesh );
 }
 
 void DriverMED_W_SMESHDS_Mesh::AddGroupOfNodes()
@@ -292,6 +292,20 @@ namespace
 //       return elem_famNum->second;
     return aDefaultFamilyId;
   }
+
+  //================================================================================
+  /*!
+   * \brief Returns iterator on sub-meshes
+   */
+  //================================================================================
+
+  SMESHDS_SubMeshIteratorPtr getIterator( std::vector<SMESHDS_SubMesh*>& mySubMeshes )
+  {
+    return SMESHDS_SubMeshIteratorPtr
+      ( new SMDS_SetIterator
+        < const SMESHDS_SubMesh*, std::vector< SMESHDS_SubMesh* >::iterator >( mySubMeshes.begin(),
+                                                                               mySubMeshes.end() ));
+  }
 }
 
 Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
@@ -435,7 +449,7 @@ Driver_Mesh::Status DriverMED_W_SMESHDS_Mesh::Perform()
          myDoGroupOfBalls   && nbBalls);
     } else {
       aFamilies = DriverMED_Family::MakeFamilies
-        (mySubMeshes, myGroups,
+        (getIterator( mySubMeshes ), myGroups,
          myDoGroupOfNodes   && nbNodes,
          myDoGroupOfEdges   && nbEdges,
          myDoGroupOfFaces   && nbFaces,
index d817c3f..4342d5d 100644 (file)
@@ -79,7 +79,7 @@ class MESHDRIVERMED_EXPORT DriverMED_W_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
   MED::EVersion myMedVersion;
   std::list<SMESHDS_GroupBase*> myGroups;
   bool myAllSubMeshes;
-  std::map<int,SMESHDS_SubMesh*> mySubMeshes;
+  std::vector<SMESHDS_SubMesh*> mySubMeshes;
   bool myDoGroupOfNodes;
   bool myDoGroupOfEdges;
   bool myDoGroupOfFaces;
index 0f41460..732c3e6 100644 (file)
@@ -178,6 +178,7 @@ const SMESH_Algo::Features& SMESH_Algo::GetFeatures( const std::string& algoType
 SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
   : SMESH_Hypothesis(hypId, studyId, gen)
 {
+  _compatibleAllHypFilter = _compatibleNoAuxHypFilter = NULL;
   _onlyUnaryInput = _requireDiscreteBoundary = _requireShape = true;
   _quadraticMesh = _supportSubmeshes = false;
   _error = COMPERR_OK;
@@ -193,6 +194,8 @@ SMESH_Algo::SMESH_Algo (int hypId, int studyId, SMESH_Gen * gen)
 
 SMESH_Algo::~SMESH_Algo()
 {
+  delete _compatibleNoAuxHypFilter;
+  // delete _compatibleAllHypFilter; -- _compatibleNoAuxHypFilter does it!!!
 }
 
 //=============================================================================
@@ -263,10 +266,9 @@ SMESH_Algo::GetUsedHypothesis(SMESH_Mesh &         aMesh,
 {
   SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
   me->_usedHypList.clear();
-  SMESH_HypoFilter filter;
-  if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary ))
+  if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
   {
-    aMesh.GetHypotheses( aShape, filter, me->_usedHypList, true );
+    aMesh.GetHypotheses( aShape, *filter, me->_usedHypList, true );
     if ( ignoreAuxiliary && _usedHypList.size() > 1 )
       me->_usedHypList.clear(); //only one compatible hypothesis allowed
   }
@@ -288,9 +290,8 @@ SMESH_Algo::GetAppliedHypothesis(SMESH_Mesh &         aMesh,
 {
   SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
   me->_appliedHypList.clear();
-  SMESH_HypoFilter filter;
-  if ( InitCompatibleHypoFilter( filter, ignoreAuxiliary ))
-    aMesh.GetHypotheses( aShape, filter, me->_appliedHypList, false );
+  if ( const SMESH_HypoFilter* filter = GetCompatibleHypoFilter( ignoreAuxiliary ))
+    aMesh.GetHypotheses( aShape, *filter, me->_appliedHypList, false );
 
   return _appliedHypList;
 }
@@ -457,27 +458,35 @@ bool SMESH_Algo::GetSortedNodesOnEdge(const SMESHDS_Mesh*                   theM
 
 //================================================================================
 /*!
- * \brief Make filter recognize only compatible hypotheses
- * \param theFilter - the filter to initialize
- * \param ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses
+ * \brief Returns the filter recognizing only compatible hypotheses
+ *  \param ignoreAuxiliary - make filter ignore auxiliary hypotheses
+ *  \retval SMESH_HypoFilter* - the filter that can be NULL
  */
 //================================================================================
 
-bool SMESH_Algo::InitCompatibleHypoFilter( SMESH_HypoFilter & theFilter,
-                                           const bool         ignoreAuxiliary) const
+const SMESH_HypoFilter*
+SMESH_Algo::GetCompatibleHypoFilter(const bool ignoreAuxiliary) const
 {
   if ( !_compatibleHypothesis.empty() )
   {
-    theFilter.Init( theFilter.HasName( _compatibleHypothesis[0] ));
-    for ( int i = 1; i < _compatibleHypothesis.size(); ++i )
-      theFilter.Or( theFilter.HasName( _compatibleHypothesis[ i ] ));
-
-    if ( ignoreAuxiliary )
-      theFilter.AndNot( theFilter.IsAuxiliary() );
-
-    return true;
+    if ( !_compatibleAllHypFilter )
+    {
+      SMESH_HypoFilter* filter = new SMESH_HypoFilter();
+      filter->Init( filter->HasName( _compatibleHypothesis[0] ));
+      for ( int i = 1; i < _compatibleHypothesis.size(); ++i )
+        filter->Or( filter->HasName( _compatibleHypothesis[ i ] ));
+
+      SMESH_HypoFilter* filterNoAux = new SMESH_HypoFilter( filter );
+      filterNoAux->AndNot( filterNoAux->IsAuxiliary() );
+
+      // _compatibleNoAuxHypFilter will detele _compatibleAllHypFilter!!!
+      SMESH_Algo* me = const_cast< SMESH_Algo* >( this );
+      me->_compatibleAllHypFilter   = filter;
+      me->_compatibleNoAuxHypFilter = filterNoAux;
+    }
+    return ignoreAuxiliary ? _compatibleNoAuxHypFilter : _compatibleAllHypFilter;
   }
-  return false;
+  return 0;
 }
 
 //================================================================================
index 8aeaf7b..348c34d 100644 (file)
@@ -218,13 +218,12 @@ class SMESH_EXPORT SMESH_Algo : public SMESH_Hypothesis
                        const TopoDS_Shape & aShape,
                        const bool           ignoreAuxiliary=true) const;
   /*!
-   * \brief Make the filter recognize only compatible hypotheses
-   * \param theFilter - the filter to initialize
-   * \param ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses
-   * \retval bool - true if the algo has compatible hypotheses
+   * \brief Returns the filter recognizing only compatible hypotheses
+   *  \param ignoreAuxiliary - make filter ignore compatible auxiliary hypotheses
+   *  \retval SMESH_HypoFilter* - the filter that can be NULL
    */
-  bool InitCompatibleHypoFilter( SMESH_HypoFilter & theFilter,
-                                 const bool         ignoreAuxiliary) const;
+  const SMESH_HypoFilter* GetCompatibleHypoFilter(const bool ignoreAuxiliary) const;
+
   /*!
    * \brief Just return false as the algorithm does not hold parameters values
    */
@@ -408,9 +407,12 @@ public:
 
 protected:
 
+  const SMESH_HypoFilter *              _compatibleAllHypFilter;
+  const SMESH_HypoFilter *              _compatibleNoAuxHypFilter;
   std::vector<std::string>              _compatibleHypothesis;
   std::list<const SMESHDS_Hypothesis *> _appliedHypList;
   std::list<const SMESHDS_Hypothesis *> _usedHypList;
+  
 
   // Algo features influencing which Compute() and how is called:
   // in what turn and with what input shape.
index c8ba34b..3acff67 100644 (file)
@@ -288,24 +288,24 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
     // Apply all-dimensional algorithms supporing sub-meshes
     // ======================================================
 
+    std::vector< SMESH_subMesh* > smVec;
     for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim )
     {
       // ------------------------------------------------
       // sort list of sub-meshes according to mesh order
       // ------------------------------------------------
-      aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes[ aShapeDim ] );
+      smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(),
+                    smWithAlgoSupportingSubmeshes[ aShapeDim ].end() );
+      aMesh.SortByMeshOrder( smVec );
 
       // ------------------------------------------------------------
       // compute sub-meshes with local uni-dimensional algos under
       // sub-meshes with all-dimensional algos
       // ------------------------------------------------------------
-      list< SMESH_subMesh* >::iterator subIt, subEnd;
-      subIt  = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin();
-      subEnd = smWithAlgoSupportingSubmeshes[ aShapeDim ].end();
       // start from lower shapes
-      for ( ; subIt != subEnd; ++subIt )
+      for ( size_t i = 0; i < smVec.size(); ++i )
       {
-        sm = *subIt;
+        sm = smVec[i];
 
         // get a shape the algo is assigned to
         if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
@@ -343,10 +343,9 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
       // --------------------------------
       // apply the all-dimensional algos
       // --------------------------------
-      subIt  = smWithAlgoSupportingSubmeshes[ aShapeDim ].begin();
-      for ( ; subIt != subEnd; ++subIt )
+      for ( size_t i = 0; i < smVec.size(); ++i )
       {
-        sm = *subIt;
+        sm = smVec[i];
         if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
         {
           const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
@@ -494,18 +493,18 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
     // ------------------------------------------------------------
     // sort list of meshes according to mesh order
     // ------------------------------------------------------------
-    aMesh.SortByMeshOrder( smWithAlgoSupportingSubmeshes );
+    std::vector< SMESH_subMesh* > smVec( smWithAlgoSupportingSubmeshes.begin(),
+                                         smWithAlgoSupportingSubmeshes.end() );
+    aMesh.SortByMeshOrder( smVec );
 
     // ------------------------------------------------------------
     // compute sub-meshes under shapes with algos that DO NOT require
     // Discreteized boundaries and DO support sub-meshes
     // ------------------------------------------------------------
-    list< SMESH_subMesh* >::iterator subIt, subEnd;
-    subIt  = smWithAlgoSupportingSubmeshes.begin();
-    subEnd = smWithAlgoSupportingSubmeshes.end();
     // start from lower shapes
-    for ( ; subIt != subEnd; ++subIt ) {
-      sm = *subIt;
+    for ( size_t i = 0; i < smVec.size(); ++i )
+    {
+      sm = smVec[i];
 
       // get a shape the algo is assigned to
       TopoDS_Shape algoShape;
@@ -538,9 +537,9 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
     // ----------------------------------------------------------
     // apply the algos that do not require Discreteized boundaries
     // ----------------------------------------------------------
-    for ( subIt = smWithAlgoSupportingSubmeshes.begin(); subIt != subEnd; ++subIt )
+    for ( size_t i = 0; i < smVec.size(); ++i )
     {
-      sm = *subIt;
+      sm = smVec[i];
       sm->Evaluate(aResMap);
       if ( aShapesId )
         aShapesId->insert( sm->GetId() );
index e19fd11..e5d1670 100644 (file)
@@ -185,6 +185,7 @@ bool SMESH_HypoFilter::IsMoreLocalThanPredicate::IsOk(const SMESH_Hypothesis* aH
 //=======================================================================
 
 SMESH_HypoFilter::SMESH_HypoFilter()
+  : myNbPredicates(0)
 {
 }
 
@@ -194,6 +195,7 @@ SMESH_HypoFilter::SMESH_HypoFilter()
 //=======================================================================
 
 SMESH_HypoFilter::SMESH_HypoFilter( SMESH_HypoPredicate* aPredicate, bool notNegate )
+  : myNbPredicates(0)
 {
   add( notNegate ? AND : AND_NOT, aPredicate );
 }
@@ -352,15 +354,14 @@ SMESH_HypoPredicate* SMESH_HypoFilter::HasType(const int theHypType)
 bool SMESH_HypoFilter::IsOk (const SMESH_Hypothesis* aHyp,
                              const TopoDS_Shape&     aShape) const
 {
-  if ( myPredicates.empty() )
+  if ( IsEmpty() )
     return true;
 
-  bool ok = ( myPredicates.front()->_logical_op <= AND_NOT );
-  list<SMESH_HypoPredicate*>::const_iterator pred = myPredicates.begin();
-  for ( ; pred != myPredicates.end(); ++pred )
+  bool ok = ( myPredicates[0]->_logical_op <= AND_NOT );
+  for ( int i = 0; i < myNbPredicates; ++i )
   {
-    bool ok2 = (*pred)->IsOk( aHyp, aShape );
-    switch ( (*pred)->_logical_op ) {
+    bool ok2 = myPredicates[i]->IsOk( aHyp, aShape );
+    switch ( myPredicates[i]->_logical_op ) {
     case AND:     ok = ok && ok2; break;
     case AND_NOT: ok = ok && !ok2; break;
     case OR:      ok = ok || ok2; break;
@@ -378,10 +379,11 @@ bool SMESH_HypoFilter::IsOk (const SMESH_Hypothesis* aHyp,
 
 SMESH_HypoFilter & SMESH_HypoFilter::Init  ( SMESH_HypoPredicate* aPredicate, bool notNegate )
 {
-  list<SMESH_HypoPredicate*>::const_iterator pred = myPredicates.begin();
-  for ( ; pred != myPredicates.end(); ++pred )
+  SMESH_HypoPredicate** pred = &myPredicates[0];
+  SMESH_HypoPredicate** end  = &myPredicates[myNbPredicates];
+  for ( ; pred != end; ++pred )
     delete *pred;
-  myPredicates.clear();
+  myNbPredicates = 0;
 
   add( notNegate ? AND : AND_NOT, aPredicate );
   return *this;
@@ -395,7 +397,11 @@ SMESH_HypoFilter & SMESH_HypoFilter::Init  ( SMESH_HypoPredicate* aPredicate, bo
 
 SMESH_HypoFilter::~SMESH_HypoFilter()
 {
-  Init(0);
+  SMESH_HypoPredicate** pred = &myPredicates[0];
+  SMESH_HypoPredicate** end  = &myPredicates[myNbPredicates];
+  for ( ; pred != end; ++pred )
+    delete *pred;
+  myNbPredicates = 0;
 }
 
 
index 6ac97e6..7a9c47d 100644 (file)
@@ -59,7 +59,7 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
   // Create and add predicates.
   // Added predicates will be destroyed by filter when it dies
   SMESH_HypoFilter();
-  SMESH_HypoFilter( SMESH_HypoPredicate* aPredicate, bool notNegate = true );
+  explicit SMESH_HypoFilter( SMESH_HypoPredicate* aPredicate, bool notNegate = true );
   // notNegate==false means !aPredicate->IsOk()
   SMESH_HypoFilter & Init  ( SMESH_HypoPredicate* aPredicate, bool notNegate = true );
   SMESH_HypoFilter & And   ( SMESH_HypoPredicate* aPredicate );
@@ -80,7 +80,7 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
   static SMESH_HypoPredicate* HasDim(const int theDim);
   static SMESH_HypoPredicate* HasType(const int theHypType);
 
-  bool IsEmpty() const { return myPredicates.empty(); }
+  bool IsEmpty() const { return myNbPredicates == 0; }
 
   /*!
    * \brief check aHyp or/and aShape it is assigned to
@@ -90,7 +90,7 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
   /*!
    * \brief return true if contains no predicates
    */
-  bool IsAny() const { return myPredicates.empty(); }
+  bool IsAny() const { return myNbPredicates > 0; }
 
   ~SMESH_HypoFilter();
 
@@ -98,7 +98,9 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
  protected:
   // fields
 
-  std::list<SMESH_HypoPredicate*> myPredicates;
+  //std::list<SMESH_HypoPredicate*> myPredicates;
+  SMESH_HypoPredicate* myPredicates[100];
+  int                  myNbPredicates;
 
   // private methods
 
@@ -111,7 +113,7 @@ class SMESH_EXPORT SMESH_HypoFilter: public SMESH_HypoPredicate
   {
     if ( pred ) {
       pred->_logical_op = bool_op;
-      myPredicates.push_back( pred );
+      myPredicates[ myNbPredicates++ ] = pred;
     }
   }
 
index 6d4db5d..a7c20a0 100644 (file)
 //
 #include "SMESH_Mesh.hxx"
 #include "SMESH_MesherHelper.hxx"
-#include "SMESH_subMesh.hxx"
+#include "SMDS_MeshVolume.hxx"
+#include "SMDS_SetIterator.hxx"
+#include "SMESHDS_Document.hxx"
+#include "SMESHDS_Group.hxx"
+#include "SMESHDS_GroupOnGeom.hxx"
+#include "SMESHDS_Script.hxx"
+#include "SMESHDS_TSubMeshHolder.hxx"
 #include "SMESH_Gen.hxx"
-#include "SMESH_Hypothesis.hxx"
 #include "SMESH_Group.hxx"
 #include "SMESH_HypoFilter.hxx"
-#include "SMESHDS_Group.hxx"
-#include "SMESHDS_Script.hxx"
-#include "SMESHDS_GroupOnGeom.hxx"
-#include "SMESHDS_Document.hxx"
-#include "SMDS_MeshVolume.hxx"
-#include "SMDS_SetIterator.hxx"
+#include "SMESH_Hypothesis.hxx"
+#include "SMESH_subMesh.hxx"
 
 #include "utilities.h"
 
@@ -91,6 +92,10 @@ static int MYDEBUG = 0;
 
 typedef SMESH_HypoFilter THypType;
 
+class SMESH_Mesh::SubMeshHolder : public SMESHDS_TSubMeshHolder< SMESH_subMesh >
+{
+};
+
 //=============================================================================
 /*!
  * 
@@ -116,6 +121,7 @@ SMESH_Mesh::SMESH_Mesh(int               theLocalId,
   _shapeDiagonal = 0.0;
   _callUp        = NULL;
   _myMeshDS->ShapeToMesh( PseudoShape() );
+  _subMeshHolder = new SubMeshHolder;
 }
 
 //================================================================================
@@ -138,6 +144,7 @@ SMESH_Mesh::SMESH_Mesh():
   _shapeDiagonal( 0.0 ),
   _callUp( 0 )
 {
+  _subMeshHolder = new SubMeshHolder;
 }
 
 namespace
@@ -185,13 +192,7 @@ SMESH_Mesh::~SMESH_Mesh()
   _mapGroup.clear();
 
   // delete sub-meshes
-  map <int, SMESH_subMesh*>::iterator sm = _mapSubMesh.begin();
-  for ( ; sm != _mapSubMesh.end(); ++sm )
-  {
-    delete sm->second;
-    sm->second = 0;
-  }
-  _mapSubMesh.clear();
+  delete _subMeshHolder;
 
   if ( _callUp) delete _callUp;
   _callUp = 0;
@@ -248,10 +249,7 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
   {
     // removal of a shape to mesh, delete objects referring to sub-shapes:
     // - sub-meshes
-    map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
-    for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
-      delete i_sm->second;
-    _mapSubMesh.clear();
+    _subMeshHolder->DeleteAll();
     //  - groups on geometry
     map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
     while ( i_gr != _mapGroup.end() ) {
@@ -756,7 +754,6 @@ const list<const SMESHDS_Hypothesis*>&
 SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
   throw(SALOME_Exception)
 {
-  Unexpect aCatch(SalomeException);
   return _myMeshDS->GetHypothesis(aSubShape);
 }
 
@@ -790,9 +787,9 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape &    aSubS
   if ( andAncestors )
   {
     // user sorted submeshes of ancestors, according to stored submesh priority
-    const list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
-    list<SMESH_subMesh*>::const_iterator smIt = smList.begin(); 
-    for ( ; smIt != smList.end(); smIt++ )
+    getAncestorsSubMeshes( aSubShape, _ancestorSubMeshes );
+    vector<SMESH_subMesh*>::const_iterator smIt = _ancestorSubMeshes.begin(); 
+    for ( ; smIt != _ancestorSubMeshes.end(); smIt++ )
     {
       const TopoDS_Shape& curSh = (*smIt)->GetSubShape();
       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
@@ -863,18 +860,18 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape &                aSubShape,
     TopTools_MapOfShape map;
 
     // user sorted submeshes of ancestors, according to stored submesh priority
-    const list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
-    list<SMESH_subMesh*>::const_iterator smIt = smList.begin(); 
-    for ( ; smIt != smList.end(); smIt++ )
+    getAncestorsSubMeshes( aSubShape, _ancestorSubMeshes );
+    vector<SMESH_subMesh*>::const_iterator smIt = _ancestorSubMeshes.begin();
+    for ( ; smIt != _ancestorSubMeshes.end(); smIt++ )
     {
       const TopoDS_Shape& curSh = (*smIt)->GetSubShape();
-     if ( !map.Add( curSh ))
+      if ( !map.Add( curSh ))
         continue;
       const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
       for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
-        if (aFilter.IsOk( cSMESH_Hyp( *hyp ), curSh ) &&
+        if (( aFilter.IsOk( cSMESH_Hyp( *hyp ), curSh ))         &&
             ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
-            hypTypes.insert( (*hyp)->GetName() ).second )
+            ( hypTypes.insert( (*hyp)->GetName() ).second          ))
         {
           aHypList.push_back( *hyp );
           nbHyps++;
@@ -937,8 +934,6 @@ void SMESH_Mesh::ClearLog() throw(SALOME_Exception)
 SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
   throw(SALOME_Exception)
 {
-  Unexpect aCatch(SalomeException);
-  SMESH_subMesh *aSubMesh;
   int index = _myMeshDS->ShapeToIndex(aSubShape);
 
   // for submeshes on GEOM Group
@@ -955,15 +950,11 @@ SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
 //   if ( !index )
 //     return NULL; // neither sub-shape nor a group
 
-  map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.find(index);
-  if ( i_sm != _mapSubMesh.end())
-  {
-    aSubMesh = i_sm->second;
-  }
-  else
+  SMESH_subMesh* aSubMesh = _subMeshHolder->Get( index );
+  if ( !aSubMesh )
   {
     aSubMesh = new SMESH_subMesh(index, this, _myMeshDS, aSubShape);
-    _mapSubMesh[index] = aSubMesh;
+    _subMeshHolder->Add( index, aSubMesh );
   }
   return aSubMesh;
 }
@@ -978,17 +969,10 @@ SMESH_subMesh *SMESH_Mesh::GetSubMesh(const TopoDS_Shape & aSubShape)
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape) const
   throw(SALOME_Exception)
 {
-  Unexpect aCatch(SalomeException);
-  SMESH_subMesh *aSubMesh = NULL;
-  
   int index = _myMeshDS->ShapeToIndex(aSubShape);
-
-  map <int, SMESH_subMesh *>::const_iterator i_sm = _mapSubMesh.find(index);
-  if ( i_sm != _mapSubMesh.end())
-    aSubMesh = i_sm->second;
-
-  return aSubMesh;
+  return GetSubMeshContaining( index );
 }
+
 //=============================================================================
 /*!
  * Get the SMESH_subMesh object implementation. Dont create it, return null
@@ -999,13 +983,11 @@ SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const TopoDS_Shape & aSubShape)
 SMESH_subMesh *SMESH_Mesh::GetSubMeshContaining(const int aShapeID) const
 throw(SALOME_Exception)
 {
-  Unexpect aCatch(SalomeException);
-  
-  map <int, SMESH_subMesh *>::const_iterator i_sm = _mapSubMesh.find(aShapeID);
-  if (i_sm == _mapSubMesh.end())
-    return NULL;
-  return i_sm->second;
+  SMESH_subMesh *aSubMesh = _subMeshHolder->Get( aShapeID );
+
+  return aSubMesh;
 }
+
 //================================================================================
 /*!
  * \brief Return submeshes of groups containing the given sub-shape
@@ -1016,7 +998,6 @@ list<SMESH_subMesh*>
 SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
   throw(SALOME_Exception)
 {
-  Unexpect aCatch(SalomeException);
   list<SMESH_subMesh*> found;
 
   SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape);
@@ -1024,13 +1005,14 @@ SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
     return found;
 
   // submeshes of groups have max IDs, so search from the map end
-  map<int, SMESH_subMesh *>::const_reverse_iterator i_sm;
-  for ( i_sm = _mapSubMesh.rbegin(); i_sm != _mapSubMesh.rend(); ++i_sm) {
-    SMESHDS_SubMesh * ds = i_sm->second->GetSubMeshDS();
+SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator( /*reverse=*/true ) );
+  while ( smIt->more() ) {
+    SMESH_subMesh*    sm = smIt->next();
+    SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
     if ( ds && ds->IsComplexSubmesh() ) {
-      if ( SMESH_MesherHelper::IsSubShape( aSubShape, i_sm->second->GetSubShape() ))
+      if ( SMESH_MesherHelper::IsSubShape( aSubShape, sm->GetSubShape() ))
       {
-        found.push_back( i_sm->second );
+        found.push_back( sm );
         //break;
       }
     } else {
@@ -1040,7 +1022,7 @@ SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
 
   if ( found.empty() ) // maybe the main shape is a COMPOUND (issue 0021530)
   {
-    if ( SMESH_subMesh * mainSM = GetSubMeshContaining(1))
+    if ( SMESH_subMesh * mainSM = GetSubMeshContaining(1) )
       if ( mainSM->GetSubShape().ShapeType() == TopAbs_COMPOUND )
       {
         TopoDS_Iterator it( mainSM->GetSubShape() );
@@ -1077,17 +1059,15 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
   if (algo)
   {
     // look trough hypotheses used by algo
-    SMESH_HypoFilter hypoKind;
-    if ( algo->InitCompatibleHypoFilter( hypoKind, !hyp->IsAuxiliary() )) {
+    const SMESH_HypoFilter* hypoKind;
+    if (( hypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() ))) {
       list <const SMESHDS_Hypothesis * > usedHyps;
-      if ( GetHypotheses( aSubShape, hypoKind, usedHyps, true ))
+      if ( GetHypotheses( aSubShape, *hypoKind, usedHyps, true ))
         return ( find( usedHyps.begin(), usedHyps.end(), anHyp ) != usedHyps.end() );
     }
   }
 
-  // look through all assigned hypotheses
-  //SMESH_HypoFilter filter( SMESH_HypoFilter::Is( hyp ));
-  return false; //GetHypothesis( aSubShape, filter, true );
+  return false;
 }
 
 //=============================================================================
@@ -1096,22 +1076,20 @@ bool SMESH_Mesh::IsUsedHypothesis(SMESHDS_Hypothesis * anHyp,
  */
 //=============================================================================
 
-const list < SMESH_subMesh * >&
-SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
-  throw(SALOME_Exception)
-{
-  Unexpect aCatch(SalomeException);
-  if(MYDEBUG) MESSAGE("SMESH_Mesh::GetSubMeshUsingHypothesis");
-  map < int, SMESH_subMesh * >::iterator itsm;
-  _subMeshesUsingHypothesisList.clear();
-  for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
-  {
-    SMESH_subMesh *aSubMesh = (*itsm).second;
-    if ( IsUsedHypothesis ( anHyp, aSubMesh ))
-      _subMeshesUsingHypothesisList.push_back(aSubMesh);
-  }
-  return _subMeshesUsingHypothesisList;
-}
+// const list < SMESH_subMesh * >&
+// SMESH_Mesh::GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp)
+//   throw(SALOME_Exception)
+// {
+//   _subMeshesUsingHypothesisList.clear();
+//   SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator() );
+//   while ( smIt->more() )
+//   {
+//     SMESH_subMesh* aSubMesh = smIt->next();
+//     if ( IsUsedHypothesis ( anHyp, aSubMesh ))
+//       _subMeshesUsingHypothesisList.push_back( aSubMesh );
+//   }
+//   return _subMeshesUsingHypothesisList;
+// }
 
 //=======================================================================
 //function : NotifySubMeshesHypothesisModification
@@ -1128,45 +1106,39 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h
   if (_callUp)
     _callUp->HypothesisModified();
 
-  const SMESH_Algo *foundAlgo = 0;
-  SMESH_HypoFilter algoKind, compatibleHypoKind;
+  SMESH_Algo *algo;
+  const SMESH_HypoFilter* compatibleHypoKind;
   list <const SMESHDS_Hypothesis * > usedHyps;
 
-
-  map < int, SMESH_subMesh * >::iterator itsm;
-  for (itsm = _mapSubMesh.begin(); itsm != _mapSubMesh.end(); itsm++)
+  SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator() );
+  while ( smIt->more() )
   {
-    SMESH_subMesh *aSubMesh = (*itsm).second;
-    if ( aSubMesh->IsApplicableHypotesis( hyp ))
+    SMESH_subMesh* aSubMesh = smIt->next();
+
+    // if aSubMesh meshing depends on hyp,
+    // we call aSubMesh->AlgoStateEngine( MODIF_HYP, hyp ) that causes either
+    // 1) clearing of already computed aSubMesh or
+    // 2) changing algo_state from MISSING_HYP to HYP_OK when parameters of hyp becomes valid,
+    // other possible changes are not interesting. (IPAL0052457 - assigning hyp performance pb)
+    if ( aSubMesh->GetComputeState() != SMESH_subMesh::COMPUTE_OK &&
+         aSubMesh->GetComputeState() != SMESH_subMesh::FAILED_TO_COMPUTE &&
+         aSubMesh->GetAlgoState()    != SMESH_subMesh::MISSING_HYP )
+      continue;
+
+    const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape();
+
+    if (( aSubMesh->IsApplicableHypotesis( hyp )) &&
+        ( algo = aSubMesh->GetAlgo() )            &&
+        ( compatibleHypoKind = algo->GetCompatibleHypoFilter( !hyp->IsAuxiliary() )) &&
+        ( compatibleHypoKind->IsOk( hyp, aSubShape )))
     {
-      const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape();
-
-      if ( !foundAlgo ) // init filter for algo search
-        algoKind.Init( THypType::IsAlgo() ).And( THypType::IsApplicableTo( aSubShape ));
-      
-      const SMESH_Algo *algo = static_cast<const SMESH_Algo*>
-        ( GetHypothesis( aSubShape, algoKind, true ));
-
-      if ( algo )
+      // check if hyp is used by algo
+      usedHyps.clear();
+      if ( GetHypotheses( aSubShape, *compatibleHypoKind, usedHyps, true ) &&
+           find( usedHyps.begin(), usedHyps.end(), hyp ) != usedHyps.end() )
       {
-        bool sameAlgo = ( algo == foundAlgo );
-        if ( !sameAlgo && foundAlgo )
-          sameAlgo = ( strcmp( algo->GetName(), foundAlgo->GetName() ) == 0);
-
-        if ( !sameAlgo ) { // init filter for used hypos search
-          if ( !algo->InitCompatibleHypoFilter( compatibleHypoKind, !hyp->IsAuxiliary() ))
-            continue; // algo does not use any hypothesis
-          foundAlgo = algo;
-        }
-
-        // check if hyp is used by algo
-        usedHyps.clear();
-        if ( GetHypotheses( aSubShape, compatibleHypoKind, usedHyps, true ) &&
-             find( usedHyps.begin(), usedHyps.end(), hyp ) != usedHyps.end() )
-        {
-          aSubMesh->AlgoStateEngine(SMESH_subMesh::MODIF_HYP,
-                                    const_cast< SMESH_Hypothesis*>( hyp ));
-        }
+        aSubMesh->AlgoStateEngine(SMESH_subMesh::MODIF_HYP,
+                                  const_cast< SMESH_Hypothesis*>( hyp ));
       }
     }
   }
@@ -1221,21 +1193,23 @@ bool SMESH_Mesh::HasModificationsToDiscard() const
   // return true if the next Compute() will be partial and
   // existing but changed elements may prevent successful re-compute
   bool hasComputed = false, hasNotComputed = false;
-  map <int, SMESH_subMesh*>::const_iterator i_sm = _mapSubMesh.begin();
-  for ( ; i_sm != _mapSubMesh.end() ; ++i_sm )
-    switch ( i_sm->second->GetSubShape().ShapeType() )
+SMESH_subMeshIteratorPtr smIt( _subMeshHolder->GetIterator() );
+  while ( smIt->more() )
+  {
+    const SMESH_subMesh* aSubMesh = smIt->next();
+    switch ( aSubMesh->GetSubShape().ShapeType() )
     {
     case TopAbs_EDGE:
     case TopAbs_FACE:
     case TopAbs_SOLID:
-      if ( i_sm->second->IsMeshComputed() )
+      if ( aSubMesh->IsMeshComputed() )
         hasComputed = true;
       else
         hasNotComputed = true;
       if ( hasComputed && hasNotComputed)
         return true;
     }
-
+  }
   if ( NbNodes() < 1 )
     const_cast<SMESH_Mesh*>(this)->_isModified = false;
 
@@ -2147,7 +2121,6 @@ const TListOfListOfInt& SMESH_Mesh::GetMeshOrder() const
 
 void SMESH_Mesh::fillAncestorsMap(const TopoDS_Shape& theShape)
 {
-
   int desType, ancType;
   if ( !theShape.IsSame( GetShapeToMesh()) && theShape.ShapeType() == TopAbs_COMPOUND )
   {
@@ -2193,16 +2166,16 @@ void SMESH_Mesh::fillAncestorsMap(const TopoDS_Shape& theShape)
  */
 //=============================================================================
 
-bool SMESH_Mesh::SortByMeshOrder(list<SMESH_subMesh*>& theListToSort) const
+ bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) const
 {
   if ( !_mySubMeshOrder.size() || theListToSort.size() < 2)
     return true;
   
   bool res = false;
-  list<SMESH_subMesh*> onlyOrderedList;
+  vector<SMESH_subMesh*> onlyOrderedList;
   // collect all ordered submeshes in one list as pointers
   // and get their positions within theListToSort
-  typedef list<SMESH_subMesh*>::iterator TPosInList;
+  typedef vector<SMESH_subMesh*>::iterator TPosInList;
   map< int, TPosInList > sortedPos;
   TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end();
   TListOfListOfInt::const_iterator listIdsIt = _mySubMeshOrder.begin();
@@ -2244,8 +2217,8 @@ bool SMESH_Mesh::SortByMeshOrder(list<SMESH_subMesh*>& theListToSort) const
     return res;
   res = true;
 
-  list<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
-  list<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
+  vector<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
+  vector<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
 
   // iterate on ordered submeshes and insert them in detected positions
   map< int, TPosInList >::iterator i_pos = sortedPos.begin();
@@ -2287,17 +2260,15 @@ bool SMESH_Mesh::IsOrderOK( const SMESH_subMesh* smBefore,
  */
 //=============================================================================
 
-list<SMESH_subMesh*>
-SMESH_Mesh::getAncestorsSubMeshes (const TopoDS_Shape& theSubShape) const
+void SMESH_Mesh::getAncestorsSubMeshes (const TopoDS_Shape&            theSubShape,
+                                        std::vector< SMESH_subMesh* >& theSubMeshes) const
 {
-  list<SMESH_subMesh*> listOfSubMesh;
+  theSubMeshes.clear();
   TopTools_ListIteratorOfListOfShape it( GetAncestors( theSubShape ));
   for (; it.More(); it.Next() )
     if ( SMESH_subMesh* sm = GetSubMeshContaining( it.Value() ))
-      listOfSubMesh.push_back(sm);
+      theSubMeshes.push_back(sm);
 
   // sort submeshes according to stored mesh order
-  SortByMeshOrder( listOfSubMesh );
-
-  return listOfSubMesh;
+  SortByMeshOrder( theSubMeshes );
 }
index 1981887..84086a3 100644 (file)
@@ -182,8 +182,8 @@ public:
    */
   void NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* theChangedHyp);
 
-  const std::list < SMESH_subMesh * >&
-  GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) throw(SALOME_Exception);
+  // const std::list < SMESH_subMesh * >&
+  // GetSubMeshUsingHypothesis(SMESHDS_Hypothesis * anHyp) throw(SALOME_Exception);
   /*!
    * \brief Return True if anHyp is used to mesh aSubShape
    */
@@ -322,7 +322,7 @@ public:
   const TListOfListOfInt& GetMeshOrder() const;
 
   // sort submeshes according to stored mesh order
-  bool SortByMeshOrder(std::list<SMESH_subMesh*>& theListToSort) const;
+  bool SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) const;
 
   // return true if given order of sub-meshes is OK
   bool IsOrderOK( const SMESH_subMesh* smBefore,
@@ -333,8 +333,8 @@ public:
 private:
 
   void fillAncestorsMap(const TopoDS_Shape& theShape);
-  std::list<SMESH_subMesh*> getAncestorsSubMeshes
-    (const TopoDS_Shape& theSubShape) const;
+  void getAncestorsSubMeshes(const TopoDS_Shape&            theSubShape,
+                             std::vector< SMESH_subMesh* >& theSubMeshes) const;
   
 protected:
   int                        _id;           // id given by creator (unique within the creator instance)
@@ -342,12 +342,14 @@ protected:
   int                        _groupId;      // id generator for group objects
   int                        _nbSubShapes;  // initial nb of subshapes in the shape to mesh
   bool                       _isShapeToMesh;// set to true when a shape is given (only once)
-  std::list <SMESH_subMesh*> _subMeshesUsingHypothesisList;
+  //std::list <SMESH_subMesh*> _subMeshesUsingHypothesisList;
   SMESHDS_Document *         _myDocument;
   SMESHDS_Mesh *             _myMeshDS;
   SMESH_Gen *                _gen;
-  std::map <int, SMESH_subMesh*> _mapSubMesh;
-  std::map <int, SMESH_Group*>   _mapGroup;
+  std::map <int, SMESH_Group*> _mapGroup;
+
+  class SubMeshHolder;
+  SubMeshHolder*             _subMeshHolder;
   
   bool                       _isAutoColor;
   bool                       _isModified; //!< modified since last total re-compute, issue 0020693
@@ -356,11 +358,13 @@ protected:
   
   TopTools_IndexedDataMapOfShapeListOfShape _mapAncestors;
 
+  mutable std::vector<SMESH_subMesh*> _ancestorSubMeshes; // to speed up GetHypothes[ei]s()
+
   TListOfListOfInt           _mySubMeshOrder;
 
   // Struct calling methods at CORBA API implementation level, used to
-  // 1) make an upper level be consistent with a lower one when group removal
-  // is invoked by hyp modification (issue 0020918)
+  // 1) make an upper level (SMESH_I) be consistent with a lower one (SMESH)
+  // when group removal is invoked by hyp modification (issue 0020918)
   // 2) to forget not loaded mesh data at hyp modification
   TCallUp*                    _callUp;
 
index 1cf9b4f..6bdd80c 100644 (file)
@@ -518,14 +518,12 @@ int SMESH_MeshEditor::FindShape (const SMDS_MeshElement * theElem)
   }
   else
   {
-    const map<int,SMESHDS_SubMesh*>& id2sm = GetMeshDS()->SubMeshes();
-    map<int,SMESHDS_SubMesh*>::const_iterator id_sm = id2sm.begin();
-    for ( ; id_sm != id2sm.end(); ++id_sm )
-      if ( id_sm->second->Contains( theElem ))
-        return id_sm->first;
+    SMESHDS_SubMeshIteratorPtr smIt = GetMeshDS()->SubMeshes();
+    while ( const SMESHDS_SubMesh* sm = smIt->next() )
+      if ( sm->Contains( theElem ))
+        return sm->GetID();
   }
 
-  //MESSAGE ("::FindShape() - SHAPE NOT FOUND")
   return 0;
 }
 
index 6766fbd..ff1da64 100644 (file)
 //
 #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);
 }
 
@@ -107,19 +111,17 @@ void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
     // - 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();
@@ -145,12 +147,12 @@ void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
 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 );
@@ -169,9 +171,9 @@ bool SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape & SS,
 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())
     {
@@ -790,7 +792,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
 //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)
@@ -821,18 +823,17 @@ static void removeFromContainers (map<int,SMESHDS_SubMesh*>&     theSubMeshes,
 
   // 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 );
     }
   }
@@ -840,36 +841,34 @@ static void removeFromContainers (map<int,SMESHDS_SubMesh*>&     theSubMeshes,
 
 //=======================================================================
 //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;
-
+    SMESHDS_SubMesh* subMesh = MeshElements( n->getshapeId() );
+    SMESHDS_SubMeshIteratorPtr subIt;
+    if ( !subMesh )
+      subIt = SubMeshes();
+    for ( ; !subMesh && subIt->more(); ) {
+      subMesh = const_cast< SMESHDS_SubMesh* >( subIt->next() );
+      if ( subMesh->IsComplexSubmesh() || !subMesh->Contains( n ))
+        subMesh = 0;
+    }
     RemoveFreeNode( n, subMesh, 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 );
 }
 
 //=======================================================================
@@ -917,11 +916,8 @@ void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
   {
     SMESHDS_SubMesh* subMesh=0;
     if ( elt->getshapeId() > 0 )
-    {
-      map<int,SMESHDS_SubMesh*>::iterator SubIt = myShapeIndexToSubMesh.find( elt->getshapeId() );
-      if ( SubIt != myShapeIndexToSubMesh.end() )
-        subMesh = SubIt->second;
-    }
+      subMesh = MeshElements( elt->getshapeId() );
+
     RemoveFreeElement( elt, subMesh, true);
     return;
   }
@@ -933,7 +929,7 @@ void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
 
   SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes, false);
   
-  removeFromContainers( myShapeIndexToSubMesh, myGroups, removedElems, false );
+  removeFromContainers( this, myGroups, removedElems, false );
 }
 
 //=======================================================================
@@ -987,9 +983,9 @@ void SMESHDS_Mesh::ClearMesh()
   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();
@@ -1011,8 +1007,6 @@ void SMESHDS_Mesh::ClearMesh()
  * \brief return submesh by shape
   * \param shape - the sub-shape
   * \retval SMESHDS_SubMesh* - the found submesh
-  *
- * search of submeshes is optimized
  */
 //================================================================================
 
@@ -1021,35 +1015,7 @@ SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const TopoDS_Shape & shape )
   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 ));
 }
 
 //================================================================================
@@ -1142,12 +1108,9 @@ void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode *       aNode,
 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);
 }
 
 //=======================================================================
@@ -1167,16 +1130,13 @@ void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement * anElement,
 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);
+  }
 }
 
 //=======================================================================
@@ -1185,7 +1145,7 @@ void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
 //=======================================================================
 TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() const
 {
-        return myShape;
+  return myShape;
 }
 
 //=======================================================================
@@ -1213,11 +1173,7 @@ bool SMESHDS_Mesh::IsGroupOfSubShapes (const TopoDS_Shape& theShape) const
 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 );
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1225,11 +1181,7 @@ SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const TopoDS_Shape & S) const
 ///////////////////////////////////////////////////////////////////////////////
 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 ));
 }
 
 //=======================================================================
@@ -1239,14 +1191,24 @@ SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
 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  : 
 //=======================================================================
@@ -1254,8 +1216,8 @@ list<int> SMESHDS_Mesh::SubMeshIndices() const
 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;
@@ -1300,9 +1262,8 @@ void SMESHDS_Mesh::ClearScript()
 //=======================================================================
 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 );
 }
 
 //=======================================================================
@@ -1311,7 +1272,7 @@ bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
 //=======================================================================
 bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
 {
-  return myShapeToHypothesis.IsBound(S.Oriented(TopAbs_FORWARD));
+  return myShapeToHypothesis.IsBound(S/*.Oriented(TopAbs_FORWARD)*/);
 }
 
 //=======================================================================
@@ -1320,15 +1281,12 @@ bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
 //=======================================================================
 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;
 }
 
@@ -1394,7 +1352,7 @@ const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
 
 int SMESHDS_Mesh::MaxSubMeshIndex() const
 {
-  return myShapeIndexToSubMesh.empty() ? 0 : myShapeIndexToSubMesh.rbegin()->first;
+  return mySubMeshHolder->GetMaxID();
 }
 
 //=======================================================================
@@ -1417,8 +1375,7 @@ int SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape & S) const
 //=======================================================================
 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());
 }
 
@@ -1429,7 +1386,7 @@ void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
 void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode* aNode, int Index, double u, double v)
 {
   //Set Position on Node
-  if ( add( aNode, getSubmesh( Index )))
+  if ( add( aNode, NewSubMesh( Index )))
     const_cast< SMDS_MeshNode* >
       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
 }
@@ -1443,7 +1400,7 @@ void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode* aNode,
                                  double               u)
 {
   //Set Position on Node
-  if ( add( aNode, getSubmesh( Index )))
+  if ( add( aNode, NewSubMesh( Index )))
     const_cast< SMDS_MeshNode* >
       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
 }
@@ -1455,7 +1412,7 @@ void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode* aNode,
 void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode* aNode, int Index)
 {
   //Set Position on Node
-  if ( add( aNode, getSubmesh( Index )))
+  if ( add( aNode, NewSubMesh( Index )))
     const_cast< SMDS_MeshNode* >
       ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
 }
@@ -1467,7 +1424,7 @@ void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode* aNode, int Index)
 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
                                          int                     Index)
 {
-  add( anElement, getSubmesh( Index ));
+  add( anElement, NewSubMesh( Index ));
 }
 
 //=======================================================================
@@ -1479,9 +1436,7 @@ SMESHDS_Mesh::~SMESHDS_Mesh()
   // myScript
   delete myScript;
   // submeshes
-  TShapeIndexToSubMesh::iterator i_sm = myShapeIndexToSubMesh.begin();
-  for ( ; i_sm != myShapeIndexToSubMesh.end(); ++i_sm )
-    delete i_sm->second;
+  delete mySubMeshHolder;
 }
 
 
@@ -2279,20 +2234,20 @@ void SMESHDS_Mesh::compactMesh()
   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);
@@ -2305,12 +2260,9 @@ void SMESHDS_Mesh::compactMesh()
 
   // --- 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()
index 8b8fc0a..e51df85 100644 (file)
@@ -35,6 +35,8 @@
 #include <TopTools_IndexedMapOfShape.hxx>
 #include <TopoDS_Shape.hxx>
 
+#include <map>
+
 class TopoDS_Solid ;
 class TopoDS_Shell ;
 class TopoDS_Face  ;
@@ -50,8 +52,6 @@ class SMDS_MeshVolume   ;
 class SMDS_Mesh0DElement;
 class SMDS_BallElement;
 
-#include <map>
-
 /*
  * Using of native hash_map isn't portable and don't work on WIN32 platform.
  * So this functionality implement on new NCollection_DataMap technology
@@ -566,9 +566,7 @@ public:
   SMESHDS_SubMesh * MeshElements(const TopoDS_Shape & S) const;
   SMESHDS_SubMesh * MeshElements(const int Index) const;
   std::list<int> SubMeshIndices() const;
-  const std::map<int,SMESHDS_SubMesh*>& SubMeshes() const
-  { return myShapeIndexToSubMesh; }
-  const TopoDS_Shape& GetCurrentSubShape() const { return myCurSubShape; }
+  SMESHDS_SubMeshIteratorPtr SubMeshes() const;
 
   bool HasHypothesis(const TopoDS_Shape & S);
   const std::list<const SMESHDS_Hypothesis*>& GetHypothesis(const TopoDS_Shape & S) const;
@@ -601,22 +599,14 @@ public:
   ~SMESHDS_Mesh();
   
 private:
-  void addNodeToSubmesh( const SMDS_MeshNode* aNode, int Index )
-  {
-    //Update or build submesh
-    std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
-    if ( it == myShapeIndexToSubMesh.end() )
-      it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
-    it->second->AddNode( aNode ); // add aNode to submesh
-  }
-  
+
   ShapeToHypothesis          myShapeToHypothesis;
 
   int                        myMeshID, myPersistentID;
   TopoDS_Shape               myShape;
 
-  typedef std::map<int,SMESHDS_SubMesh*> TShapeIndexToSubMesh;
-  TShapeIndexToSubMesh myShapeIndexToSubMesh;
+  class SubMeshHolder;
+  SubMeshHolder*             mySubMeshHolder;
 
   TopTools_IndexedMapOfShape myIndexToShape;
 
@@ -626,14 +616,8 @@ private:
   SMESHDS_Script*            myScript;
   bool                       myIsEmbeddedMode;
 
-  // optimize addition of nodes/elements to submeshes by, SetNodeInVolume() etc:
-  // avoid search of submeshes in maps
   bool add( const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh );
   SMESHDS_SubMesh* getSubmesh( const TopoDS_Shape & shape);
-  SMESHDS_SubMesh* getSubmesh( const int            Index );
-  int                        myCurSubID;
-  TopoDS_Shape               myCurSubShape;
-  SMESHDS_SubMesh*           myCurSubMesh;
 };
 
 
diff --git a/src/SMESHDS/SMESHDS_TSubMeshHolder.hxx b/src/SMESHDS/SMESHDS_TSubMeshHolder.hxx
new file mode 100644 (file)
index 0000000..b6fa226
--- /dev/null
@@ -0,0 +1,143 @@
+// Copyright (C) 2007-2014  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, 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
+// 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
+//
+#ifndef __SMESHDS_SubMeshHolder_HXX__
+#define __SMESHDS_SubMeshHolder_HXX__
+
+#include <vector>
+#include <map>
+
+//=======================================================================
+/*!
+ * \brief A binder of a sub-mesh to its ID which can be negative. Provides fast
+ *        access to a sub-mesh by its ID.
+ *
+ * Issue 52457: Addition of hypotheses is 8 time longer than meshing.
+ */
+//=======================================================================
+
+template <class SUBMESH>
+class SMESHDS_TSubMeshHolder
+{
+  std::vector< SUBMESH* >   myVec; // for ID >= 0
+  std::map< int, SUBMESH* > myMap; // for ID < 0
+
+public:
+
+  ~SMESHDS_TSubMeshHolder()
+  {
+    DeleteAll();
+  }
+  void Add( int id, SUBMESH* sm )
+  {
+    if ( id < 0 )
+    {
+      myMap[ id ] = sm;
+    }
+    else
+    {
+      if ( myVec.size() <= id )
+        myVec.resize( id+1, (SUBMESH*) NULL );
+      myVec[ id ] = sm;
+    }
+  }
+  SUBMESH* Get( int id ) const
+  {
+    if ( id < 0 )
+    {
+      typename std::map< int, SUBMESH* >::const_iterator i2sm = myMap.find( id );
+      return (SUBMESH*) ( i2sm == myMap.end() ? NULL : i2sm->second );
+    }
+    else
+    {
+      return (SUBMESH*) ( id >= myVec.size() ? NULL : myVec[ id ]);
+    }
+  }
+  void DeleteAll()
+  {
+    for ( size_t i = 0; i < myVec.size(); ++i )
+      delete myVec[i];
+    myVec.clear();
+
+    typename std::map< int, SUBMESH* >::iterator i2sm = myMap.begin();
+    for ( ; i2sm != myMap.end(); ++i2sm )
+      delete i2sm->second;
+    myMap.clear();
+  }
+  int GetMinID() const
+  {
+    return myMap.empty() ? 0 : myMap.begin()->first;
+  }
+  int GetMaxID() const
+  {
+    return myVec.empty() ? ( myMap.empty() ? 0 : myMap.rbegin()->first ) : myVec.size();
+  }
+
+  //-----------------------------------------------------------------------
+  struct Iterator : public SMDS_Iterator< SUBMESH* >
+  {
+    const SMESHDS_TSubMeshHolder<SUBMESH>* myHolder;
+    SUBMESH* myNext;
+    int myCurID, myEndID, myIDDelta;
+
+    void init( const SMESHDS_TSubMeshHolder<SUBMESH>* holder,
+               int firstID, int endID, int delta )
+    {
+      myHolder  = holder;
+      myNext    = 0;
+      myCurID   = firstID;
+      myEndID   = endID;
+      myIDDelta = delta;
+
+      next();
+    }
+
+    bool more()
+    {
+      return myNext;
+    }
+
+    SUBMESH* next()
+    {
+      SUBMESH* res = myNext;
+      myNext = 0;
+      while ( !myNext && myCurID != myEndID )
+      {
+        myNext = myHolder->Get( myCurID );
+        myCurID += myIDDelta;
+      }
+      return res;
+    }
+    virtual ~Iterator() {}
+  };
+  //-----------------------------------------------------------------------
+
+  SMDS_Iterator< SUBMESH* >* GetIterator(const bool reverse=false) const
+  {
+    Iterator* iter = new Iterator;
+    if ( reverse ) iter->init( this, GetMaxID(), GetMinID()-1, -1 );
+    else           iter->init( this, GetMinID(), GetMaxID()+1, +1 );
+    return iter;
+  }
+};
+
+
+#endif
index 815426b..7d1dbf9 100644 (file)
@@ -3696,7 +3696,8 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
                 myLocMesh.ShapeToMesh( nullShape ); // remove shape referring data
               }
 
-              if ( !mySMESHDSMesh->SubMeshes().empty() )
+              SMESHDS_SubMeshIteratorPtr smIt = mySMESHDSMesh->SubMeshes();
+              if ( smIt->more() )
               {
                 // Store submeshes
                 // ----------------
@@ -3706,52 +3707,9 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
                 // each element belongs to one or none submesh,
                 // so for each node/element, we store a submesh ID
 
-                // Make maps of submesh IDs of elements sorted by element IDs
-                // typedef int TElemID;
-                // typedef int TSubMID;
-                // map< TElemID, TSubMID > eId2smId, nId2smId;
-                const map<int,SMESHDS_SubMesh*>& aSubMeshes = mySMESHDSMesh->SubMeshes();
-                map<int,SMESHDS_SubMesh*>::const_iterator itSubM ( aSubMeshes.begin() );
-                // SMDS_NodeIteratorPtr itNode;
-                // SMDS_ElemIteratorPtr itElem;
-                // for ( itSubM = aSubMeshes.begin(); itSubM != aSubMeshes.end() ; itSubM++ )
-                // {
-                //   TSubMID          aSubMeID = itSubM->first;
-                //   SMESHDS_SubMesh* aSubMesh = itSubM->second;
-                //   if ( aSubMesh->IsComplexSubmesh() )
-                //     continue; // sub-mesh containing other sub-meshes
-                //   // nodes
-                //   for ( itNode = aSubMesh->GetNodes(); itNode->more(); ++hint)
-                //     nId2smId.insert( nId2smId.back(), make_pair( itNode->next()->GetID(), aSubMeID ));
-                //   // elements
-                //   for ( itElem = aSubMesh->GetElements(); itElem->more(); ++hint)
-                //     hint = eId2smId.insert( eId2smId.back(), make_pair( itElem->next()->GetID(), aSubMeID ));
-                // }
-
-                // // Care of elements that are not on submeshes
-                // if ( mySMESHDSMesh->NbNodes() != nId2smId.size() ) {
-                //   for ( itNode = mySMESHDSMesh->nodesIterator(); itNode->more(); )
-                //     /*  --- stl_map.h says : */
-                //     /*  A %map relies on unique keys and thus a %pair is only inserted if its */
-                //     /*  first element (the key) is not already present in the %map.           */
-                //     nId2smId.insert( make_pair( itNode->next()->GetID(), 0 ));
-                // }
-                // int nbElems = mySMESHDSMesh->GetMeshInfo().NbElements();
-                // if ( nbElems != eId2smId.size() ) {
-                //   for ( itElem = mySMESHDSMesh->elementsIterator(); itElem->more(); )
-                //     eId2smId.insert( make_pair( itElem->next()->GetID(), 0 ));
-                // }
-
                 // Store submesh IDs
                 for ( int isNode = 0; isNode < 2; ++isNode )
                 {
-                  // map< TElemID, TSubMID >& id2smId = isNode ? nId2smId : eId2smId;
-                  // if ( id2smId.empty() ) continue;
-                  // map< TElemID, TSubMID >::const_iterator id_smId = id2smId.begin();
-                  // // make and fill array of submesh IDs
-                  // int* smIDs = new int [ id2smId.size() ];
-                  // for ( int i = 0; id_smId != id2smId.end(); ++id_smId, ++i )
-                  //   smIDs[ i ] = id_smId->second;
                   SMDS_ElemIteratorPtr eIt =
                     mySMESHDSMesh->elementsIterator( isNode ? SMDSAbs_Node : SMDSAbs_All );
                   int nbElems = isNode ? mySMESHDSMesh->NbNodes() : mySMESHDSMesh->GetMeshInfo().NbElements();
@@ -3790,15 +3748,15 @@ SALOMEDS::TMPFile* SMESH_Gen_i::Save( SALOMEDS::SComponent_ptr theComponent,
                 int nbEdgeNodes = 0, nbFaceNodes = 0;
                 list<SMESHDS_SubMesh*> aEdgeSM, aFaceSM;
                 // loop on SMESHDS_SubMesh'es
-                for ( itSubM = aSubMeshes.begin(); itSubM != aSubMeshes.end() ; itSubM++ )
+                while ( smIt->more() )
                 {
-                  SMESHDS_SubMesh* aSubMesh = (*itSubM).second;
+                  SMESHDS_SubMesh* aSubMesh = const_cast< SMESHDS_SubMesh* >( smIt->next() );
                   if ( aSubMesh->IsComplexSubmesh() )
                     continue; // submesh containing other submeshs
                   int nbNodes = aSubMesh->NbNodes();
                   if ( nbNodes == 0 ) continue;
 
-                  int aShapeID = (*itSubM).first;
+                  int aShapeID = aSubMesh->GetID();
                   if ( aShapeID < 1 || aShapeID > mySMESHDSMesh->MaxShapeIndex() )
                     continue;
                   int aShapeType = mySMESHDSMesh->IndexToShape( aShapeID ).ShapeType();
index 32ac43e..92474f2 100644 (file)
@@ -2132,7 +2132,7 @@ bool StdMeshers_ProjectionUtils::MakeComputed(SMESH_subMesh * sm, const int iter
           mesh->GetHypotheses( shape, hypoFilter, hyps, true, &assignedTo );
         if ( nbAlgos > 1 ) // concurrent algos
         {
-          list<SMESH_subMesh*> smList; // where an algo is assigned
+          vector<SMESH_subMesh*> smList; // where an algo is assigned
           list< TopoDS_Shape >::iterator shapeIt = assignedTo.begin();
           for ( ; shapeIt != assignedTo.end(); ++shapeIt )
             smList.push_back( mesh->GetSubMesh( *shapeIt ));
index 30612ef..cb6aa8f 100644 (file)
@@ -994,9 +994,9 @@ bool StdMeshers_RadialQuadrangle_1D2D::computeLayerPositions(const gp_Pnt&
     if ( !edge.IsNull() )
     {
       // find a hyp usable by TNodeDistributor
-      SMESH_HypoFilter hypKind;
-      TNodeDistributor::GetDistributor(*mesh)->InitCompatibleHypoFilter(hypKind,/*ignoreAux=*/1);
-      hyp1D = mesh->GetHypothesis( edge, hypKind, /*fromAncestors=*/true);
+      const SMESH_HypoFilter* hypKind =
+        TNodeDistributor::GetDistributor(*mesh)->GetCompatibleHypoFilter(/*ignoreAux=*/true);
+      hyp1D = mesh->GetHypothesis( edge, *hypKind, /*fromAncestors=*/true);
     }
   }
   if ( hyp1D ) // try to compute with hyp1D
index f3449e8..1c97ebc 100644 (file)
@@ -1336,12 +1336,11 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh &         aMesh,
   _usedHypList.clear();
   _mainEdge.Nullify();
 
-  SMESH_HypoFilter auxiliaryFilter, compatibleFilter;
-  auxiliaryFilter.Init( SMESH_HypoFilter::IsAuxiliary() );
-  InitCompatibleHypoFilter( compatibleFilter, /*ignoreAux=*/true );
+  SMESH_HypoFilter auxiliaryFilter( SMESH_HypoFilter::IsAuxiliary() );
+  const SMESH_HypoFilter* compatibleFilter = GetCompatibleHypoFilter(/*ignoreAux=*/true );
 
   // get non-auxiliary assigned directly to aShape
-  int nbHyp = aMesh.GetHypotheses( aShape, compatibleFilter, _usedHypList, false );
+  int nbHyp = aMesh.GetHypotheses( aShape, *compatibleFilter, _usedHypList, false );
 
   if (nbHyp == 0 && aShape.ShapeType() == TopAbs_EDGE)
   {
@@ -1352,7 +1351,7 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh &         aMesh,
     {
       // Propagation of 1D hypothesis from <aMainEdge> on this edge;
       // get non-auxiliary assigned to _mainEdge
-      nbHyp = aMesh.GetHypotheses( _mainEdge, compatibleFilter, _usedHypList, true );
+      nbHyp = aMesh.GetHypotheses( _mainEdge, *compatibleFilter, _usedHypList, true );
     }
   }