0022124: [CEA 763] Projection 1D does not work with Netgen 1D2D

  Do not call algo->Compute() if !algo->NeedDiscreteBoundary() and
  computing a sub-mesh of the current sub-mesh already failed.

diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx
index 8a90cc253b4582b368b52cc4e4235822675ba9f0..d015be18dd7d6ff92f267fb2cc829736974c1c7a 100644 (file)
--- a/src/SMESH/SMESH_subMesh.cxx
+++ b/src/SMESH/SMESH_subMesh.cxx
@@ -88,22 +88,22 @@ SMESH_subMesh::SMESH_subMesh(int                  Id,
                              SMESHDS_Mesh *       meshDS,
                              const TopoDS_Shape & aSubShape)
 {
-        _subShape = aSubShape;
-        _subMeshDS = meshDS->MeshElements(_subShape);   // may be null ...
-        _father = father;
-        _Id = Id;
-        _dependenceAnalysed = _alwaysComputed = false;
-
-        if (_subShape.ShapeType() == TopAbs_VERTEX)
-        {
-                _algoState = HYP_OK;
-                _computeState = READY_TO_COMPUTE;
-        }
-        else
-        {
-          _algoState = NO_ALGO;
-          _computeState = NOT_READY;
-        }
+  _subShape           = aSubShape;
+  _subMeshDS          = meshDS->MeshElements(_subShape);   // may be null ...
+  _father             = father;
+  _Id                 = Id;
+  _dependenceAnalysed = _alwaysComputed = false;
+  _algo               = 0;
+  if (_subShape.ShapeType() == TopAbs_VERTEX)
+  {
+    _algoState = HYP_OK;
+    _computeState = READY_TO_COMPUTE;
+  }
+  else
+  {
+    _algoState = NO_ALGO;
+    _computeState = NOT_READY;
+  }
 }
 
 //=============================================================================
@@ -194,7 +194,9 @@ SMESH_subMesh *SMESH_subMesh::GetFirstToCompute()
 
 SMESH_Algo* SMESH_subMesh::GetAlgo() const
 {
-  return _father->GetGen()->GetAlgo(*_father, _subShape);
+  if ( !_algo )
+    ((SMESH_subMesh*)this)->_algo = _father->GetGen()->GetAlgo(*_father, _subShape);
+  return _algo;
 }
 
 //================================================================================
@@ -268,11 +270,12 @@ bool SMESH_subMesh::IsMeshComputed() const
  */
 //=============================================================================
 
-bool SMESH_subMesh::SubMeshesComputed() const
+bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const
 {
   int myDim = SMESH_Gen::GetShapeDim( _subShape );
   int dimToCheck = myDim - 1;
   bool subMeshesComputed = true;
+  if ( isFailedToCompute ) *isFailedToCompute = false;
   // check subMeshes with upper dimension => reverse iteration
   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
   while ( smIt->more() )
@@ -281,66 +284,72 @@ bool SMESH_subMesh::SubMeshesComputed() const
     if ( sm->_alwaysComputed )
       continue;
     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)
