From 91ed159dc19c3819c0001f18ff52e91b9b39e8e1 Mon Sep 17 00:00:00 2001
From: msv <msv@opencascade.com>
Date: Thu, 13 Apr 2006 08:41:58 +0000
Subject: [PATCH] Changes needed for smooth working of algorithms that need no
 descrete boundaries: - in SubMeshesComputed(), restrict checking to myDim-1
 only - in AlgoStateEngine(), clean all submeshes in the current on
 REMOVE_ALGO event - in CleanDependsOn(), remove call to ComputeStateEngine to
 avoid repeatitive cleaning - in ComputeStateEngine(), call CleanDependsOn on
 the event modifying hyp or algo   regardless of current compute state

---
 src/SMESH/SMESH_subMesh.cxx | 65 +++++++++++++++++++++++++------------
 1 file changed, 45 insertions(+), 20 deletions(-)

diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx
index 9fb17c2ca..3e3dee91d 100644
--- a/src/SMESH/SMESH_subMesh.cxx
+++ b/src/SMESH/SMESH_subMesh.cxx
@@ -186,11 +186,20 @@ bool SMESH_subMesh::SubMeshesComputed()
   //MESSAGE("SMESH_subMesh::SubMeshesComputed");
   const map < int, SMESH_subMesh * >&subMeshes = DependsOn();
 
+  int myDim = SMESH_Gen::GetShapeDim( _subShape );
+  int dimToCheck = myDim - 1;
   bool subMeshesComputed = true;
   map < int, SMESH_subMesh * >::const_iterator itsub;
   for (itsub = subMeshes.begin(); itsub != subMeshes.end(); itsub++)
   {
     SMESH_subMesh *sm = (*itsub).second;
+    const TopoDS_Shape & ss = sm->GetSubShape();
+    // MSV 07.04.2006: restrict checking to myDim-1 only. Ex., there is no sense
+    // in checking of existence of edges if the algo needs only faces. Moreover,
+    // degenerated edges may have no submesh, as after computing NETGEN_2D.
+    int dim = SMESH_Gen::GetShapeDim( ss );
+    if (dim < dimToCheck)
+      continue;
     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
     // PAL10974.
     // There are some tricks with compute states, e.g. Penta_3D leaves
@@ -201,7 +210,6 @@ bool SMESH_subMesh::SubMeshesComputed()
                       (ds && ( ds->GetNodes()->more() || ds->GetElements()->more() )));
     if (!computeOk)
     {
-      const TopoDS_Shape & ss = sm->GetSubShape();
       int type = ss.ShapeType();
 
       subMeshesComputed = false;
@@ -634,6 +642,19 @@ SMESH_Hypothesis::Hypothesis_Status
         ret = SMESH_Hypothesis::HYP_CONCURENT;
       }
     } // Serve Propagation of 1D hypothesis
+    else // event == REMOVE_ALGO
+    {
+      SMESH_Algo* algo = dynamic_cast<SMESH_Algo*> (anHyp);
+      if (!algo->NeedDescretBoundary())
+      {
+        // clean all mesh in the tree of the current submesh;
+        // we must perform it now because later
+        // we will have no information about the type of the removed algo
+        CleanDependants();
+	ComputeStateEngine( CLEAN );
+        CleanDependsOn();
+      }
+    }
   }
 
   // ------------------
@@ -1038,9 +1059,6 @@ SMESH_Hypothesis::Hypothesis_Status
 void SMESH_subMesh::CleanDependsOn()
 {
   //MESSAGE("SMESH_subMesh::CleanDependsOn");
-  // **** parcourir les ancetres dans l'ordre de dépendance
-
-  ComputeStateEngine(CLEAN);
 
   const map < int, SMESH_subMesh * >&dependson = DependsOn();
   map < int, SMESH_subMesh * >::const_iterator its;
@@ -1169,10 +1187,12 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
   case NOT_READY:
     switch (event)
     {
-    case MODIF_HYP:		// nothing to do
-      break;
+    case MODIF_HYP:
     case MODIF_ALGO_STATE:
-      if (_algoState == HYP_OK)
+      algo = gen->GetAlgo((*_father), _subShape);
+      if (algo && !algo->NeedDescretBoundary())
+        CleanDependsOn(); // clean sub-meshes with event CLEAN
+      if (event == MODIF_ALGO_STATE && _algoState == HYP_OK)
       {
         _computeState = READY_TO_COMPUTE;
       }
@@ -1205,11 +1225,14 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
   case READY_TO_COMPUTE:
     switch (event)
     {
-    case MODIF_HYP:		// nothing to do
-      break;
+    case MODIF_HYP:
     case MODIF_ALGO_STATE:
-      _computeState = NOT_READY;
       algo = gen->GetAlgo((*_father), _subShape);
+      if (algo && !algo->NeedDescretBoundary())
+        CleanDependsOn(); // clean sub-meshes with event CLEAN
+      if (event == MODIF_HYP)
+	break;            // nothing else to do when MODIF_HYP
+      _computeState = NOT_READY;
       if (algo)
       {
         ret = algo->CheckHypothesis((*_father), _subShape, hyp_status);
@@ -1240,16 +1263,18 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         // compute
         CleanDependants();
         RemoveSubMeshElementsAndNodes();
-        try {
-          if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput())
-            ret = ApplyToCollection( algo, GetCollection( gen, algo ) );
-          else
-            ret = algo->Compute((*_father), _subShape);
-        }
-        catch (Standard_Failure) {
-          MESSAGE( "Exception in algo->Compute() ");
-          ret = false;
-        }
+	{
+	  try {
+	    if (!algo->NeedDescretBoundary() && !algo->OnlyUnaryInput())
+	      ret = ApplyToCollection( algo, GetCollection( gen, algo ) );
+	    else
+	      ret = algo->Compute((*_father), _subShape);
+	  }
+	  catch (Standard_Failure) {
+	    MESSAGE( "Exception in algo->Compute() ");
+	    ret = false;
+	  }
+	}
         if (!ret)
         {
           MESSAGE("problem in algo execution: failed to compute");
-- 
2.30.2