0021893: EDF 2133 SMESH : Improvement of 3D extrusion algorithm

Not to clear sub-meshes computed by local algos when an
   all-dimensional global algorithm is assigned

-  void cleanDependsOn();
+  void cleanDependsOn( bool keepSupportedsubMeshes = false );

src/SMESH/SMESH_subMesh.cxx

@@ -601,10 +601,6 @@ bool SMESH_subMesh::IsApplicableHypotesis(const SMESH_Hypothesis* theHypothesis,
 SMESH_Hypothesis::Hypothesis_Status
   SMESH_subMesh::AlgoStateEngine(int event, SMESH_Hypothesis * anHyp)
 {
-  //  MESSAGE("SMESH_subMesh::AlgoStateEngine");
-  //SCRUTE(_algoState);
-  //SCRUTE(event);
-
   // **** les retour des evenement shape sont significatifs
   // (add ou remove fait ou non)
   // le retour des evenement father n'indiquent pas que add ou remove fait
@@ -612,7 +608,6 @@ SMESH_Hypothesis::Hypothesis_Status
   SMESH_Hypothesis::Hypothesis_Status aux_ret, ret = SMESH_Hypothesis::HYP_OK;
 
   SMESHDS_Mesh* meshDS =_father->GetMeshDS();
-  //SMESH_Gen*    gen    =_father->GetGen();
   SMESH_Algo*   algo   = 0;
 
   if (_subShape.ShapeType() == TopAbs_VERTEX )
@@ -642,7 +637,7 @@ SMESH_Hypothesis::Hypothesis_Status
 
   int oldAlgoState = _algoState;
   bool modifiedHyp = (event == MODIF_HYP);  // if set to true, force event MODIF_ALGO_STATE
-  bool needFullClean = false;
+  bool needFullClean = false, subMeshesSupported = false;
 
   bool isApplicableHyp = IsApplicableHypotesis( anHyp );
 
@@ -665,7 +660,7 @@ SMESH_Hypothesis::Hypothesis_Status
       SMESH_HypoFilter filter( SMESH_HypoFilter::HasType( algo->GetType() ));
       filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+1 ));
       filter.Or( SMESH_HypoFilter::HasType( algo->GetType()+2 ));
-      if ( SMESH_Algo * curAlgo = (SMESH_Algo*) _father->GetHypothesis( _subShape, filter, true ))
+      if ( SMESH_Algo * curAlgo = (SMESH_Algo*)_father->GetHypothesis(_subShape, filter, true ))
         needFullClean = ( !curAlgo->NeedDiscreteBoundary() );
     }
   }
@@ -702,6 +697,7 @@ SMESH_Hypothesis::Hypothesis_Status
         // we must perform it now because later
         // we will have no information about the type of the removed algo
         needFullClean = true;
+        subMeshesSupported = algo->SupportSubmeshes();
       }
     }
   }
@@ -984,8 +980,10 @@ SMESH_Hypothesis::Hypothesis_Status
       // CLEAN was not called at event REMOVE_ALGO because the algo is not applicable to SOLID.
       algo = dynamic_cast<SMESH_Algo*> (anHyp);
       if (!algo->NeedDiscreteBoundary())
+      {
         needFullClean = true;
-
+        subMeshesSupported = algo->SupportSubmeshes();
+      }
       algo = GetAlgo();
       if (algo == NULL)  // no more applying algo on father
       {
@@ -1064,7 +1062,7 @@ SMESH_Hypothesis::Hypothesis_Status
   if ( needFullClean ) {
     // added or removed algo is all-dimensional
     ComputeStateEngine( CLEAN );
-    cleanDependsOn();
+    cleanDependsOn( subMeshesSupported );
     ComputeSubMeshStateEngine( CHECK_COMPUTE_STATE );
   }
 
@@ -1163,17 +1161,59 @@ SMESH_Hypothesis::Hypothesis_Status
   return ret;
 }
 
