23068: [CEA 1505] Be able to keep meshing in 2D after having merged the nodes in 1D

    In SMESH_subMesh::ComputeStateEngine() transform errors into warnings if it is caused by mesh edition

Regression of SALOME_TESTS/Grids/smesh/2D_submesh_00/A7
    fix SMESH_subMesh::cleanDependsOn()

Regression of SALOME_TESTS/Grids/smesh/imps_02/C4
    fix getSubMeshes() in SMESH_subMesh_i.cxx and use it in all cases

Regression SALOME_TESTS/Grids/smesh/mesh_Projection_2D_01/B1
    In StdMeshers_Projection_2D treat coincident nodes in all cases

diff --git a/src/SMESH/SMESH_subMesh.cxx b/src/SMESH/SMESH_subMesh.cxx
index 64ee5948de5d9b569196bac7497813a26fbc6389..9618871bd7211bc5ed2b269dbc58772929d68fb3 100644 (file)
--- a/src/SMESH/SMESH_subMesh.cxx
+++ b/src/SMESH/SMESH_subMesh.cxx
@@ -241,7 +241,7 @@ bool SMESH_subMesh::IsMeshComputed() const
 {
   if ( _alwaysComputed )
     return true;
 {
   if ( _alwaysComputed )
     return true;

-  // algo may bind a submesh not to _subShape, eg 3D algo
+  // algo may bind a sub-mesh not to _subShape, eg 3D algo

   // sets nodes on SHELL while _subShape may be SOLID
 
   SMESHDS_Mesh* meshDS = _father->GetMeshDS();
   // sets nodes on SHELL while _subShape may be SOLID
 
   SMESHDS_Mesh* meshDS = _father->GetMeshDS();


@@ -280,7 +280,7 @@ bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const
   int dimToCheck = myDim - 1;
   bool subMeshesComputed = true;
   if ( isFailedToCompute ) *isFailedToCompute = false;
   int dimToCheck = myDim - 1;
   bool subMeshesComputed = true;
   if ( isFailedToCompute ) *isFailedToCompute = false;

-  // check subMeshes with upper dimension => reverse iteration
+  // check sub-meshes with upper dimension => reverse iteration

   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
   while ( smIt->more() )
   {
   SMESH_subMeshIteratorPtr smIt = getDependsOnIterator(false,true);
   while ( smIt->more() )
   {


@@ -291,67 +291,22 @@ bool SMESH_subMesh::SubMeshesComputed(bool * isFailedToCompute/*=0*/) const
 
     // 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,
 
     // 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.
+    // degenerated edges may have no sub-mesh, as after computing NETGEN_2D.

     if ( !_algo || _algo->NeedDiscreteBoundary() ) {
       int dim = SMESH_Gen::GetShapeDim( ss );
       if (dim < dimToCheck)
     if ( !_algo || _algo->NeedDiscreteBoundary() ) {
       int dim = SMESH_Gen::GetShapeDim( ss );
       if (dim < dimToCheck)

-        break; // the rest subMeshes are all of less dimension
+        break; // the rest sub-meshes are all of less dimension

     }
     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();
     }
     SMESHDS_SubMesh * ds = sm->GetSubMeshDS();

-    bool computeOk = (sm->GetComputeState() == COMPUTE_OK ||
-                      (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes()  )));
+    bool computeOk = ((sm->GetComputeState() == COMPUTE_OK ) ||
+                      (ds && ( dimToCheck ? ds->NbElements() : ds->NbNodes() )));

     if (!computeOk)
     {
       subMeshesComputed = false;
     if (!computeOk)
     {
       subMeshesComputed = false;

+

       if ( isFailedToCompute && !(*isFailedToCompute) )
         *isFailedToCompute = ( sm->GetComputeState() == FAILED_TO_COMPUTE );
 
       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;
     }
       if ( !isFailedToCompute )
         break;
     }


@@ -1254,7 +1209,7 @@ void SMESH_subMesh::cleanDependsOn( SMESH_Algo* algoRequiringCleaning/*=0*/ )
         // remember all sub-meshes of sm
         if ( keepSubMeshes )
         {
         // remember all sub-meshes of sm
         if ( keepSubMeshes )
         {

-          SMESH_subMeshIteratorPtr smIt2 = getDependsOnIterator(false);
+          SMESH_subMeshIteratorPtr smIt2 = sm->getDependsOnIterator(false);

           while ( smIt2->more() )
             smToKeep.insert( smIt2->next() );
         }
           while ( smIt2->more() )
             smToKeep.insert( smIt2->next() );
         }


@@ -1624,6 +1579,36 @@ bool SMESH_subMesh::ComputeStateEngine(compute_event event)
           _computeError.reset();
         }
 
           _computeError.reset();
         }
 

+        // transform errors into warnings if it is caused by mesh edition (imp 0023068)
+        if (!ret && _father->GetIsModified() )
+        {
+          for (subS.ReInit(); subS.More(); subS.Next())
+          {
+            SMESH_subMesh* sm = _father->GetSubMesh( subS.Current() );
+            if ( !sm->IsMeshComputed() && sm->_computeError )
+            {
+              // check if there is a VERTEX w/o nodes
+              // with READY_TO_COMPUTE state (after MergeNodes())
+              SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(false,false);
+              while ( smIt->more() )
+              {
+                SMESH_subMesh * vertSM = smIt->next();
+                if ( vertSM->_subShape.ShapeType() != TopAbs_VERTEX ) break;
+                if ( vertSM->GetComputeState() == READY_TO_COMPUTE )
+                {
+                  SMESHDS_SubMesh * ds = vertSM->GetSubMeshDS();
+                  if ( !ds || ds->NbNodes() == 0 )
+                  {
+                    sm->_computeState = READY_TO_COMPUTE;
+                    sm->_computeError->myName = COMPERR_WARNING;
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+

         // send event SUBMESH_COMPUTED
         if ( ret ) {
           if ( !algo->NeedDiscreteBoundary() )
         // send event SUBMESH_COMPUTED
         if ( ret ) {
           if ( !algo->NeedDiscreteBoundary() )

diff --git a/src/SMESH/SMESH_subMesh.hxx b/src/SMESH/SMESH_subMesh.hxx
index 331d701605dde9394c93afe155d86fcb91b9d666..8de40d2225c70f6e1201a16f47799e94fec9850a 100644 (file)
--- a/src/SMESH/SMESH_subMesh.hxx
+++ b/src/SMESH/SMESH_subMesh.hxx
@@ -96,8 +96,7 @@ class SMESH_EXPORT SMESH_subMesh
 
   enum compute_state
   {
 
   enum compute_state
   {

-    NOT_READY, READY_TO_COMPUTE,
-    COMPUTE_OK, FAILED_TO_COMPUTE
+    NOT_READY, READY_TO_COMPUTE, COMPUTE_OK, FAILED_TO_COMPUTE

   };
   enum algo_state
   {
   };
   enum algo_state
   {


@@ -123,7 +122,7 @@ class SMESH_EXPORT SMESH_subMesh
   };
 
   // ==================================================================
   };
 
   // ==================================================================

-  // Members to track non hierarchical dependencies between submeshes 
+  // Members to track non hierarchical dependencies between sub-meshes 

   // ==================================================================
 
   /*!
   // ==================================================================
 
   /*!

diff --git a/src/SMESH_I/SMESH_subMesh_i.cxx b/src/SMESH_I/SMESH_subMesh_i.cxx
index 7f86e0ddc1a60093c9554b80b1f288ecf7d2257c..a660013ed3b98aca2e1b523398a7c3c2c8bd1056 100644 (file)
--- a/src/SMESH_I/SMESH_subMesh_i.cxx
+++ b/src/SMESH_I/SMESH_subMesh_i.cxx
@@ -29,14 +29,13 @@
 #include "SMESH_Gen_i.hxx"
 #include "SMESH_Mesh_i.hxx"
 #include "SMESH_PreMeshInfo.hxx"
 #include "SMESH_Gen_i.hxx"
 #include "SMESH_Mesh_i.hxx"
 #include "SMESH_PreMeshInfo.hxx"

+#include "SMESH_MesherHelper.hxx"

 
 #include "Utils_CorbaException.hxx"
 #include "utilities.h"
 #include "OpUtil.hxx"
 #include "Utils_ExceptHandlers.hxx"
 
 
 #include "Utils_CorbaException.hxx"
 #include "utilities.h"
 #include "OpUtil.hxx"
 #include "Utils_ExceptHandlers.hxx"
 

-#include <TopExp_Explorer.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>

 #include <TopoDS_Iterator.hxx>
 
 using namespace std;
 #include <TopoDS_Iterator.hxx>
 
 using namespace std;


@@ -97,99 +96,37 @@ bool getSubMeshes(::SMESH_subMesh*  theSubMesh,
 {
   size_t size = theSubMeshList.size();
 
 {
   size_t size = theSubMeshList.size();
 

-  SMESH_Mesh*      aMesh      = theSubMesh->GetFather();
-  SMESHDS_Mesh*    aMeshDS    = aMesh->GetMeshDS();
-  SMESHDS_SubMesh* aSubMeshDS = theSubMesh->GetSubMeshDS();
-  ::SMESH_subMesh* sm;
-
-  // nodes can be bound to either vertex, edge, face or solid_or_shell
-  TopoDS_Shape         aShape = theSubMesh->GetSubShape();
-  TopAbs_ShapeEnum aShapeType = aShape.ShapeType();
-
-  // IPAL18558: Wrong information of the created sub-mesh is shown. (Sub-mesh on a FACE
-  // with only 1D algo assigned)
-  // Find dimension of sub-meshes to return as highest dimension of the assigned algorithm
-  if (( theSubMesh->IsEmpty() || ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )) &&
-      ( !theSubMesh->GetAlgo() ))
+  // check all child sub-meshes of one complexity,
+  // if no elements found and no algo assigned, go to children of lower complexity
+
+  TopoDS_Shape            shape = theSubMesh->GetSubShape();
+  TopAbs_ShapeEnum     mainType = SMESH_MesherHelper::GetGroupType( shape, /*noCompound=*/true );
+  TopAbs_ShapeEnum    shapeType = shape.ShapeType();
+  bool            elementsFound = false;
+  bool                algoFound = false;
+  SMESH_subMeshIteratorPtr smIt = theSubMesh->getDependsOnIterator(/*includeSelf=*/true,
+                                                                   /*complexFirst=*/true);
+  while ( smIt->more() )

   {
   {

-    // on father sub-meshes, check presence of an algo which will mesh this sub-mesh
-    // even if no algo is assigned to this sub-mesh
-    bool topAlgoPresent = false;
-    TopTools_ListIteratorOfListOfShape ancestors( aMesh->GetAncestors( aShape ));
-    for ( ; ancestors.More() && !topAlgoPresent; ancestors.Next() )
-      if (( sm = aMesh->GetSubMeshContaining( ancestors.Value() )))
-        topAlgoPresent = ( sm->GetAlgo() && !sm->GetAlgo()->NeedDiscreteBoundary() );
-
-    if ( !topAlgoPresent )
+    ::SMESH_subMesh* sm = smIt->next();
+    if ( sm->GetSubShape().ShapeType() != shapeType )

     {
     {

-      // find max dimension of an assigned algo
-      TopAbs_ShapeEnum algoShape = TopAbs_SHAPE;
-      const std::list <const SMESHDS_Hypothesis * >& hyps = aMesh->GetHypothesisList( aShape );
-      std::list <const SMESHDS_Hypothesis * >::const_iterator hypIt = hyps.begin();
-      for ( ; hypIt != hyps.end(); ++hypIt )
-        if ( const SMESH_Algo* algo = dynamic_cast< const SMESH_Algo* >( *hypIt ))
-          switch ( algo->GetDim() ) {
-          case 1: algoShape = TopAbs_EDGE; break;
-          case 2: algoShape = TopAbs_FACE; break;
-          case 3: algoShape = TopAbs_SOLID; break;
-          case 0: algoShape = TopAbs_VERTEX; break;
-          }
-      if ( algoShape != TopAbs_SHAPE )
-      {
-        // return all sub-meshes on this dimension
-        SMESH_subMeshIteratorPtr smIt = theSubMesh->getDependsOnIterator(/*includeSelf=*/false);
-        while ( smIt->more() )
-        {
-          sm = smIt->next();
-          if ( sm->GetSubShape().ShapeType() == algoShape && sm->GetSubMeshDS() )
-            theSubMeshList.push_back( sm->GetSubMeshDS() );
-        }
-        return size < theSubMeshList.size();
-      }
+      if ( elementsFound || algoFound )
+        break;
+      if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX &&
+           mainType != TopAbs_VERTEX )
+        break;

     }
     }

-  }
-
-  switch ( aShapeType )
-  {
-  case TopAbs_SOLID:
-  {
-    // add sub-mesh of solid itself
-    if (( aSubMeshDS = aMeshDS->MeshElements( aShape )))
-      theSubMeshList.push_back( aSubMeshDS );
-
-    // and of the first shell
-    TopExp_Explorer exp( aShape, TopAbs_SHELL );
-    if ( exp.More() )
-      if (( aSubMeshDS = aMeshDS->MeshElements( exp.Current() )))
-        theSubMeshList.push_back( aSubMeshDS );
-    break;
-  }
-  case TopAbs_WIRE:
-  case TopAbs_COMPOUND:
-  case TopAbs_COMPSOLID:
-  {
-    // call getSubMeshes() for sub-shapes
-    list<TopoDS_Shape> shapeList;
-    shapeList.push_back( aShape );
-    list<TopoDS_Shape>::iterator sh = shapeList.begin();
-    for ( ; sh != shapeList.end(); ++sh ) {
-      for ( TopoDS_Iterator it( *sh ); it.More(); it.Next() ) {
-        if (( sm = aMesh->GetSubMeshContaining( it.Value() )))
-          getSubMeshes( sm, theSubMeshList ); // add found sub-mesh or explore deeper
-        else
-          // no submesh for a compound inside compound
-          shapeList.push_back( it.Value() );
-      }
+    shapeType = sm->GetSubShape().ShapeType();
+    if ( !sm->IsEmpty() )
+    {
+      elementsFound = true;
+      theSubMeshList.push_back( sm->GetSubMeshDS() );

     }
     }

-    // return only unique sub-meshes
-    set<SMESHDS_SubMesh*> smSet( theSubMeshList.begin(), theSubMeshList.end() );
-    theSubMeshList.assign( smSet.begin(), smSet.end() );
-    break;
-  }
-  default:
-    if ( aSubMeshDS )
-      theSubMeshList.push_back( aSubMeshDS );
+    if ( sm->GetAlgo() )
+      algoFound = true;

   }
   }

+

   return size < theSubMeshList.size();
 }
 
   return size < theSubMeshList.size();
 }
 


@@ -211,15 +148,11 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfElements()
     return 0;
 
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];
     return 0;
 
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];

-  SMESHDS_SubMesh* aSubMeshDS = aSubMesh->GetSubMeshDS();
-  if ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )
-    aSubMeshDS = 0;

 
 

-  int nbElems = aSubMeshDS ? aSubMeshDS->NbElements() : 0;
+  int nbElems = 0;

 
 

-  // volumes are bound to shell

   TListOfSubMeshes smList;
   TListOfSubMeshes smList;

-  if ( nbElems == 0 && getSubMeshes( aSubMesh, smList ))
+  if ( getSubMeshes( aSubMesh, smList ))

   {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( ; sm != smList.end(); ++sm )
   {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( ; sm != smList.end(); ++sm )


@@ -249,8 +182,6 @@ CORBA::Long SMESH_subMesh_i::GetNumberOfNodes(CORBA::Boolean all)
   }
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];
   SMESHDS_SubMesh* aSubMeshDS = aSubMesh->GetSubMeshDS();
   }
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];
   SMESHDS_SubMesh* aSubMeshDS = aSubMesh->GetSubMeshDS();

