22806: EDF SMESH: Regression: Prism_3D error

[modules/smesh.git] / src / SMESH / SMESH_Gen.cxx

diff --git a/src/SMESH/SMESH_Gen.cxx b/src/SMESH/SMESH_Gen.cxx
index c8ba34bc33dc1d07aa213dab65459e05aeb88408..864f50c21449346cb49b5ccccdfd2e718d5b4af9 100644 (file)
--- a/src/SMESH/SMESH_Gen.cxx
+++ b/src/SMESH/SMESH_Gen.cxx
@@ -232,7 +232,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
       if ( aShapesId && aShapeDim > (int)aDim )
         continue;
 
-      SMESH_Algo* algo = GetAlgo( aMesh, aSubShape, &algoShape );
+      SMESH_Algo* algo = GetAlgo( smToCompute, &algoShape );
       if ( algo && !algo->NeedDiscreteBoundary() )
       {
         if ( algo->SupportSubmeshes() )
@@ -288,27 +288,27 @@ 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 ))
+        if ( !GetAlgo( sm, & algoShape ))
           continue; // strange...
 
         // look for more local algos
@@ -331,7 +331,8 @@ bool SMESH_Gen::Compute(SMESH_Mesh &          aMesh,
             .And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
             .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh ));
 
-          if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
+          if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true))
+          {
             if ( ! subAlgo->NeedDiscreteBoundary() ) continue;
             SMESH_Hypothesis::Hypothesis_Status status;
             if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
@@ -343,10 +344,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();
@@ -478,7 +478,7 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
       const int aShapeDim = GetShapeDim( aSubShape );
       if ( aShapeDim < 1 ) break;
       
-      SMESH_Algo* algo = GetAlgo( aMesh, aSubShape );
+      SMESH_Algo* algo = GetAlgo( smToCompute );
       if ( algo && !algo->NeedDiscreteBoundary() ) {
         if ( algo->SupportSubmeshes() ) {
           smWithAlgoSupportingSubmeshes.push_front( smToCompute );
@@ -494,22 +494,22 @@ 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;
-      if ( !GetAlgo( aMesh, sm->GetSubShape(), & algoShape ))
+      if ( !GetAlgo( sm, & algoShape ))
         continue; // strange...
 
       // look for more local algos
@@ -526,7 +526,8 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh &          aMesh,
           .And( SMESH_HypoFilter::IsApplicableTo( aSubShape ))
           .And( SMESH_HypoFilter::IsMoreLocalThan( algoShape, aMesh ));
 
-        if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( aSubShape, filter, true )) {
+        if ( SMESH_Algo* subAlgo = (SMESH_Algo*) aMesh.GetHypothesis( smToCompute, filter, true ))
+        {
           if ( ! subAlgo->NeedDiscreteBoundary() ) continue;
           SMESH_Hypothesis::Hypothesis_Status status;
           if ( subAlgo->CheckHypothesis( aMesh, aSubShape, status ))
@@ -538,9 +539,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() );
@@ -1014,6 +1015,23 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh &         aMesh,
                                const TopoDS_Shape & aShape,
                                TopoDS_Shape*        assignedTo)
 {
+  return GetAlgo( aMesh.GetSubMesh( aShape ), assignedTo );
+}
+
+//=============================================================================
+/*!
+ * Finds algo to mesh a sub-mesh. Optionally returns a shape the found algo is bound to
+ */
+//=============================================================================
+
+SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_subMesh * aSubMesh,
+                               TopoDS_Shape*   assignedTo)
+{
+  if ( !aSubMesh ) return 0;
+
+  const TopoDS_Shape & aShape = aSubMesh->GetSubShape();
+  SMESH_Mesh&          aMesh  = *aSubMesh->GetFather();
+
   SMESH_HypoFilter filter( SMESH_HypoFilter::IsAlgo() );
   filter.And( filter.IsApplicableTo( aShape ));
 
@@ -1021,7 +1039,7 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh &         aMesh,
 
   TopoDS_Shape assignedToShape;
   SMESH_Algo* algo =
-    (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape );
+    (SMESH_Algo*) aMesh.GetHypothesis( aSubMesh, filter, true, &assignedToShape );
 
   if ( algo &&
        aShape.ShapeType() == TopAbs_FACE &&
@@ -1036,7 +1054,7 @@ SMESH_Algo *SMESH_Gen::GetAlgo(SMESH_Mesh &         aMesh,
     filter.AndNot( filter.Is( algo ));
     TopoDS_Shape assignedToShape2;
     SMESH_Algo* algo2 =
-      (SMESH_Algo*) aMesh.GetHypothesis( aShape, filter, true, &assignedToShape2 );
+      (SMESH_Algo*) aMesh.GetHypothesis( aSubMesh, filter, true, &assignedToShape2 );
     if ( algo2 &&                                                  // algo found
          !assignedToShape2.IsSame( aMesh.GetShapeToMesh() ) &&     // algo is local
          ( SMESH_MesherHelper::GetGroupType( assignedToShape2 ) == // algo of the same level