-//=============================================================================
+//================================================================================
 /*!
- *
+ * \brief Remove elements from sub-meshes.
+ *  \param keepSupportedsubMeshes - if true, the sub-meshes computed using more 
+ *         local algorithms are not cleaned
  */
-//=============================================================================
+//================================================================================
 
-void SMESH_subMesh::cleanDependsOn()
+void SMESH_subMesh::cleanDependsOn( bool keepSupportedsubMeshes )
 {
-  SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,false);
+  if ( _father->NbNodes() == 0 ) return;
-  while ( smIt->more() )
+
-    smIt->next()->ComputeStateEngine(CLEAN);
+  SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,
+                                                       /*complexShapeFirst=*/true);
+  if ( !keepSupportedsubMeshes )
+  {
+    while ( smIt->more() )
+      smIt->next()->ComputeStateEngine(CLEAN);
+  }
+  else
+  {
+    // find sub-meshes to keep elements on
+    set< SMESH_subMesh* > smToKeep;
+    SMESHDS_Mesh* meshDS = _father->GetMeshDS();
+    while ( smIt->more() )
+    {
+      SMESH_subMesh* sm = smIt->next();
+      if ( sm->IsEmpty() ) continue;
+
+      // look for an algo assigned to sm
+      bool algoFound = false;
+      const list<const SMESHDS_Hypothesis*>& hyps = meshDS->GetHypothesis( sm->_subShape );
+      list<const SMESHDS_Hypothesis*>::const_iterator h = hyps.begin();
+      for ( ; ( !algoFound && h != hyps.end() ); ++h )
+        algoFound = ((*h)->GetType() != SMESHDS_Hypothesis::PARAM_ALGO );
+
+      // remember all sub-meshes of sm
+      if ( algoFound )
+      {
+        SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false,true);
+        while ( smIt2->more() )
+          smToKeep.insert( smIt2->next() );
+      }
+    }
+    // remove elements
+    SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
+    while ( smIt->more() )
+    {
+      SMESH_subMesh* sm = smIt->next();
+      if ( !smToKeep.count( sm ))
+        sm->ComputeStateEngine(CLEAN);
+    }
+  }
 }
 
 //=============================================================================
@@ -1328,7 +1368,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
     case MODIF_ALGO_STATE:
       algo = GetAlgo();
       if (algo && !algo->NeedDiscreteBoundary())
-        cleanDependsOn(); // clean sub-meshes with event CLEAN
+        cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
       if ( _algoState == HYP_OK )
         _computeState = READY_TO_COMPUTE;
       break;
@@ -1374,7 +1414,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
       if (algo)
       {
         if (!algo->NeedDiscreteBoundary())
-          cleanDependsOn(); // clean sub-meshes with event CLEAN
+          cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
         if ( _algoState == HYP_OK )
           _computeState = READY_TO_COMPUTE;
       }
@@ -1597,7 +1637,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
       ComputeStateEngine( CLEAN );
       algo = GetAlgo();
       if (algo && !algo->NeedDiscreteBoundary())
-        cleanDependsOn(); // clean sub-meshes with event CLEAN
+        cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
       break;
     case COMPUTE:               // nothing to do
       break;
@@ -1652,7 +1692,7 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         ComputeStateEngine( CLEAN );
       algo = GetAlgo();
       if (algo && !algo->NeedDiscreteBoundary())
-        cleanDependsOn(); // clean sub-meshes with event CLEAN
+        cleanDependsOn( algo->SupportSubmeshes() ); // clean sub-meshes with event CLEAN
       if (_algoState == HYP_OK)
         _computeState = READY_TO_COMPUTE;
       else

src/SMESH/SMESH_subMesh.hxx

@@ -273,7 +273,7 @@ protected:
   void updateDependantsState(const compute_event theEvent);
   void updateSubMeshState(const compute_state theState);
   void cleanDependants();
-  void cleanDependsOn();
+  void cleanDependsOn( bool keepSupportedsubMeshes = false );
   void setAlgoState(algo_state state);
 
   /*!