-  if ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )
-    aSubMeshDS = 0;

 
   if ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )
   {
 
   if ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )
   {


@@ -298,17 +229,10 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsId()
     _preMeshInfo->FullLoadFromFile();
 
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];
     _preMeshInfo->FullLoadFromFile();
 
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];

-  SMESHDS_SubMesh* aSubMeshDS = aSubMesh->GetSubMeshDS();
-  if ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )
-    aSubMeshDS = 0;

 
 

-  int nbElems = aSubMeshDS ? aSubMeshDS->NbElements() : 0;
+  int nbElems = 0;

   TListOfSubMeshes smList;
   TListOfSubMeshes smList;

-  if ( nbElems )
-    smList.push_back( aSubMeshDS );
-
-  // volumes are bound to shell
-  if ( nbElems == 0 && getSubMeshes( aSubMesh, smList ))
+  if ( getSubMeshes( aSubMesh, smList ))

   {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( ; sm != smList.end(); ++sm )
   {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( ; sm != smList.end(); ++sm )


@@ -350,17 +274,14 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theEle
     _preMeshInfo->FullLoadFromFile();
 
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];
     _preMeshInfo->FullLoadFromFile();
 
   ::SMESH_subMesh* aSubMesh = _mesh_i->_mapSubMesh[_localId];

-  SMESHDS_SubMesh* aSubMeshDS = aSubMesh->GetSubMeshDS();
-  if ( aSubMeshDS && aSubMeshDS->IsComplexSubmesh() )
-    aSubMeshDS = 0;

 
 

-  // PAL5440, return all nodes belonging to elements of submesh
+  // PAL5440, return all nodes belonging to elements of the sub-mesh

   set<int> nodeIds;
   set<int> nodeIds;

-  int nbElems = aSubMeshDS ? aSubMeshDS->NbElements() : 0;
+  int nbElems = 0;

 
   // volumes may be bound to shell instead of solid
   TListOfSubMeshes smList;
 
   // volumes may be bound to shell instead of solid
   TListOfSubMeshes smList;

-  if ( nbElems == 0 && getSubMeshes( aSubMesh, smList ))
+  if ( getSubMeshes( aSubMesh, smList ))

   {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( ; sm != smList.end(); ++sm )
   {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( ; sm != smList.end(); ++sm )


@@ -386,29 +307,6 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theEle
         nbElems += (*sm)->NbElements();
       }
     }
         nbElems += (*sm)->NbElements();
       }
     }

