#20282 EDF 22320 - general compute fails

don't apply 1D-2D algorithms before 1D-2D-3D ones if sub-mesh order says opposite

src/SMESH/SMESH_Gen.cxx

@@ -338,12 +338,13 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
 
     std::vector< SMESH_subMesh* > smVec;
     for ( aShapeDim = 0; aShapeDim < 4; ++aShapeDim )
+      smVec.insert( smVec.end(),
+                    smWithAlgoSupportingSubmeshes[aShapeDim].begin(),
+                    smWithAlgoSupportingSubmeshes[aShapeDim].end() );
     {
       // ------------------------------------------------
       // sort list of sub-meshes according to mesh order
       // ------------------------------------------------
-      smVec.assign( smWithAlgoSupportingSubmeshes[ aShapeDim ].begin(),
-                    smWithAlgoSupportingSubmeshes[ aShapeDim ].end() );
       aMesh.SortByMeshOrder( smVec );
 
       // ------------------------------------------------------------
@@ -354,20 +355,29 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
       for ( size_t i = 0; i < smVec.size(); ++i )
       {
         sm = smVec[i];
+        if ( sm->GetComputeState() != SMESH_subMesh::READY_TO_COMPUTE)
+          continue;
+
+        const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
 
         // get a shape the algo is assigned to
         if ( !GetAlgo( sm, & algoShape ))
           continue; // strange...
 
         // look for more local algos
+        if ( SMESH_subMesh* algoSM = aMesh.GetSubMesh( algoShape ))
+          smIt = algoSM->getDependsOnIterator(!includeSelf, !complexShapeFirst);
+        else
           smIt = sm->getDependsOnIterator(!includeSelf, !complexShapeFirst);
+
         while ( smIt->more() )
         {
           SMESH_subMesh* smToCompute = smIt->next();
 
           const TopoDS_Shape& aSubShape = smToCompute->GetSubShape();
           const int aShapeDim = GetShapeDim( aSubShape );
-          if ( aShapeDim < 1 ) continue;
+          if ( aShapeDim < 1 || aSubShape.ShapeType() == shapeType )
+            continue;
 
           // check for preview dimension limitations
           if ( aShapesId && GetShapeDim( aSubShape.ShapeType() ) > (int)aDim )
@@ -391,22 +401,15 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
               Compute( aMesh, aSubShape, aFlags | SHAPE_ONLY_UPWARD, aDim, aShapesId, localAllowed );
           }
         }
-      }
         // --------------------------------
-      // apply the all-dimensional algos
+        // apply the all-dimensional algo
         // --------------------------------
-      for ( size_t i = 0; i < smVec.size(); ++i )
         {
-        sm = smVec[i];
+          if (_compute_canceled)
-        if ( sm->GetComputeState() == SMESH_subMesh::READY_TO_COMPUTE)
+            return false;
-        {
-          const TopAbs_ShapeEnum shapeType = sm->GetSubShape().ShapeType();
           // check for preview dimension limitations
           if ( aShapesId && GetShapeDim( shapeType ) > (int)aDim )
             continue;
-
-          if (_compute_canceled)
-            return false;
           sm->SetAllowedSubShapes( fillAllowed( shapeSM, aShapeOnly, allowedSubShapes ));
           setCurrentSubMesh( sm );
           sm->ComputeStateEngine( computeEvent );
@@ -416,7 +419,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh &                aMesh,
             aShapesId->insert( sm->GetId() );
         }
       }
-    } // loop on shape dimensions
+    }
 
     // -----------------------------------------------
     // mesh the rest sub-shapes starting from vertices
@@ -1074,15 +1077,18 @@ std::vector< std::string > SMESH_Gen::GetPluginXMLPaths()
       xmlPath += sep + plugin + ".xml";
       bool fileOK;
 #ifdef WIN32
-#ifdef UNICODE
+  #ifdef UNICODE
       const wchar_t* path = Kernel_Utils::decode_s(xmlPath);
-#else
+  #else
       const char* path = xmlPath.c_str();
-#endif
+  #endif
+
       fileOK = (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES);
-#ifdef UNICODE
+
+  #ifdef UNICODE
       delete path;
-#endif
+  #endif
+
 #else
       fileOK = (access(xmlPath.c_str(), F_OK) == 0);
 #endif

src/SMESH/SMESH_Mesh.cxx