-      break; // the rest subMeshes are all of less dimension
+    if ( !_algo || _algo->NeedDiscreteBoundary() ) {
+      int dim = SMESH_Gen::GetShapeDim( ss );
+      if (dim < dimToCheck)
+        break; // the rest subMeshes are all of less dimension
+    }
     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
     bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
                       (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes()  )));
     if (!computeOk)
     {
-      int type = ss.ShapeType();
-
       subMeshesComputed = false;
-
-      switch (type)
-      {
-      case TopAbs_COMPOUND:
-        {
-          MESSAGE("The not computed sub mesh is a COMPOUND");
-          break;
-        }
-      case TopAbs_COMPSOLID:
-        {
-          MESSAGE("The not computed sub mesh is a COMPSOLID");
-          break;
-        }
-      case TopAbs_SHELL:
-        {
-          MESSAGE("The not computed sub mesh is a SHEL");
-          break;
-        }
-      case TopAbs_WIRE:
-        {
-          MESSAGE("The not computed sub mesh is a WIRE");
-          break;
-        }
-      case TopAbs_SOLID:
-        {
-          MESSAGE("The not computed sub mesh is a SOLID");
-          break;
-        }
-      case TopAbs_FACE:
-        {
-          MESSAGE("The not computed sub mesh is a FACE");
-          break;
-        }
-      case TopAbs_EDGE:
-        {
-          MESSAGE("The not computed sub mesh is a EDGE");
-          break;
-        }
-      default:
-        {
-          MESSAGE("The not computed sub mesh is of unknown type");
-          break;
-        }
-      }
-
-      break;
+      if ( isFailedToCompute && !(*isFailedToCompute) )
+        *isFailedToCompute = ( sm->GetComputeState() == FAILED_TO_COMPUTE );
+
+      // int type = ss.ShapeType();
+
+      // switch (type)
+      // {
+      // case TopAbs_COMPOUND:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a COMPOUND");
+      //     break;
+      //   }
+      // case TopAbs_COMPSOLID:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a COMPSOLID");
+      //     break;
+      //   }
+      // case TopAbs_SHELL:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a SHEL");
+      //     break;
+      //   }
+      // case TopAbs_WIRE:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a WIRE");
+      //     break;
+      //   }
+      // case TopAbs_SOLID:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a SOLID");
+      //     break;
+      //   }
+      // case TopAbs_FACE:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a FACE");
+      //     break;
+      //   }
+      // case TopAbs_EDGE:
+      //   {
+      //     MESSAGE("The not computed sub mesh is a EDGE");
+      //     break;
+      //   }
+      // default:
+      //   {
+      //     MESSAGE("The not computed sub mesh is of unknown type");
+      //     break;
+      //   }
+      // }
+
+      if ( !isFailedToCompute )
+        break;
     }
   }
   return subMeshesComputed;
@@ -609,6 +618,7 @@ SMESH_Hypothesis::Hypothesis_Status
 
   SMESHDS_Mesh* meshDS =_father->GetMeshDS();
   SMESH_Algo*   algo   = 0;
+  _algo = 0;
 
   if (_subShape.ShapeType() == TopAbs_VERTEX )
   {
@@ -1323,10 +1333,6 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
   default:;
   }
 
-  //MESSAGE("SMESH_subMesh::ComputeStateEngine");
-  //SCRUTE(_computeState);
-  //SCRUTE(event);
-
   if (_subShape.ShapeType() == TopAbs_VERTEX)
   {
     _computeState = READY_TO_COMPUTE;
@@ -1434,21 +1440,22 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         TopoDS_Shape shape = _subShape;
         // check submeshes needed
         if (_father->HasShapeToMesh() ) {
-          bool subComputed = false;
+          bool subComputed = false, subFailed = false;
           if (!algo->OnlyUnaryInput())
-            shape = getCollection( gen, algo, subComputed );
+            shape = getCollection( gen, algo, subComputed, subFailed );
           else
             subComputed = SubMeshesComputed();
           ret = ( algo->NeedDiscreteBoundary() ? subComputed :
-                  algo->SupportSubmeshes() ? true :
+                  algo->SupportSubmeshes() ? !subFailed :
                   ( !subComputed || _father->IsNotConformAllowed() ));
-          if (!ret) {
+          if (!ret)
+          {
             _computeState = FAILED_TO_COMPUTE;
-            if ( !algo->NeedDiscreteBoundary() )
+            if ( !algo->NeedDiscreteBoundary() && !subFailed )
               _computeError =
                 SMESH_ComputeError::New(COMPERR_BAD_INPUT_MESH,
                                         "Unexpected computed submesh",algo);
-            break;
+            break; // goto exit
           }
         }
         // Compute
@@ -1534,6 +1541,8 @@ bool SMESH_subMesh::ComputeStateEngine(int event)
         }
         // check if an error reported on any sub-shape
         bool isComputeErrorSet = !checkComputeError( algo, ret, shape );
+        if ( isComputeErrorSet )
+          ret = false;
         // check if anything was built
         TopExp_Explorer subS(shape, _subShape.ShapeType());
         if (ret)
@@ -1991,9 +2000,10 @@ void SMESH_subMesh::removeSubMeshElementsAndNodes()
 
 TopoDS_Shape SMESH_subMesh::getCollection(SMESH_Gen * theGen,
                                           SMESH_Algo* theAlgo,
-                                          bool &      theSubComputed)
+                                          bool &      theSubComputed,
+                                          bool &      theSubFailed)
 {
-  theSubComputed = SubMeshesComputed();
+  theSubComputed = SubMeshesComputed( & theSubFailed );
 
   TopoDS_Shape mainShape = _father->GetMeshDS()->ShapeToMesh();