-    aSubMeshDS = 0;
-  }
-  else
-  {
-    if ( nbElems )
-      smList.push_back( aSubMeshDS );
-  }
-
-  if ( theElemType == SMESH::NODE && aSubMeshDS )
-  {
-    SMDS_ElemIteratorPtr eIt = aSubMeshDS->GetElements();
-    if ( eIt->more() ) {
-      while ( eIt->more() ) {
-        const SMDS_MeshElement* anElem = eIt->next();
-        SMDS_ElemIteratorPtr nIt = anElem->nodesIterator();
-        while ( nIt->more() )
-          nodeIds.insert( nIt->next()->GetID() );
-      }
-    } else {
-      SMDS_NodeIteratorPtr nIt = aSubMeshDS->GetNodes();
-      while ( nIt->more() )
-        nodeIds.insert( nIt->next()->GetID() );
-    }

   }
 
   if ( theElemType == SMESH::NODE )
   }
 
   if ( theElemType == SMESH::NODE )


@@ -428,8 +326,7 @@ SMESH::long_array* SMESH_subMesh_i::GetElementsByType( SMESH::ElementType theEle
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( i = 0; sm != smList.end(); sm++ )
     {
     TListOfSubMeshes::iterator sm = smList.begin();
     for ( i = 0; sm != smList.end(); sm++ )
     {

-      aSubMeshDS = *sm;
-      SMDS_ElemIteratorPtr anIt = aSubMeshDS->GetElements();
+      SMDS_ElemIteratorPtr anIt = (*sm)->GetElements();

       while ( i < n && anIt->more() ) {
         const SMDS_MeshElement* anElem = anIt->next();
         if ( theElemType == SMESH::ALL || anElem->GetType() == (SMDSAbs_ElementType)theElemType )
       while ( i < n && anIt->more() ) {
         const SMDS_MeshElement* anElem = anIt->next();
         if ( theElemType == SMESH::ALL || anElem->GetType() == (SMDSAbs_ElementType)theElemType )

diff --git a/src/StdMeshers/StdMeshers_Projection_2D.cxx b/src/StdMeshers/StdMeshers_Projection_2D.cxx
index fed12f5a5d8c0e03cec39371e51595f7aaf55a9e..c4375bac9c1a8c222681114520f69cca6dda863e 100644 (file)
--- a/src/StdMeshers/StdMeshers_Projection_2D.cxx
+++ b/src/StdMeshers/StdMeshers_Projection_2D.cxx
@@ -1437,6 +1437,9 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
     if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
       return error("Can't make mesh by source mesh pattern");
 
     if ( mapper.GetErrorCode() != SMESH_Pattern::ERR_OK )
       return error("Can't make mesh by source mesh pattern");
 

+  } // end of projection using Pattern mapping
+
+  {

     // -------------------------------------------------------------------------
     // mapper doesn't take care of nodes already existing on edges and vertices,
     // so we must merge nodes created by it with existing ones
     // -------------------------------------------------------------------------
     // mapper doesn't take care of nodes already existing on edges and vertices,
     // so we must merge nodes created by it with existing ones


@@ -1476,7 +1479,7 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
         continue; // do not treat sm of degen VERTEX
       }
 
         continue; // do not treat sm of degen VERTEX
       }
 

-      // Sort new and old nodes of a submesh separately
+      // Sort new and old nodes of a sub-mesh separately

 
       bool isSeam = helper.IsRealSeam( sm->GetId() );
 
 
       bool isSeam = helper.IsRealSeam( sm->GetId() );
 


@@ -1600,6 +1603,7 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
     // The mapper can't create quadratic elements, so convert if needed
     // ----------------------------------------------------------------
 
     // The mapper can't create quadratic elements, so convert if needed
     // ----------------------------------------------------------------
 

+    SMDS_ElemIteratorPtr faceIt;

     faceIt         = srcSubMesh->GetSubMeshDS()->GetElements();
     bool srcIsQuad = faceIt->next()->IsQuadratic();
     faceIt         = tgtSubMesh->GetSubMeshDS()->GetElements();
     faceIt         = srcSubMesh->GetSubMeshDS()->GetElements();
     bool srcIsQuad = faceIt->next()->IsQuadratic();
     faceIt         = tgtSubMesh->GetSubMeshDS()->GetElements();


@@ -1613,8 +1617,7 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
 
       editor.ConvertToQuadratic(/*theForce3d=*/false, tgtFaces, false);
     }
 
       editor.ConvertToQuadratic(/*theForce3d=*/false, tgtFaces, false);
     }

-
-  } // end of projection using Pattern mapping
+  } // end of coincident nodes and quadratic elements treatment

 
 
   if ( !projDone || is1DComputed )
 
 
   if ( !projDone || is1DComputed )