@@ -2432,6 +2432,7 @@ bool SMESH_Mesh::SortByMeshOrder(std::vector<SMESH_subMesh*>& theListToSort) con
         smVec.push_back( sm );
         if ( sm->GetSubMeshDS() && sm->GetSubMeshDS()->IsComplexSubmesh() )
         {
+          smVec.reserve( smVec.size() + sm->GetSubMeshDS()->NbSubMeshes() );
           SMESHDS_SubMeshIteratorPtr smdsIt = sm->GetSubMeshDS()->GetSubMeshIterator();
           while ( smdsIt->more() )
           {

src/SMESHGUI/SMESHGUI.cxx

@@ -4686,7 +4686,7 @@ void SMESHGUI::initialize( CAM_Application* app )
 
   popupMgr()->insert( separator(), -1, 0 );
   createPopupItem( SMESHOp::OpCompute,           OB, mesh, "&& selcount=1 && hasAlgo && isComputable" );
-  createPopupItem( SMESHOp::OpRecompute,         OB, mesh, "&& selcount=1 && hasAlgo && " + isNotEmpty );
+  createPopupItem( SMESHOp::OpRecompute,         OB, mesh, "&& selcount=1 && hasAlgo && (" + isNotEmpty + " || hasErrors )");
   createPopupItem( SMESHOp::OpShowErrors,        OB, mesh, "&& selcount=1 && hasErrors" );
   createPopupItem( SMESHOp::OpComputeSubMesh,    OB, subMesh, "&& selcount=1 && hasAlgo && isComputable" );
   createPopupItem( SMESHOp::OpPreCompute,        OB, mesh, "&& selcount=1 && hasAlgo && isPreComputable" );

src/SMESH_I/SMESH_Mesh_i.cxx

@@ -6584,10 +6584,13 @@ void findConcurrents(const SMESH_DimHyp* theDimHyp,
 }
 
 //-----------------------------------------------------------------------------
-void unionLists(TListOfInt&       theListOfId,
+bool unionLists(TListOfInt&       theListOfId,
                 TListOfListOfInt& theListOfListOfId,
                 const int         theIndx )
 {
+  bool changed = false;
+  if ( theListOfId.empty() )
+    return changed;
   TListOfListOfInt::iterator it = theListOfListOfId.begin();
   for ( int i = 0; it != theListOfListOfId.end(); it++, i++ )
   {
@@ -6603,11 +6606,15 @@ void unionLists(TListOfInt&       theListOfId,
     TListOfInt::iterator it2 = otherListOfId.begin();
     for ( ; it2 != otherListOfId.end(); it2++ ) {
       if ( find( theListOfId.begin(), theListOfId.end(), (*it2) ) == theListOfId.end() )
+      {
         theListOfId.push_back(*it2);
+        changed = true;
+      }
     }
     // clear source list
     otherListOfId.clear();
   }
+  return changed;
 }
 //-----------------------------------------------------------------------------
 
@@ -6691,10 +6698,15 @@ SMESH::submesh_array_array* SMESH_Mesh_i::GetMeshOrder()
   TListOfListOfInt allConurrent = findConcurrentSubMeshes();
   anOrder.splice( anOrder.end(), allConurrent );
 
-  int listIndx = 0;
+  bool changed;
+  do {
+    changed = false;
     TListOfListOfInt::iterator listIt = anOrder.begin();
-  for(; listIt != anOrder.end(); listIt++, listIndx++ )
+    for ( int listIndx = 1; listIt != anOrder.end(); listIt++, listIndx++ )
-    unionLists( *listIt,  anOrder, listIndx + 1 );
+      if ( unionLists( *listIt,  anOrder, listIndx ))
+        changed = true;
+  }
+  while ( changed );
 
   // convert submesh ids into interface instances
   //  and dump command into python

src/StdMeshers/StdMeshers_Prism_3D.cxx

@@ -1841,6 +1841,8 @@ bool StdMeshers_Prism_3D::computeWalls(const Prism_3D::TPrismTopo& thePrism)
           mesh->GetSubMesh( v )->ComputeStateEngine( SMESH_subMesh::COMPUTE );
           const SMDS_MeshNode* n = SMESH_Algo::VertexNode( v, meshDS );
           newNodes[ is2ndV ? newNodes.size()-1 : 0 ] = (SMDS_MeshNode*) n;
+          if ( !n )
+            return toSM( error( TCom("No node on vertex #") << meshDS->ShapeToIndex( v )));
         }
 
         // compute nodes on target EDGEs