Salome HOME
23207: EDF 11232 SMESH: viscou layers builder fails at the very fist inflation
authoreap <eap@opencascade.com>
Wed, 11 May 2016 13:55:05 +0000 (16:55 +0300)
committereap <eap@opencascade.com>
Wed, 11 May 2016 13:55:05 +0000 (16:55 +0300)
23190: EDF 11636 - Problem of viscous layer
Regression of SALOME_TESTS/Grids/smesh/viscous_layers_01/B2 - shrink fails

src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_MesherHelper.cxx
src/SMESH/SMESH_MesherHelper.hxx
src/SMESHDS/SMESHDS_SubMesh.cxx
src/SMESHUtils/SMESH_TypeDefs.hxx
src/StdMeshers/StdMeshers_FaceSide.cxx
src/StdMeshers/StdMeshers_FaceSide.hxx
src/StdMeshers/StdMeshers_ViscousLayers.cxx
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
src/StdMeshers/StdMeshers_ViscousLayers2D.hxx
src/StdMeshers_I/StdMeshers_ViscousLayers_i.cxx

index 4119c5f..746486f 100644 (file)
@@ -112,7 +112,7 @@ SMESH_Mesh::SMESH_Mesh(int               theLocalId,
                        SMESHDS_Document* theDocument):
   _groupId( 0 ), _nbSubShapes( 0 )
 {
-  MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
+  if(MYDEBUG) MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
   _id            = theLocalId;
   _studyId       = theStudyId;
   _gen           = theGen;
@@ -179,7 +179,7 @@ namespace
 
 SMESH_Mesh::~SMESH_Mesh()
 {
-  MESSAGE("SMESH_Mesh::~SMESH_Mesh");
+  if(MYDEBUG) MESSAGE("SMESH_Mesh::~SMESH_Mesh");
 
   // avoid usual removal of elements while processing RemoveHypothesis( algo ) event
   SMESHDS_SubMeshIteratorPtr smIt = _myMeshDS->SubMeshes();
@@ -361,10 +361,19 @@ double SMESH_Mesh::GetShapeDiagonalSize(const TopoDS_Shape & aShape)
     int nbFaces = 0;
     for ( TopExp_Explorer f( aShape, TopAbs_FACE ); f.More() && nbFaces < maxNbFaces; f.Next() )
       ++nbFaces;
+    bool isPrecise = false;
     if ( nbFaces < maxNbFaces )
-      GEOMUtils::PreciseBoundingBox(aShape, Box);
-    else
-      BRepBndLib::Add( aShape, Box);
+      try {
+        GEOMUtils::PreciseBoundingBox( aShape, Box );
+        isPrecise = true;
+      }
+      catch (...) {
+        isPrecise = false;
+      }
+    if ( !isPrecise )
+    {
+      BRepBndLib::Add( aShape, Box );
+    }
     if ( !Box.IsVoid() )
       return sqrt( Box.SquareExtent() );
   }
index 3877d8a..913362e 100644 (file)
@@ -308,11 +308,18 @@ void SMESH_MesherHelper::SetSubShape(const TopoDS_Shape& aSh)
           {
             double f,l, r = 0.2345;
             Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface( edge, face, f, l );
-            uv2 = C2d->Value( f * r + l * ( 1.-r ));
-            if ( du < Precision::PConfusion() )
-              isSeam = ( Abs( uv1.Coord(1) - uv2.Coord(1) ) < Precision::PConfusion() );
+            if ( C2d.IsNull() )
+            {
+              isSeam = false;
+            }
             else
-              isSeam = ( Abs( uv1.Coord(2) - uv2.Coord(2) ) < Precision::PConfusion() );
+            {
+              uv2 = C2d->Value( f * r + l * ( 1.-r ));
+              if ( du < Precision::PConfusion() )
+                isSeam = ( Abs( uv1.Coord(1) - uv2.Coord(1) ) < Precision::PConfusion() );
+              else
+                isSeam = ( Abs( uv1.Coord(2) - uv2.Coord(2) ) < Precision::PConfusion() );
+            }
           }
         }
         if ( isSeam )
@@ -653,8 +660,7 @@ gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face&   F,
       {
         if ( !IsSubShape( V, F ))
         {
-          MESSAGE ( "SMESH_MesherHelper::GetNodeUV(); Vertex " << vertexID
-                    << " not in face " << GetMeshDS()->ShapeToIndex( F ) );
+          MESSAGE("GetNodeUV() Vertex "<< vertexID <<" not in face "<< GetMeshDS()->ShapeToIndex(F));
           // get UV of a vertex closest to the node
           double dist = 1e100;
           gp_Pnt pn = XYZ( n );
@@ -1073,7 +1079,6 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge&   E,
         }
         Quantity_Parameter U = projector->LowerDistanceParameter();
         u = double( U );
-        MESSAGE(" f " << f << " l " << l << " u " << u);
         curvPnt = curve->Value( u );
         dist = nodePnt.Distance( curvPnt );
         if ( distXYZ ) {
@@ -1083,8 +1088,7 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge&   E,
         }
         if ( dist > tol )
         {
-          MESSAGE( "SMESH_MesherHelper::CheckNodeU(), invalid projection" );
-          MESSAGE("distance " << dist << " " << tol );
+          MESSAGE( "CheckNodeU(), invalid projection; distance " << dist << "; tol " << tol );
           return false;
         }
         // store the fixed U on the edge
@@ -3049,8 +3053,6 @@ bool SMESH_MesherHelper::IsSubShape( const TopoDS_Shape& shape,
       if ( shape.IsSame( exp.Current() ))
         return true;
   }
-  SCRUTE((shape.IsNull()));
-  SCRUTE((mainShape.IsNull()));
   return false;
 }
 
@@ -5324,3 +5326,19 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
     }
   }
 }
+
+//================================================================================
+/*!
+ * \brief DEBUG
+ */
+//================================================================================
+
+void SMESH_MesherHelper::WriteShape(const TopoDS_Shape& s)
+{
+  const char* name = "/tmp/shape.brep";
+  BRepTools::Write( s, name );
+#ifdef _DEBUG_
+  std::cout << name << std::endl;
+#endif
+}
+
index fe888c7..834cd8e 100644 (file)
@@ -684,6 +684,8 @@ public:
   
   virtual ~SMESH_MesherHelper();
 
+  static void WriteShape(const TopoDS_Shape& s);
+
  protected:
 
   /*!
index 11dbb12..21d6da4 100644 (file)
@@ -154,7 +154,7 @@ bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDele
 
 //=======================================================================
 //function : AddNode
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
@@ -240,7 +240,7 @@ int SMESHDS_SubMesh::NbElements() const
 
 //=======================================================================
 //function : NbNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 int SMESHDS_SubMesh::NbNodes() const
@@ -299,10 +299,10 @@ public:
 
 template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
 {
- public:
+public:
   MyIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
     : myMore(false), mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() )
-    {}
+  {}
   bool more()
   {
     while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd)
@@ -320,11 +320,11 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
       elem = myElemIt->next();
     return elem;
   }
- protected:
+protected:
   virtual boost::shared_ptr< SMDS_Iterator<VALUE> >
-    getElements(const SMESHDS_SubMesh*) const = 0;
+  getElements(const SMESHDS_SubMesh*) const = 0;
 
- private:
+private:
   bool                                        myMore;
   set<const SMESHDS_SubMesh*>::const_iterator mySubIt, mySubEnd;
   boost::shared_ptr< SMDS_Iterator<VALUE> >   myElemIt;
@@ -336,7 +336,7 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
 
 class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
 {
- public:
+public:
   MyElemIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
     :MyIterator<const SMDS_MeshElement*>( theSubMeshes ) {}
   SMDS_ElemIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
@@ -349,28 +349,30 @@ class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
 
 class MyNodeIterator: public MyIterator<const SMDS_MeshNode*>
 {
- public:
+public:
   MyNodeIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
     :MyIterator<const SMDS_MeshNode*>( theSubMeshes ) {}
   SMDS_NodeIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
   { return theSubMesh->GetNodes(); }
 };
-  
+
 //=======================================================================
 //function : GetElements
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements() const
 {
   if ( IsComplexSubmesh() )
     return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes ));
-  return SMDS_ElemIteratorPtr(new MySetIterator<const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> >(myElements));
+
+  return SMDS_ElemIteratorPtr
+    (new MySetIterator<const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> >(myElements));
 }
 
 //=======================================================================
 //function : GetNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
@@ -378,7 +380,8 @@ SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
   if ( IsComplexSubmesh() )
     return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes ));
 
-  return SMDS_NodeIteratorPtr(new MySetIterator<const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> >(myNodes));
+  return SMDS_NodeIteratorPtr
+    (new MySetIterator<const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> >(myNodes));
 }
 
 //=======================================================================
@@ -444,7 +447,7 @@ bool SMESHDS_SubMesh::IsQuadratic() const
 
 //=======================================================================
 //function : AddSubMesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 void SMESHDS_SubMesh::AddSubMesh( const SMESHDS_SubMesh* theSubMesh )
@@ -503,6 +506,24 @@ SMESHDS_SubMeshIteratorPtr SMESHDS_SubMesh::GetSubMeshIterator() const
 
 void SMESHDS_SubMesh::Clear()
 {
+  if ( myParent && myParent->NbNodes() > 0 )
+  {
+    for ( size_t i = 0; i < myElements.size(); ++i )
+    {
+      if ( myElements[i] &&
+           myElements[i]->GetID() > 0 &&
+           myElements[i] == myParent->FindElement( myElements[i]->GetID() )) // not deleted
+        const_cast< SMDS_MeshElement* >( myElements[i] )->setShapeId( 0 );
+    }
+    for ( size_t i = 0; i < myNodes.size(); ++i )
+    {
+      if ( myNodes[i] &&
+           myNodes[i]->GetID() > 0 &&
+           myNodes[i] == myParent->FindNode( myNodes[i]->GetID() )) // not deleted
+        const_cast< SMDS_MeshNode* >( myNodes[i] )->setShapeId( 0 );
+    }
+  }
+
   clearVector( myElements );
   clearVector( myNodes );
   myUnusedIdNodes = 0;
@@ -530,12 +551,12 @@ void SMESHDS_SubMesh::compactList()
   {
     std::vector<const SMDS_MeshElement*> newElems;
     newElems.reserve( myElements.size() - myUnusedIdElements );
-    for (size_t i = 0; i < myElements.size(); i++)
-      if (myElements[i])
+    for ( size_t i = 0; i < myElements.size(); i++)
+      if ( myElements[i] )
       {
         SMDS_MeshElement* elem = (SMDS_MeshElement*)myElements[i];
-        elem->setIdInShape(newElems.size());
-        newElems.push_back(elem);
+        elem->setIdInShape( newElems.size() );
+        newElems.push_back( elem );
       }
     myElements.swap(newElems);
     myUnusedIdElements = 0;
@@ -545,12 +566,12 @@ void SMESHDS_SubMesh::compactList()
   {
     std::vector<const SMDS_MeshNode*> newNodes;
     newNodes.reserve( myNodes.size() - myUnusedIdNodes );
-    for (size_t i = 0; i < myNodes.size(); i++)
-      if (myNodes[i])
+    for ( size_t i = 0; i < myNodes.size(); i++ )
+      if ( myNodes[i] )
       {
         SMDS_MeshNode* node = (SMDS_MeshNode*)myNodes[i];
-        node->setIdInShape(newNodes.size());
-        newNodes.push_back(node);
+        node->setIdInShape( newNodes.size() );
+        newNodes.push_back( node );
       }
     myNodes.swap(newNodes);
     myUnusedIdNodes = 0;
index d73f8ca..77c095c 100644 (file)
@@ -186,6 +186,7 @@ typedef struct uvPtStruct
   uvPtStruct(): node(NULL) {}
 
   inline gp_XY UV() const { return gp_XY( u, v ); }
+  inline void  SetUV( const gp_XY& uv ) { u = uv.X(); v = uv.Y(); }
 
   struct NodeAccessor // accessor to iterate on nodes in UVPtStructVec
   {
index 470b5b6..ab76ddf 100644 (file)
@@ -144,7 +144,6 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face&      theFace,
         double p4 = myFirst[i]+(myLast[i]-myFirst[i])/4.;
         double d2 = GCPnts_AbscissaPoint::Length( A2dC, myFirst[i], p2 );
         double d4 = GCPnts_AbscissaPoint::Length( A2dC, myFirst[i], p4 );
-        //cout<<"len = "<<len<<"  d2 = "<<d2<<"  fabs(2*d2/len-1.0) = "<<fabs(2*d2/len-1.0)<<endl;
         myIsUniform[i] = !( fabs(2*d2/myEdgeLength[i]-1.0) > 0.01 || fabs(2*d4/d2-1.0) > 0.01 );
         Handle(Geom_Curve) C3d = BRep_Tool::Curve(myEdge[i],d2,d4);
         myC3dAdaptor[i].Load( C3d, d2,d4 );
@@ -232,9 +231,11 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const StdMeshers_FaceSide*  theSide,
 //================================================================================
 
 StdMeshers_FaceSide::StdMeshers_FaceSide(UVPtStructVec&     theSideNodes,
-                                         const TopoDS_Face& theFace)
+                                         const TopoDS_Face& theFace,
+                                         const TopoDS_Edge& theEdge,
+                                         SMESH_Mesh*        theMesh)
 {
-  myEdge.resize( 1 );
+  myEdge.resize( 1, theEdge );
   myEdgeID.resize( 1, -1 );
   myC2d.resize( 1 );
   myC3dAdaptor.resize( 1 );
@@ -244,6 +245,17 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(UVPtStructVec&     theSideNodes,
   myIsUniform.resize( 1, 1 );
   myMissingVertexNodes = myIgnoreMediumNodes = false;
   myDefaultPnt2d.SetCoord( 1e100, 1e100 );
+  if ( theMesh ) myProxyMesh.reset( new SMESH_ProxyMesh( *theMesh ));
+  if ( !theEdge.IsNull() )
+  {
+    if ( theMesh ) myEdgeID[0] = theMesh->GetMeshDS()->ShapeToIndex( theEdge );
+    if ( theFace.IsNull() )
+      BRep_Tool::Range( theEdge, myFirst[0], myLast[0] );
+    else
+      myC2d[0] = BRep_Tool::CurveOnSurface( theEdge, theFace, myFirst[0], myLast[0] );
+    if ( theEdge.Orientation() == TopAbs_REVERSED )
+      std::swap( myFirst[0], myLast[0] );
+  }
 
   myFace       = theFace;
   myPoints     = theSideNodes;
index 905a0bf..eb42bee 100644 (file)
@@ -97,7 +97,9 @@ public:
    * \brief Create a side from an UVPtStructVec
    */
   StdMeshers_FaceSide(UVPtStructVec&     theSideNodes,
-                      const TopoDS_Face& theFace = TopoDS_Face());
+                      const TopoDS_Face& theFace = TopoDS_Face(),
+                      const TopoDS_Edge& theEdge = TopoDS_Edge(),
+                      SMESH_Mesh*        theMesh = 0);
 
   // static "consrtuctors"
   static StdMeshers_FaceSidePtr New(const TopoDS_Face&   Face,
@@ -246,6 +248,10 @@ public:
    */
   const std::vector<TopoDS_Edge>& Edges() const { return myEdge; }
   /*!
+   * \brief Return the FACE
+   */
+  const TopoDS_Face& Face() const { return myFace; }
+  /*!
    * \brief Return 1st vertex of the i-th edge (count starts from zero)
    */
   TopoDS_Vertex FirstVertex(int i=0) const;
index 1e8d0f2..0c40b47 100644 (file)
 #include "SMESH_subMesh.hxx"
 #include "SMESH_subMeshEventListener.hxx"
 #include "StdMeshers_FaceSide.hxx"
+#include "StdMeshers_ViscousLayers2D.hxx"
 
 #include <Adaptor3d_HSurface.hxx>
+#include <BRepAdaptor_Curve.hxx>
 #include <BRepAdaptor_Curve2d.hxx>
 #include <BRepAdaptor_Surface.hxx>
 #include <BRepLProp_SLProps.hxx>
+#include <BRepOffsetAPI_MakeOffsetShape.hxx>
 #include <BRep_Tool.hxx>
 #include <Bnd_B2d.hxx>
 #include <Bnd_B3d.hxx>
 #include <ElCLib.hxx>
 #include <GCPnts_AbscissaPoint.hxx>
+#include <GCPnts_TangentialDeflection.hxx>
 #include <Geom2d_Circle.hxx>
 #include <Geom2d_Line.hxx>
 #include <Geom2d_TrimmedCurve.hxx>
@@ -70,6 +74,7 @@
 #include <TopExp_Explorer.hxx>
 #include <TopTools_IndexedMapOfShape.hxx>
 #include <TopTools_ListOfShape.hxx>
+#include <TopTools_MapIteratorOfMapOfShape.hxx>
 #include <TopTools_MapOfShape.hxx>
 #include <TopoDS.hxx>
 #include <TopoDS_Edge.hxx>
 #include <gp_Vec.hxx>
 #include <gp_XY.hxx>
 
-#include <list>
-#include <string>
 #include <cmath>
 #include <limits>
+#include <list>
+#include <queue>
+#include <string>
 
 #ifdef _DEBUG_
-//#define __myDEBUG
+#define __myDEBUG
 //#define __NOT_INVALIDATE_BAD_SMOOTH
 #endif
 
+#define INCREMENTAL_SMOOTH // smooth only if min angle is too small
+#define BLOCK_INFLATION // of individual _LayerEdge's
+#define OLD_NEF_POLYGON
+
 using namespace std;
 
 //================================================================================
@@ -102,6 +112,8 @@ namespace VISCOUS_3D
 
   const double theMinSmoothCosin = 0.1;
   const double theSmoothThickToElemSizeRatio = 0.3;
+  const double theMinSmoothTriaAngle = 30;
+  const double theMinSmoothQuadAngle = 45;
 
   // what part of thickness is allowed till intersection
   // (defined by SALOME_TESTS/Grids/smesh/viscous_layers_00/A5)
@@ -111,6 +123,10 @@ namespace VISCOUS_3D
   {
     return cosin * tgtThick > theSmoothThickToElemSizeRatio * elemSize;
   }
+  double getSmoothingThickness( double cosin, double elemSize )
+  {
+    return theSmoothThickToElemSizeRatio * elemSize / cosin;
+  }
 
   /*!
    * \brief SMESH_ProxyMesh computed by _ViscousBuilder for a SOLID.
@@ -184,8 +200,9 @@ namespace VISCOUS_3D
                               SMESH_subMeshEventListenerData* data,
                               const SMESH_Hypothesis*         hyp)
     {
-      if ( SMESH_subMesh::COMPUTE_EVENT       == eventType &&
-           SMESH_subMesh::CHECK_COMPUTE_STATE != event)
+      if (( SMESH_subMesh::COMPUTE_EVENT       == eventType ) &&
+          ( SMESH_subMesh::CHECK_COMPUTE_STATE != event &&
+            SMESH_subMesh::SUBMESH_COMPUTED    != event ))
       {
         // delete SMESH_ProxyMesh containing temporary faces
         subMesh->DeleteEventListener( this );
@@ -256,20 +273,25 @@ namespace VISCOUS_3D
              const SMDS_MeshNode* nNext=0,
              const SMDS_MeshNode* nOpp=0)
       : _nPrev(nPrev), _nNext(nNext), _nOpp(nOpp) {}
-    bool IsForward(const SMDS_MeshNode* nSrc, const gp_XYZ* pntTgt, double& vol) const
+    bool IsForward(const gp_XYZ* pntSrc, const gp_XYZ* pntTgt, double& vol) const
     {
       const double M[3][3] =
-        {{ _nNext->X() - nSrc->X(), _nNext->Y() - nSrc->Y(), _nNext->Z() - nSrc->Z() },
-         { pntTgt->X() - nSrc->X(), pntTgt->Y() - nSrc->Y(), pntTgt->Z() - nSrc->Z() },
-         { _nPrev->X() - nSrc->X(), _nPrev->Y() - nSrc->Y(), _nPrev->Z() - nSrc->Z() }};
-      vol = ( + M[0][0]*M[1][1]*M[2][2]
-              + M[0][1]*M[1][2]*M[2][0]
-              + M[0][2]*M[1][0]*M[2][1]
-              - M[0][0]*M[1][2]*M[2][1]
-              - M[0][1]*M[1][0]*M[2][2]
-              - M[0][2]*M[1][1]*M[2][0]);
+        {{ _nNext->X() - pntSrc->X(), _nNext->Y() - pntSrc->Y(), _nNext->Z() - pntSrc->Z() },
+         { pntTgt->X() - pntSrc->X(), pntTgt->Y() - pntSrc->Y(), pntTgt->Z() - pntSrc->Z() },
+         { _nPrev->X() - pntSrc->X(), _nPrev->Y() - pntSrc->Y(), _nPrev->Z() - pntSrc->Z() }};
+      vol = ( + M[0][0] * M[1][1] * M[2][2]
+              + M[0][1] * M[1][2] * M[2][0]
+              + M[0][2] * M[1][0] * M[2][1]
+              - M[0][0] * M[1][2] * M[2][1]
+              - M[0][1] * M[1][0] * M[2][2]
+              - M[0][2] * M[1][1] * M[2][0]);
       return vol > 1e-100;
     }
+    bool IsForward(const SMDS_MeshNode* nSrc, const gp_XYZ& pTgt, double& vol) const
+    {
+      SMESH_TNodeXYZ pSrc( nSrc );
+      return IsForward( &pSrc, &pTgt, vol );
+    }
     bool IsForward(const gp_XY&         tgtUV,
                    const SMDS_MeshNode* smoothedNode,
                    const TopoDS_Face&   face,
@@ -282,10 +304,50 @@ namespace VISCOUS_3D
       double d = v1 ^ v2;
       return d*refSign > 1e-100;
     }
+    bool IsMinAngleOK( const gp_XYZ& pTgt, double& minAngle ) const
+    {
+      SMESH_TNodeXYZ pPrev( _nPrev ), pNext( _nNext );
+      if ( !_nOpp ) // triangle
+      {
+        gp_Vec tp( pPrev - pTgt ), pn( pNext - pPrev ), nt( pTgt - pNext );
+        double tp2 = tp.SquareMagnitude();
+        double pn2 = pn.SquareMagnitude();
+        double nt2 = nt.SquareMagnitude();
+
+        if ( tp2 < pn2 && tp2 < nt2 )
+          minAngle = ( nt * -pn ) * ( nt * -pn ) / nt2 / pn2;
+        else if ( pn2 < nt2 )
+          minAngle = ( tp * -nt ) * ( tp * -nt ) / tp2 / nt2;
+        else
+          minAngle = ( pn * -tp ) * ( pn * -tp ) / pn2 / tp2;
+
+        static double theMaxCos2 = ( Cos( theMinSmoothTriaAngle * M_PI / 180. ) *
+                                     Cos( theMinSmoothTriaAngle * M_PI / 180. ));
+        return minAngle < theMaxCos2;
+      }
+      else // quadrangle
+      {
+        SMESH_TNodeXYZ pOpp( _nOpp );
+        gp_Vec tp( pPrev - pTgt ), po( pOpp - pPrev ), on( pNext - pOpp), nt( pTgt - pNext );
+        double tp2 = tp.SquareMagnitude();
+        double po2 = po.SquareMagnitude();
+        double on2 = on.SquareMagnitude();
+        double nt2 = nt.SquareMagnitude();
+        minAngle = Max( Max((( tp * -nt ) * ( tp * -nt ) / tp2 / nt2 ),
+                            (( po * -tp ) * ( po * -tp ) / po2 / tp2 )),
+                        Max((( on * -po ) * ( on * -po ) / on2 / po2 ),
+                            (( nt * -on ) * ( nt * -on ) / nt2 / on2 )));
+
+        static double theMaxCos2 = ( Cos( theMinSmoothQuadAngle * M_PI / 180. ) *
+                                     Cos( theMinSmoothQuadAngle * M_PI / 180. ));
+        return minAngle < theMaxCos2;
+      }
+    }
     bool IsNeighbour(const _Simplex& other) const
     {
       return _nPrev == other._nNext || _nNext == other._nPrev;
     }
+    bool Includes( const SMDS_MeshNode* node ) const { return _nPrev == node || _nNext == node; }
     static void GetSimplices( const SMDS_MeshNode* node,
                               vector<_Simplex>&   simplices,
                               const set<TGeomID>& ingnoreShapes,
@@ -299,9 +361,10 @@ namespace VISCOUS_3D
    */
   struct _Curvature
   {
-    double _r; // radius
-    double _k; // factor to correct node smoothed position
-    double _h2lenRatio; // avgNormProj / (2*avgDist)
+    double   _r; // radius
+    double   _k; // factor to correct node smoothed position
+    double   _h2lenRatio; // avgNormProj / (2*avgDist)
+    gp_Pnt2d _uv; // UV used in putOnOffsetSurface()
   public:
     static _Curvature* New( double avgNormProj, double avgDist )
     {
@@ -314,6 +377,8 @@ namespace VISCOUS_3D
         //c->_k = avgNormProj / c->_r;
         c->_k *= ( c->_r < 0 ? 1/1.1 : 1.1 ); // not to be too restrictive
         c->_h2lenRatio = avgNormProj / ( avgDist + avgDist );
+
+        c->_uv.SetCoord( 0., 0. );
       }
       return c;
     }
@@ -325,6 +390,7 @@ namespace VISCOUS_3D
   struct _2NearEdges;
   struct _LayerEdge;
   struct _EdgesOnShape;
+  struct _Smoother1D;
   typedef map< const SMDS_MeshNode*, _LayerEdge*, TIDCompare > TNode2Edge;
 
   //--------------------------------------------------------------------------------
@@ -338,23 +404,42 @@ namespace VISCOUS_3D
 
     vector< const SMDS_MeshNode*> _nodes;
 
-    gp_XYZ              _normal; // to solid surface
-    vector<gp_XYZ>      _pos; // points computed during inflation
-    double              _len; // length achived with the last inflation step
-    double              _cosin; // of angle (_normal ^ surface)
+    gp_XYZ              _normal;    // to boundary of solid
+    vector<gp_XYZ>      _pos;       // points computed during inflation
+    double              _len;       // length achived with the last inflation step
+    double              _maxLen;    // maximal possible length
+    double              _cosin;     // of angle (_normal ^ surface)
+    double              _minAngle;  // of _simplices
     double              _lenFactor; // to compute _len taking _cosin into account
+    int                 _flags;
 
-    // face or edge w/o layer along or near which _LayerEdge is inflated
-    //TopoDS_Shape*       _sWOL;
     // simplices connected to the source node (_nodes[0]);
     // used for smoothing and quality check of _LayerEdge's based on the FACE
     vector<_Simplex>    _simplices;
+    vector<_LayerEdge*> _neibors; // all surrounding _LayerEdge's
     PSmooFun            _smooFunction; // smoothing function
+    _Curvature*         _curvature;
     // data for smoothing of _LayerEdge's based on the EDGE
     _2NearEdges*        _2neibors;
 
-    _Curvature*         _curvature;
-    // TODO:: detele _Curvature, _plnNorm
+    enum EFlags { TO_SMOOTH       = 1,
+                  MOVED           = 2,   // set by _neibors[i]->SetNewLength()
+                  SMOOTHED        = 4,   // set by this->Smooth()
+                  DIFFICULT       = 8,   // near concave VERTEX
+                  ON_CONCAVE_FACE = 16,
+                  BLOCKED         = 32,  // not to inflate any more
+                  INTERSECTED     = 64,  // close intersection with a face found
+                  NORMAL_UPDATED  = 128,
+                  MARKED          = 256, // local usage
+                  MULTI_NORMAL    = 512, // a normal is invisible by some of surrounding faces
+                  NEAR_BOUNDARY   = 1024,// is near FACE boundary forcing smooth
+                  SMOOTHED_C1     = 2048,// is on _eosC1
+                  DISTORTED       = 4096,// was bad before smoothing
+                  RISKY_SWOL      = 8192 // SWOL is parallel to a source FACE
+    };
+    bool Is   ( EFlags f ) const { return _flags & f; }
+    void Set  ( EFlags f ) { _flags |= f; }
+    void Unset( EFlags f ) { _flags &= ~f; }
 
     void SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper );
     bool SetNewLength2d( Handle(Geom_Surface)& surface,
@@ -365,30 +450,57 @@ namespace VISCOUS_3D
                              const SMDS_MeshNode* n2,
                              const _EdgesOnShape& eos,
                              SMESH_MesherHelper&  helper);
-    void InvalidateStep( int curStep, const _EdgesOnShape& eos, bool restoreLength=false );
+    void Block( _SolidData& data );
+    void InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength=false );
     void ChooseSmooFunction(const set< TGeomID >& concaveVertices,
                             const TNode2Edge&     n2eMap);
-    int  Smooth(const int step, const bool isConcaveFace, const bool findBest);
-    bool SmoothOnEdge(Handle(Geom_Surface)& surface,
-                      const TopoDS_Face&    F,
-                      SMESH_MesherHelper&   helper);
+    void SmoothPos( const vector< double >& segLen, const double tol );
+    int  Smooth(const int step, const bool isConcaveFace, bool findBest);
+    int  Smooth(const int step, bool findBest, vector< _LayerEdge* >& toSmooth );
+    int  CheckNeiborsOnBoundary(vector< _LayerEdge* >* badNeibors = 0 );
+    void SmoothWoCheck();
+    bool SmoothOnEdge(Handle(ShapeAnalysis_Surface)& surface,
+                      const TopoDS_Face&             F,
+                      SMESH_MesherHelper&            helper);
+    void MoveNearConcaVer( const _EdgesOnShape*    eov,
+                           const _EdgesOnShape*    eos,
+                           const int               step,
+                           vector< _LayerEdge* > & badSmooEdges);
     bool FindIntersection( SMESH_ElementSearcher&   searcher,
                            double &                 distance,
                            const double&            epsilon,
                            _EdgesOnShape&           eos,
                            const SMDS_MeshElement** face = 0);
     bool SegTriaInter( const gp_Ax1&        lastSegment,
+                       const gp_XYZ&        p0,
+                       const gp_XYZ&        p1,
+                       const gp_XYZ&        p2,
+                       double&              dist,
+                       const double&        epsilon) const;
+    bool SegTriaInter( const gp_Ax1&        lastSegment,
                        const SMDS_MeshNode* n0,
                        const SMDS_MeshNode* n1,
                        const SMDS_MeshNode* n2,
                        double&              dist,
-                       const double&        epsilon) const;
+                       const double&        epsilon) const
+    { return SegTriaInter( lastSegment,
+                           SMESH_TNodeXYZ( n0 ), SMESH_TNodeXYZ( n1 ), SMESH_TNodeXYZ( n2 ),
+                           dist, epsilon );
+    }
+    const gp_XYZ& PrevPos() const { return _pos[ _pos.size() - 2 ]; }
+    const gp_XYZ& PrevCheckPos() const { return _pos[ Is( NORMAL_UPDATED ) ? _pos.size()-2 : 0 ]; }
     gp_Ax1 LastSegment(double& segLen, _EdgesOnShape& eos) const;
     gp_XY  LastUV( const TopoDS_Face& F, _EdgesOnShape& eos ) const;
     bool   IsOnEdge() const { return _2neibors; }
     gp_XYZ Copy( _LayerEdge& other, _EdgesOnShape& eos, SMESH_MesherHelper& helper );
     void   SetCosin( double cosin );
+    void   SetNormal( const gp_XYZ& n ) { _normal = n; }
     int    NbSteps() const { return _pos.size() - 1; } // nb inlation steps
+    bool   IsNeiborOnEdge( const _LayerEdge* edge ) const;
+    void   SetSmooLen( double len ) { // set _len at which smoothing is needed
+      _cosin = len; // as for _LayerEdge's on FACE _cosin is not used
+    }
+    double GetSmooLen() { return _cosin; } // for _LayerEdge's on FACE _cosin is not used
 
     gp_XYZ smoothLaplacian();
     gp_XYZ smoothAngular();
@@ -432,9 +544,9 @@ namespace VISCOUS_3D
     {
       return _inNorm * ( p - _pos ) < -tol;
     }
-    bool FindInterestion( const _halfPlane& hp, gp_XY & intPnt )
+    bool FindIntersection( const _halfPlane& hp, gp_XY & intPnt )
     {
-      const double eps = 1e-10;
+      //const double eps = 1e-10;
       double D = _dir.Crossed( hp._dir );
       if ( fabs(D) < std::numeric_limits<double>::min())
         return false;
@@ -467,6 +579,12 @@ namespace VISCOUS_3D
       std::swap( _wgt  [0], _wgt  [1] );
       std::swap( _edges[0], _edges[1] );
     }
+    void set( _LayerEdge* e1, _LayerEdge* e2, double w1, double w2 ) {
+      _edges[0] = e1; _edges[1] = e2; _wgt[0] = w1; _wgt[1] = w2;
+    }
+    bool include( const _LayerEdge* e ) {
+      return ( _edges[0] == e || _edges[1] == e );
+    }
   };
 
 
@@ -477,7 +595,7 @@ namespace VISCOUS_3D
   struct AverageHyp
   {
     AverageHyp( const StdMeshers_ViscousLayers* hyp = 0 )
-      :_nbLayers(0), _nbHyps(0), _thickness(0), _stretchFactor(0), _method(0)
+      :_nbLayers(0), _nbHyps(0), _method(0), _thickness(0), _stretchFactor(0)
     {
       Add( hyp );
     }
@@ -523,18 +641,32 @@ namespace VISCOUS_3D
     SMESH_subMesh *       _subMesh;
     // face or edge w/o layer along or near which _edges are inflated
     TopoDS_Shape          _sWOL;
+    bool                  _isRegularSWOL; // w/o singularities
     // averaged StdMeshers_ViscousLayers parameters
     AverageHyp            _hyp;
     bool                  _toSmooth;
+    _Smoother1D*          _edgeSmoother;
+    vector< _EdgesOnShape* > _eosConcaVer; // edges at concave VERTEXes of a FACE
+    vector< _EdgesOnShape* > _eosC1; // to smooth together several C1 continues shapes
 
-    vector< gp_XYZ >      _faceNormals; // if _shape is FACE
+    vector< gp_XYZ >         _faceNormals; // if _shape is FACE
     vector< _EdgesOnShape* > _faceEOS; // to get _faceNormals of adjacent FACEs
 
+    Handle(ShapeAnalysis_Surface) _offsetSurf;
+    _LayerEdge*                   _edgeForOffset;
+
+    _SolidData*            _data; // parent SOLID
+
     TopAbs_ShapeEnum ShapeType() const
     { return _shape.IsNull() ? TopAbs_SHAPE : _shape.ShapeType(); }
     TopAbs_ShapeEnum SWOLType() const
     { return _sWOL.IsNull() ? TopAbs_SHAPE : _sWOL.ShapeType(); }
+    bool             HasC1( const _EdgesOnShape* other ) const
+    { return std::find( _eosC1.begin(), _eosC1.end(), other ) != _eosC1.end(); }
     bool             GetNormal( const SMDS_MeshElement* face, gp_Vec& norm );
+    _SolidData&      GetData() const { return *_data; }
+
+    _EdgesOnShape(): _shapeID(-1), _subMesh(0), _toSmooth(false), _edgeSmoother(0) {}
   };
 
   //--------------------------------------------------------------------------------
@@ -547,7 +679,7 @@ namespace VISCOUS_3D
   {
     TopoDS_Face                     _face;
 
-    // edges whose _simplices are used to detect prism destorsion
+    // edges whose _simplices are used to detect prism distortion
     vector< _LayerEdge* >           _simplexTestEdges;
 
     // map a sub-shape to _SolidData::_edgesOnShape
@@ -564,6 +696,20 @@ namespace VISCOUS_3D
 
   //--------------------------------------------------------------------------------
   /*!
+   * \brief Structure holding _LayerEdge's based on EDGEs that will collide
+   *        at inflation up to the full thickness. A detected collision
+   *        is fixed in updateNormals()
+   */
+  struct _CollisionEdges
+  {
+    _LayerEdge*           _edge;
+    vector< _LayerEdge* > _intEdges; // each pair forms an intersected quadrangle
+    const SMDS_MeshNode* nSrc(int i) const { return _intEdges[i]->_nodes[0]; }
+    const SMDS_MeshNode* nTgt(int i) const { return _intEdges[i]->_nodes.back(); }
+  };
+
+  //--------------------------------------------------------------------------------
+  /*!
    * \brief Data of a SOLID
    */
   struct _SolidData
@@ -603,9 +749,9 @@ namespace VISCOUS_3D
 
     int                              _nbShapesToSmooth;
 
-    // <EDGE to smooth on> to <it's curve> -- for analytic smooth
-    map< TGeomID,Handle(Geom_Curve)> _edge2curve;
+    //map< TGeomID,Handle(Geom_Curve)> _edge2curve;
 
+    vector< _CollisionEdges >        _collisionEdges;
     set< TGeomID >                   _concaveFaces;
 
     double                           _maxThickness; // of all _hyps
@@ -613,23 +759,17 @@ namespace VISCOUS_3D
 
     double                           _epsilon; // precision for SegTriaInter()
 
+    SMESH_MesherHelper*              _helper;
+
     _SolidData(const TopoDS_Shape& s=TopoDS_Shape(),
                _MeshOfSolid*       m=0)
-      :_solid(s), _proxyMesh(m) {}
+      :_solid(s), _proxyMesh(m), _helper(0) {}
     ~_SolidData();
 
-    Handle(Geom_Curve) CurveForSmooth( const TopoDS_Edge&    E,
-                                       _EdgesOnShape&        eos,
-                                       SMESH_MesherHelper&   helper);
-
-    void SortOnEdge( const TopoDS_Edge&     E,
-                     vector< _LayerEdge* >& edges,
-                     SMESH_MesherHelper&    helper);
-
+    void SortOnEdge( const TopoDS_Edge& E, vector< _LayerEdge* >& edges);
     void Sort2NeiborsOnEdge( vector< _LayerEdge* >& edges );
 
-    _ConvexFace* GetConvexFace( const TGeomID faceID )
-    {
+    _ConvexFace* GetConvexFace( const TGeomID faceID ) {
       map< TGeomID, _ConvexFace >::iterator id2face = _convexFaces.find( faceID );
       return id2face == _convexFaces.end() ? 0 : & id2face->second;
     }
@@ -638,12 +778,38 @@ namespace VISCOUS_3D
     _EdgesOnShape* GetShapeEdges(const _LayerEdge*   edge )
     { return GetShapeEdges( edge->_nodes[0]->getshapeId() ); }
 
-    void AddShapesToSmooth( const set< _EdgesOnShape* >& shape );
+    SMESH_MesherHelper& GetHelper() const { return *_helper; }
+
+    void UnmarkEdges() {
+      for ( size_t i = 0; i < _edgesOnShape.size(); ++i )
+        for ( size_t j = 0; j < _edgesOnShape[i]._edges.size(); ++j )
+          _edgesOnShape[i]._edges[j]->Unset( _LayerEdge::MARKED );
+    }
+    void AddShapesToSmooth( const set< _EdgesOnShape* >& shape,
+                            const set< _EdgesOnShape* >* edgesNoAnaSmooth=0 );
 
     void PrepareEdgesToSmoothOnFace( _EdgesOnShape* eof, bool substituteSrcNodes );
   };
   //--------------------------------------------------------------------------------
   /*!
+   * \brief Offset plane used in getNormalByOffset()
+   */
+  struct _OffsetPlane
+  {
+    gp_Pln _plane;
+    int    _faceIndex;
+    int    _faceIndexNext[2];
+    gp_Lin _lines[2]; // line of intersection with neighbor _OffsetPlane's
+    bool   _isLineOK[2];
+    _OffsetPlane() {
+      _isLineOK[0] = _isLineOK[1] = false; _faceIndexNext[0] = _faceIndexNext[1] = -1;
+    }
+    void   ComputeIntersectionLine( _OffsetPlane& pln );
+    gp_XYZ GetCommonPoint(bool& isFound) const;
+    int    NbLines() const { return _isLineOK[0] + _isLineOK[1]; }
+  };
+  //--------------------------------------------------------------------------------
+  /*!
    * \brief Container of centers of curvature at nodes on an EDGE bounding _ConvexFace
    */
   struct _CentralCurveOnEdge
@@ -725,8 +891,8 @@ namespace VISCOUS_3D
                         set<TGeomID>&                   ignoreFaces);
     bool makeLayer(_SolidData& data);
     void setShapeData( _EdgesOnShape& eos, SMESH_subMesh* sm, _SolidData& data );
-    bool setEdgeData(_LayerEdge& edge, _EdgesOnShape& eos, const set<TGeomID>& subIds,
-                     SMESH_MesherHelper& helper, _SolidData& data);
+    bool setEdgeData( _LayerEdge& edge, _EdgesOnShape& eos,
+                      SMESH_MesherHelper& helper, _SolidData& data);
     gp_XYZ getFaceNormal(const SMDS_MeshNode* n,
                          const TopoDS_Face&   face,
                          SMESH_MesherHelper&  helper,
@@ -736,7 +902,8 @@ namespace VISCOUS_3D
                                     const TopoDS_Face&  face,
                                     SMESH_MesherHelper& helper,
                                     gp_Dir&             normal );
-    gp_XYZ getWeigthedNormal( const SMDS_MeshNode*             n,
+    gp_XYZ getWeigthedNormal( const _LayerEdge*                edge );
+    gp_XYZ getNormalByOffset( _LayerEdge*                      edge,
                               std::pair< TopoDS_Face, gp_XYZ > fId2Normal[],
                               int                              nbFaces );
     bool findNeiborsOnEdge(const _LayerEdge*     edge,
@@ -755,15 +922,26 @@ namespace VISCOUS_3D
     void limitStepSize( _SolidData& data, const double minSize);
     bool inflate(_SolidData& data);
     bool smoothAndCheck(_SolidData& data, const int nbSteps, double & distToIntersection);
-    bool smoothAnalyticEdge( _SolidData&           data,
-                             _EdgesOnShape&        eos,
-                             Handle(Geom_Surface)& surface,
-                             const TopoDS_Face&    F,
-                             SMESH_MesherHelper&   helper);
-    bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb );
+    int  invalidateBadSmooth( _SolidData&               data,
+                              SMESH_MesherHelper&       helper,
+                              vector< _LayerEdge* >&    badSmooEdges,
+                              vector< _EdgesOnShape* >& eosC1,
+                              const int                 infStep );
+    void makeOffsetSurface( _EdgesOnShape& eos, SMESH_MesherHelper& );
+    void putOnOffsetSurface( _EdgesOnShape& eos, int infStep, int smooStep=0, bool moveAll=false );
+    void findCollisionEdges( _SolidData& data, SMESH_MesherHelper& helper );
+    bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb, double stepSize );
     bool updateNormalsOfConvexFaces( _SolidData&         data,
                                      SMESH_MesherHelper& helper,
                                      int                 stepNb );
+    void updateNormalsOfC1Vertices( _SolidData& data );
+    bool updateNormalsOfSmoothed( _SolidData&         data,
+                                  SMESH_MesherHelper& helper,
+                                  const int           nbSteps,
+                                  const double        stepSize );
+    bool isNewNormalOk( _SolidData&   data,
+                        _LayerEdge&   edge,
+                        const gp_XYZ& newNormal);
     bool refine(_SolidData& data);
     bool shrink();
     bool prepareEdgeToShrink( _LayerEdge& edge, _EdgesOnShape& eos,
@@ -806,6 +984,74 @@ namespace VISCOUS_3D
     void Compute(bool set3D, SMESH_MesherHelper& helper);
     void RestoreParams();
     void SwapSrcTgtNodes(SMESHDS_Mesh* mesh);
+    const TopoDS_Edge& GeomEdge() const { return _geomEdge; }
+    const SMDS_MeshNode* TgtNode( bool is2nd ) const
+    { return _edges[is2nd] ? _edges[is2nd]->_nodes.back() : 0; }
+    const SMDS_MeshNode* SrcNode( bool is2nd ) const
+    { return _edges[is2nd] ? _edges[is2nd]->_nodes[0] : 0; }
+  };
+  //--------------------------------------------------------------------------------
+  /*!
+   * \brief Smoother of _LayerEdge's on EDGE.
+   */
+  struct _Smoother1D
+  {
+    struct OffPnt // point of the offsetted EDGE
+    {
+      gp_XYZ      _xyz;    // coord of a point inflated from EDGE w/o smooth
+      double      _len;    // length reached at previous inflation step
+      _2NearEdges _2edges; // 2 neighbor _LayerEdge's
+      double Distance( const OffPnt& p ) const { return ( _xyz - p._xyz ).Modulus(); }
+    };
+    vector< OffPnt >   _offPoints;
+    vector< double >   _leParams; // normalized param of _eos._edges on EDGE
+    Handle(Geom_Curve) _anaCurve; // for analytic smooth
+    _LayerEdge         _leOnV[2]; // _LayerEdge's holding normal to the EDGE at VERTEXes
+    size_t             _iSeg[2];  // index of segment where extreme tgt node is projected
+    _EdgesOnShape&     _eos;
+
+    static Handle(Geom_Curve) CurveForSmooth( const TopoDS_Edge&  E,
+                                              _EdgesOnShape&      eos,
+                                              SMESH_MesherHelper& helper);
+
+    _Smoother1D( Handle(Geom_Curve) curveForSmooth,
+                 _EdgesOnShape&     eos )
+      : _anaCurve( curveForSmooth ), _eos( eos )
+    {
+    }
+    bool Perform(_SolidData&                    data,
+                 Handle(ShapeAnalysis_Surface)& surface,
+                 const TopoDS_Face&             F,
+                 SMESH_MesherHelper&            helper )
+    {
+      if ( _leParams.empty() || ( !isAnalytic() && _offPoints.empty() ))
+        prepare( data );
+
+      if ( isAnalytic() )
+        return smoothAnalyticEdge( data, surface, F, helper );
+      else
+        return smoothComplexEdge ( data, surface, F, helper );
+    }
+    void prepare(_SolidData& data );
+
+    bool smoothAnalyticEdge( _SolidData&                    data,
+                             Handle(ShapeAnalysis_Surface)& surface,
+                             const TopoDS_Face&             F,
+                             SMESH_MesherHelper&            helper);
+
+    bool smoothComplexEdge( _SolidData&                    data,
+                            Handle(ShapeAnalysis_Surface)& surface,
+                            const TopoDS_Face&             F,
+                            SMESH_MesherHelper&            helper);
+
+    void setNormalOnV( const bool          is2nd,
+                       SMESH_MesherHelper& helper);
+
+    _LayerEdge* getLEdgeOnV( bool is2nd )
+    {
+      return _eos._edges[ is2nd ? _eos._edges.size()-1 : 0 ]->_2neibors->_edges[ is2nd ];
+    }
+    bool isAnalytic() const { return !_anaCurve.IsNull(); }
   };
   //--------------------------------------------------------------------------------
   /*!
@@ -816,8 +1062,9 @@ namespace VISCOUS_3D
   struct _TmpMeshFace : public SMDS_MeshElement
   {
     vector<const SMDS_MeshNode* > _nn;
-    _TmpMeshFace( const vector<const SMDS_MeshNode*>& nodes, int id, int faceID=-1):
-      SMDS_MeshElement(id), _nn(nodes) { setShapeId(faceID); }
+    _TmpMeshFace( const vector<const SMDS_MeshNode*>& nodes,
+                  int id, int faceID=-1, int idInFace=-1):
+      SMDS_MeshElement(id), _nn(nodes) { setShapeId(faceID); setIdInShape(idInFace); }
     virtual const SMDS_MeshNode* GetNode(const int ind) const { return _nn[ind]; }
     virtual SMDSAbs_ElementType  GetType() const              { return SMDSAbs_Face; }
     virtual vtkIdType GetVtkType() const                      { return -1; }
@@ -842,6 +1089,28 @@ namespace VISCOUS_3D
       _nn[2]=_le2->_nodes.back();
       _nn[3]=_le2->_nodes[0];
     }
+    gp_XYZ GetDir() const // return average direction of _LayerEdge's, normal to EDGE
+    {
+      SMESH_TNodeXYZ p0s( _nn[0] );
+      SMESH_TNodeXYZ p0t( _nn[1] );
+      SMESH_TNodeXYZ p1t( _nn[2] );
+      SMESH_TNodeXYZ p1s( _nn[3] );
+      gp_XYZ  v0 = p0t - p0s;
+      gp_XYZ  v1 = p1t - p1s;
+      gp_XYZ v01 = p1s - p0s;
+      gp_XYZ   n = ( v0 ^ v01 ) + ( v1 ^ v01 );
+      gp_XYZ   d = v01 ^ n;
+      d.Normalize();
+      return d;
+    }
+    gp_XYZ GetDir(_LayerEdge* le1, _LayerEdge* le2) // return average direction of _LayerEdge's
+    {
+      _nn[0]=le1->_nodes[0];
+      _nn[1]=le1->_nodes.back();
+      _nn[2]=le2->_nodes.back();
+      _nn[3]=le2->_nodes[0];
+      return GetDir();
+    }
   };
   //--------------------------------------------------------------------------------
   /*!
@@ -882,6 +1151,21 @@ namespace VISCOUS_3D
     }
   };
 
+  //================================================================================
+  /*!
+   * \brief Check angle between vectors 
+   */
+  //================================================================================
+
+  inline bool isLessAngle( const gp_Vec& v1, const gp_Vec& v2, const double cos )
+  {
+    double dot = v1 * v2; // cos * |v1| * |v2|
+    double l1  = v1.SquareMagnitude();
+    double l2  = v2.SquareMagnitude();
+    return (( dot * cos >= 0 ) && 
+            ( dot * dot ) / l1 / l2 >= ( cos * cos ));
+  }
+
 } // namespace VISCOUS_3D
 
 
@@ -984,7 +1268,7 @@ std::istream & StdMeshers_ViscousLayers::LoadFrom(std::istream & load)
 {
   int nbFaces, faceID, shapeToTreat, method;
   load >> _nbLayers >> _thickness >> _stretchFactor >> nbFaces;
-  while ( _shapeIds.size() < nbFaces && load >> faceID )
+  while ( (int) _shapeIds.size() < nbFaces && load >> faceID )
     _shapeIds.push_back( faceID );
   if ( load >> shapeToTreat ) {
     _isToIgnoreShapes = !shapeToTreat;
@@ -1033,6 +1317,7 @@ namespace VISCOUS_3D
     gp_Vec dir;
     double f,l;
     Handle(Geom_Curve) c = BRep_Tool::Curve( E, f, l );
+    if ( c.IsNull() ) return gp_XYZ( Precision::Infinite(), 1e100, 1e100 );
     gp_Pnt p = BRep_Tool::Pnt( fromV );
     double distF = p.SquareDistance( c->Value( f ));
     double distL = p.SquareDistance( c->Value( l ));
@@ -1047,7 +1332,7 @@ namespace VISCOUS_3D
     gp_Vec dir;
     double f,l; gp_Pnt p;
     Handle(Geom_Curve) c = BRep_Tool::Curve( E, f, l );
-    if ( c.IsNull() ) return gp_XYZ( 1e100, 1e100, 1e100 );
+    if ( c.IsNull() ) return gp_XYZ( Precision::Infinite(), 1e100, 1e100 );
     double u = helper.GetNodeU( E, atNode );
     c->D1( u, p, dir );
     return dir.XYZ();
@@ -1100,9 +1385,9 @@ namespace VISCOUS_3D
   {
     TopoDS_Face faceFrw = F;
     faceFrw.Orientation( TopAbs_FORWARD );
-    double f,l; TopLoc_Location loc;
+    //double f,l; TopLoc_Location loc;
     TopoDS_Edge edges[2]; // sharing a vertex
-    int nbEdges = 0;
+    size_t nbEdges = 0;
     {
       TopoDS_Vertex VV[2];
       TopExp_Explorer exp( faceFrw, TopAbs_EDGE );
@@ -1235,10 +1520,10 @@ namespace VISCOUS_3D
         double u1 = intervals( i );
         double u2 = intervals( i+1 );
         curve.D2( 0.5*( u1+u2 ), p, drv1, drv2 );
-        double cross = drv2 ^ drv1;
+        double cross = drv1 ^ drv2;
         if ( E.Orientation() == TopAbs_REVERSED )
           cross = -cross;
-        isConvex = ( cross > 0.1 ); //-1e-9 );
+        isConvex = ( cross > -1e-9 ); // 0.1 );
       }
       if ( !isConvex )
       {
@@ -1396,16 +1681,19 @@ namespace VISCOUS_3D
   { if (py) { *py<< "  mesh.ChangeElemNodes( " << f->GetID()<<", [";
       for ( int i=1; i < f->NbNodes(); ++i ) *py << f->GetNode(i-1)->GetID()<<", ";
       *py << f->GetNode( f->NbNodes()-1 )->GetID() << " ])"<< endl; }}
-#define debugMsg( txt ) { cout << txt << " (line: " << __LINE__ << ")" << endl; }
+#define debugMsg( txt ) { cout << "# "<< txt << " (line: " << __LINE__ << ")" << endl; }
+
 #else
+
   struct PyDump { PyDump(SMESH_Mesh&) {} void Finish() {} };
 #define dumpFunction(f) f
 #define dumpMove(n)
 #define dumpMoveComm(n,txt)
 #define dumpCmd(txt)
 #define dumpFunctionEnd()
-#define dumpChangeNodes(f)
+#define dumpChangeNodes(f) { if(f) {} } // prevent "unused variable 'f'" warning
 #define debugMsg( txt ) {}
+
 #endif
 }
 
@@ -1629,7 +1917,7 @@ bool _ViscousBuilder::findSolidsWithLayers()
     list< const SMESHDS_Hypothesis *>::const_iterator hyp = allHyps.begin();
     const StdMeshers_ViscousLayers* viscHyp = 0;
     for ( ; hyp != allHyps.end(); ++hyp )
-      if ( viscHyp = dynamic_cast<const StdMeshers_ViscousLayers*>( *hyp ))
+      if (( viscHyp = dynamic_cast<const StdMeshers_ViscousLayers*>( *hyp )))
       {
         TopoDS_Shape hypShape;
         filter.Init( filter.Is( viscHyp ));
@@ -1643,6 +1931,8 @@ bool _ViscousBuilder::findSolidsWithLayers()
           _sdVec.push_back( _SolidData( allSolids(i), proxyMesh ));
           soData = & _sdVec.back();
           soData->_index = getMeshDS()->ShapeToIndex( allSolids(i));
+          soData->_helper = new SMESH_MesherHelper( *_mesh );
+          soData->_helper->SetSubShape( allSolids(i) );
         }
         soData->_hyps.push_back( viscHyp );
         soData->_hypShapes.push_back( hypShape );
@@ -1903,7 +2193,7 @@ bool _ViscousBuilder::findFacesWithLayers(const bool onlyWith)
       const TopoDS_Shape& vertex = shapes(iV);
       // find faces WOL sharing the vertex
       vector< TopoDS_Shape > facesWOL;
-      int totalNbFaces = 0;
+      size_t totalNbFaces = 0;
       PShapeIteratorPtr fIt = helper.GetAncestors(vertex, *_mesh, TopAbs_FACE);
       while ( fIt->more())
       {
@@ -2051,12 +2341,7 @@ bool _ViscousBuilder::makeLayer(_SolidData& data)
   {
     SMESH_subMesh* fSubM = _mesh->GetSubMesh( exp.Current() );
     if ( ! data._ignoreFaceIds.count( fSubM->GetId() ))
-    {
       faceIds.insert( fSubM->GetId() );
-      SMESH_subMeshIteratorPtr subIt = fSubM->getDependsOnIterator(/*includeSelf=*/true);
-      while ( subIt->more() )
-        subIds.insert( subIt->next()->GetId() );
-    }
   }
 
   // make a map to find new nodes on sub-shapes shared with other SOLID
@@ -2184,8 +2469,12 @@ bool _ViscousBuilder::makeLayer(_SolidData& data)
             {
               edge->_nodes.push_back( helper.AddNode( xyz.X(), xyz.Y(), xyz.Z() ));
             }
-            if ( !setEdgeData( *edge, edgesByGeom[ shapeID ], subIds, helper, data ))
+            if ( !setEdgeData( *edge, edgesByGeom[ shapeID ], helper, data ))
               return false;
+
+            if ( edge->_nodes.size() < 2 )
+              edge->Block( data );
+              //data._noShrinkShapes.insert( shapeID );
           }
           dumpMove(edge->_nodes.back());
 
@@ -2205,7 +2494,7 @@ bool _ViscousBuilder::makeLayer(_SolidData& data)
 
       // create a temporary face
       const SMDS_MeshElement* newFace =
-        new _TmpMeshFace( newNodes, --_tmpFaceID, face->getshapeId() );
+        new _TmpMeshFace( newNodes, --_tmpFaceID, face->getshapeId(), face->getIdInShape() );
       proxySub->AddElement( newFace );
 
       // compute inflation step size by min size of element on a convex surface
@@ -2213,7 +2502,33 @@ bool _ViscousBuilder::makeLayer(_SolidData& data)
         limitStepSize( data, face, maxCosinEdge );
 
     } // loop on 2D elements on a FACE
-  } // loop on FACEs of a SOLID
+  } // loop on FACEs of a SOLID to create _LayerEdge's
+
+
+  // Set _LayerEdge::_neibors
+  TNode2Edge::iterator n2e;
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
+  {
+    _EdgesOnShape& eos = data._edgesOnShape[iS];
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
+    {
+      _LayerEdge* edge = eos._edges[i];
+      TIDSortedNodeSet nearNodes;
+      SMDS_ElemIteratorPtr fIt = edge->_nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
+      while ( fIt->more() )
+      {
+        const SMDS_MeshElement* f = fIt->next();
+        if ( !data._ignoreFaceIds.count( f->getshapeId() ))
+          nearNodes.insert( f->begin_nodes(), f->end_nodes() );
+      }
+      nearNodes.erase( edge->_nodes[0] );
+      edge->_neibors.reserve( nearNodes.size() );
+      TIDSortedNodeSet::iterator node = nearNodes.begin();
+      for ( ; node != nearNodes.end(); ++node )
+        if (( n2e = data._n2eMap.find( *node )) != data._n2eMap.end() )
+          edge->_neibors.push_back( n2e->second );
+    }
+  }
 
   data._epsilon = 1e-7;
   if ( data._stepSize < 1. )
@@ -2226,15 +2541,13 @@ bool _ViscousBuilder::makeLayer(_SolidData& data)
   limitStepSizeByCurvature( data ); // !!! it must be before node substitution in _Simplex
 
   // Set target nodes into _Simplex and _LayerEdge's to _2NearEdges
-  TNode2Edge::iterator n2e;
   const SMDS_MeshNode* nn[2];
   for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
     _EdgesOnShape& eos = data._edgesOnShape[iS];
-    vector< _LayerEdge* >& localEdges = eos._edges;
-    for ( size_t i = 0; i < localEdges.size(); ++i )
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
     {
-      _LayerEdge* edge = localEdges[i];
+      _LayerEdge* edge = eos._edges[i];
       if ( edge->IsOnEdge() )
       {
         // get neighbor nodes
@@ -2283,17 +2596,18 @@ bool _ViscousBuilder::makeLayer(_SolidData& data)
         edge->_lenFactor = vEdge->_lenFactor;
         edge->_cosin     = vEdge->_cosin;
       }
-    }
-  }
+
+    } // loop on data._edgesOnShape._edges
+  } // loop on data._edgesOnShape
 
   // fix _LayerEdge::_2neibors on EDGEs to smooth
-  map< TGeomID,Handle(Geom_Curve)>::iterator e2c = data._edge2curve.begin();
-  for ( ; e2c != data._edge2curve.end(); ++e2c )
-    if ( !e2c->second.IsNull() )
-    {
-      if ( _EdgesOnShape* eos = data.GetShapeEdges( e2c->first ))
-        data.Sort2NeiborsOnEdge( eos->_edges );
-    }
+  // map< TGeomID,Handle(Geom_Curve)>::iterator e2c = data._edge2curve.begin();
+  // for ( ; e2c != data._edge2curve.end(); ++e2c )
+  //   if ( !e2c->second.IsNull() )
+  //   {
+  //     if ( _EdgesOnShape* eos = data.GetShapeEdges( e2c->first ))
+  //       data.Sort2NeiborsOnEdge( eos->_edges );
+  //   }
 
   dumpFunctionEnd();
   return true;
@@ -2400,7 +2714,7 @@ void _ViscousBuilder::limitStepSizeByCurvature( _SolidData& data )
         continue;
       // check concavity and curvature and limit data._stepSize
       const double minCurvature =
-        1. / ( eos->_hyp.GetTotalThickness() * ( 1+theThickToIntersection ));
+        1. / ( eos->_hyp.GetTotalThickness() * ( 1 + theThickToIntersection ));
       size_t iStep = Max( 1, eos->_edges.size() / nbTestPnt );
       for ( size_t i = 0; i < eos->_edges.size(); i += iStep )
       {
@@ -2470,7 +2784,6 @@ void _ViscousBuilder::limitStepSizeByCurvature( _SolidData& data )
           const SMDS_MeshNode* srcNode = ledge->_nodes[0];
           if ( !usedNodes.insert( srcNode ).second ) continue;
 
-          _Simplex::GetSimplices( srcNode, ledge->_simplices, data._ignoreFaceIds, &data );
           for ( size_t i = 0; i < ledge->_simplices.size(); ++i )
           {
             usedNodes.insert( ledge->_simplices[i]._nPrev );
@@ -2492,7 +2805,7 @@ void _ViscousBuilder::limitStepSizeByCurvature( _SolidData& data )
 bool _ViscousBuilder::findShapesToSmooth( _SolidData& data )
 {
   // define allowed thickness
-  computeGeomSize( data ); // compute data._geomSize
+  computeGeomSize( data ); // compute data._geomSize and _LayerEdge::_maxLen
 
   data._maxThickness = 0;
   data._minThickness = 1e100;
@@ -2502,7 +2815,7 @@ bool _ViscousBuilder::findShapesToSmooth( _SolidData& data )
     data._maxThickness = Max( data._maxThickness, (*hyp)->GetTotalThickness() );
     data._minThickness = Min( data._minThickness, (*hyp)->GetTotalThickness() );
   }
-  const double tgtThick = /*Min( 0.5 * data._geomSize, */data._maxThickness;
+  //const double tgtThick = /*Min( 0.5 * data._geomSize, */data._maxThickness;
 
   // Find shapes needing smoothing; such a shape has _LayerEdge._normal on it's
   // boundry inclined to the shape at a sharp angle
@@ -2523,44 +2836,29 @@ bool _ViscousBuilder::findShapesToSmooth( _SolidData& data )
     if ( eos._edges.empty() || eos.ShapeType() != TopAbs_FACE )
       continue;
 
+    double tgtThick = eos._hyp.GetTotalThickness();
     TopExp_Explorer eExp( edgesByGeom[iS]._shape, TopAbs_EDGE );
     for ( ; eExp.More() && !eos._toSmooth; eExp.Next() )
     {
       TGeomID iE = getMeshDS()->ShapeToIndex( eExp.Current() );
       vector<_LayerEdge*>& eE = edgesByGeom[ iE ]._edges;
       if ( eE.empty() ) continue;
-      // TopLoc_Location loc;
-      // Handle(Geom_Surface) surface = BRep_Tool::Surface( TopoDS::Face( S ), loc );
-      // bool isPlane = GeomLib_IsPlanarSurface( surface ).IsPlanar();
-      //if ( eE[0]->_sWOL.IsNull() )
-      {
-        double faceSize;
-        for ( size_t i = 0; i < eE.size() && !eos._toSmooth; ++i )
-          if ( eE[i]->_cosin > theMinSmoothCosin )
+
+      double faceSize;
+      for ( size_t i = 0; i < eE.size() && !eos._toSmooth; ++i )
+        if ( eE[i]->_cosin > theMinSmoothCosin )
+        {
+          SMDS_ElemIteratorPtr fIt = eE[i]->_nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
+          while ( fIt->more() && !eos._toSmooth )
           {
-            SMDS_ElemIteratorPtr fIt = eE[i]->_nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
-            while ( fIt->more() && !eos._toSmooth )
+            const SMDS_MeshElement* face = fIt->next();
+            if ( face->getshapeId() == eos._shapeID &&
+                 getDistFromEdge( face, eE[i]->_nodes[0], faceSize ))
             {
-              const SMDS_MeshElement* face = fIt->next();
-              if ( getDistFromEdge( face, eE[i]->_nodes[0], faceSize ))
-                eos._toSmooth = needSmoothing( eE[i]->_cosin, tgtThick, faceSize );
+              eos._toSmooth = needSmoothing( eE[i]->_cosin, tgtThick, faceSize );
             }
           }
-      }
-      // else
-      // {
-      //   const TopoDS_Face& F1 = TopoDS::Face( S );
-      //   const TopoDS_Face& F2 = TopoDS::Face( eE[0]->_sWOL );
-      //   const TopoDS_Edge& E  = TopoDS::Edge( eExp.Current() );
-      //   for ( size_t i = 0; i < eE.size() && !eos._toSmooth; ++i )
-      //   {
-      //     gp_Vec dir1 = getFaceDir( F1, E, eE[i]->_nodes[0], helper, ok );
-      //     gp_Vec dir2 = getFaceDir( F2, E, eE[i]->_nodes[0], helper, ok );
-      //     double angle = dir1.Angle(  );
-      //     double cosin = cos( angle );
-      //     eos._toSmooth = ( cosin > theMinSmoothCosin );
-      //   }
-      // }
+        }
     }
     if ( eos._toSmooth )
     {
@@ -2576,6 +2874,7 @@ bool _ViscousBuilder::findShapesToSmooth( _SolidData& data )
   for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS ) // check EDGEs
   {
     _EdgesOnShape& eos = edgesByGeom[iS];
+    eos._edgeSmoother = NULL;
     if ( eos._edges.empty() || eos.ShapeType() != TopAbs_EDGE ) continue;
     if ( !eos._hyp.ToSmooth() ) continue;
 
@@ -2583,32 +2882,41 @@ bool _ViscousBuilder::findShapesToSmooth( _SolidData& data )
     if ( SMESH_Algo::isDegenerated( E ) || !edgesOfSmooFaces.Contains( E ))
       continue;
 
+    double tgtThick = eos._hyp.GetTotalThickness();
     for ( TopoDS_Iterator vIt( E ); vIt.More() && !eos._toSmooth; vIt.Next() )
     {
       TGeomID iV = getMeshDS()->ShapeToIndex( vIt.Value() );
       vector<_LayerEdge*>& eV = edgesByGeom[ iV ]._edges;
       if ( eV.empty() ) continue;
-      gp_Vec  eDir = getEdgeDir( E, TopoDS::Vertex( vIt.Value() ));
-      double angle = eDir.Angle( eV[0]->_normal );
-      double cosin = Cos( angle );
+      gp_Vec  eDir    = getEdgeDir( E, TopoDS::Vertex( vIt.Value() ));
+      double angle    = eDir.Angle( eV[0]->_normal );
+      double cosin    = Cos( angle );
       double cosinAbs = Abs( cosin );
       if ( cosinAbs > theMinSmoothCosin )
       {
         // always smooth analytic EDGEs
-        eos._toSmooth = ! data.CurveForSmooth( E, eos, helper ).IsNull();
+        Handle(Geom_Curve) curve = _Smoother1D::CurveForSmooth( E, eos, helper );
+        eos._toSmooth = ! curve.IsNull();
 
         // compare tgtThick with the length of an end segment
         SMDS_ElemIteratorPtr eIt = eV[0]->_nodes[0]->GetInverseElementIterator(SMDSAbs_Edge);
         while ( eIt->more() && !eos._toSmooth )
         {
           const SMDS_MeshElement* endSeg = eIt->next();
-          if ( endSeg->getshapeId() == iS )
+          if ( endSeg->getshapeId() == (int) iS )
           {
             double segLen =
               SMESH_TNodeXYZ( endSeg->GetNode(0) ).Distance( endSeg->GetNode(1 ));
             eos._toSmooth = needSmoothing( cosinAbs, tgtThick, segLen );
           }
         }
+        if ( eos._toSmooth )
+        {
+          eos._edgeSmoother = new _Smoother1D( curve, eos );
+
+          for ( size_t i = 0; i < eos._edges.size(); ++i )
+            eos._edges[i]->Set( _LayerEdge::TO_SMOOTH );
+        }
       }
     }
     data._nbShapesToSmooth += eos._toSmooth;
@@ -2627,36 +2935,160 @@ bool _ViscousBuilder::findShapesToSmooth( _SolidData& data )
   }
 
 
-  // int nbShapes = 0;
-  // for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS )
-  // {
-  //   nbShapes += ( edgesByGeom[iS]._edges.size() > 0 );
-  // }
-  // data._edgesOnShape.reserve( nbShapes );
+  // Fill _eosC1 to make that C1 FACEs and EGDEs between them to be smoothed as a whole
+
+  TopTools_MapOfShape c1VV;
+
+  for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS ) // check FACEs
+  {
+    _EdgesOnShape& eos = edgesByGeom[iS];
+    if ( eos._edges.empty() ||
+         eos.ShapeType() != TopAbs_FACE ||
+         !eos._toSmooth )
+      continue;
+
+    // check EDGEs of a FACE
+    TopTools_MapOfShape checkedEE, allVV;
+    list< SMESH_subMesh* > smQueue( 1, eos._subMesh ); // sm of FACEs
+    while ( !smQueue.empty() )
+    {
+      SMESH_subMesh* sm = smQueue.front();
+      smQueue.pop_front();
+      SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/false);
+      while ( smIt->more() )
+      {
+        sm = smIt->next();
+        if ( sm->GetSubShape().ShapeType() == TopAbs_VERTEX )
+          allVV.Add( sm->GetSubShape() );
+        if ( sm->GetSubShape().ShapeType() != TopAbs_EDGE ||
+             !checkedEE.Add( sm->GetSubShape() ))
+          continue;
+
+        _EdgesOnShape*      eoe = data.GetShapeEdges( sm->GetId() );
+        vector<_LayerEdge*>& eE = eoe->_edges;
+        if ( eE.empty() || !eoe->_sWOL.IsNull() )
+          continue;
+
+        bool isC1 = true; // check continuity along an EDGE
+        for ( size_t i = 0; i < eE.size() && isC1; ++i )
+          isC1 = ( Abs( eE[i]->_cosin ) < theMinSmoothCosin );
+        if ( !isC1 )
+          continue;
+
+        // check that mesh faces are C1 as well
+        {
+          gp_XYZ norm1, norm2;
+          const SMDS_MeshNode*   n = eE[ eE.size() / 2 ]->_nodes[0];
+          SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face);
+          if ( !SMESH_MeshAlgos::FaceNormal( fIt->next(), norm1, /*normalized=*/true ))
+            continue;
+          while ( fIt->more() && isC1 )
+            isC1 = ( SMESH_MeshAlgos::FaceNormal( fIt->next(), norm2, /*normalized=*/true ) &&
+                     Abs( norm1 * norm2 ) >= ( 1. - theMinSmoothCosin ));
+          if ( !isC1 )
+            continue;
+        }
+
+        // add the EDGE and an adjacent FACE to _eosC1
+        PShapeIteratorPtr fIt = helper.GetAncestors( sm->GetSubShape(), *_mesh, TopAbs_FACE );
+        while ( const TopoDS_Shape* face = fIt->next() )
+        {
+          _EdgesOnShape* eof = data.GetShapeEdges( *face );
+          if ( !eof ) continue; // other solid
+          if ( !eos.HasC1( eoe ))
+          {
+            eos._eosC1.push_back( eoe );
+            eoe->_toSmooth = false;
+            data.PrepareEdgesToSmoothOnFace( eoe, /*substituteSrcNodes=*/false );
+          }
+          if ( eos._shapeID != eof->_shapeID && !eos.HasC1( eof )) 
+          {
+            eos._eosC1.push_back( eof );
+            eof->_toSmooth = false;
+            data.PrepareEdgesToSmoothOnFace( eof, /*substituteSrcNodes=*/false );
+            smQueue.push_back( eof->_subMesh );
+          }
+        }
+      }
+    }
+    if ( eos._eosC1.empty() )
+      continue;
+
+    // check VERTEXes of C1 FACEs
+    TopTools_MapIteratorOfMapOfShape vIt( allVV );
+    for ( ; vIt.More(); vIt.Next() )
+    {
+      _EdgesOnShape* eov = data.GetShapeEdges( vIt.Key() );
+      if ( !eov || eov->_edges.empty() || !eov->_sWOL.IsNull() )
+        continue;
+
+      bool isC1 = true; // check if all adjacent FACEs are in eos._eosC1
+      PShapeIteratorPtr fIt = helper.GetAncestors( vIt.Key(), *_mesh, TopAbs_FACE );
+      while ( const TopoDS_Shape* face = fIt->next() )
+      {
+        _EdgesOnShape* eof = data.GetShapeEdges( *face );
+        if ( !eof ) continue; // other solid
+        isC1 = ( face->IsSame( eos._shape ) || eos.HasC1( eof ));
+        if ( !isC1 )
+          break;
+      }
+      if ( isC1 )
+      {
+        eos._eosC1.push_back( eov );
+        data.PrepareEdgesToSmoothOnFace( eov, /*substituteSrcNodes=*/false );
+        c1VV.Add( eov->_shape );
+      }
+    }
+
+  } // fill _eosC1 of FACEs
+
+
+  // Find C1 EDGEs
+
+  vector< pair< _EdgesOnShape*, gp_XYZ > > dirOfEdges;
+
+  for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS ) // check VERTEXes
+  {
+    _EdgesOnShape& eov = edgesByGeom[iS];
+    if ( eov._edges.empty() ||
+         eov.ShapeType() != TopAbs_VERTEX ||
+         c1VV.Contains( eov._shape ))
+      continue;
+    const TopoDS_Vertex& V = TopoDS::Vertex( eov._shape );
+
+    // get directions of surrounding EDGEs
+    dirOfEdges.clear();
+    PShapeIteratorPtr fIt = helper.GetAncestors( eov._shape, *_mesh, TopAbs_EDGE );
+    while ( const TopoDS_Shape* e = fIt->next() )
+    {
+      _EdgesOnShape* eoe = data.GetShapeEdges( *e );
+      if ( !eoe ) continue; // other solid
+      gp_XYZ eDir = getEdgeDir( TopoDS::Edge( *e ), V );
+      if ( !Precision::IsInfinite( eDir.X() ))
+        dirOfEdges.push_back( make_pair( eoe, eDir.Normalized() ));
+    }
+
+    // find EDGEs with C1 directions
+    for ( size_t i = 0; i < dirOfEdges.size(); ++i )
+      for ( size_t j = i+1; j < dirOfEdges.size(); ++j )
+        if ( dirOfEdges[i].first && dirOfEdges[j].first )
+        {
+          double dot = dirOfEdges[i].second * dirOfEdges[j].second;
+          bool isC1 = ( dot < - ( 1. - theMinSmoothCosin ));
+          if ( isC1 )
+          {
+            double maxEdgeLen = 3 * Min( eov._edges[0]->_maxLen, eov._hyp.GetTotalThickness() );
+            double eLen1 = SMESH_Algo::EdgeLength( TopoDS::Edge( dirOfEdges[i].first->_shape ));
+            double eLen2 = SMESH_Algo::EdgeLength( TopoDS::Edge( dirOfEdges[j].first->_shape ));
+            if ( eLen1 < maxEdgeLen ) eov._eosC1.push_back( dirOfEdges[i].first );
+            if ( eLen2 < maxEdgeLen ) eov._eosC1.push_back( dirOfEdges[j].first );
+            dirOfEdges[i].first = 0;
+            dirOfEdges[j].first = 0;
+          }
+        }
+  } // fill _eosC1 of VERTEXes
 
-  // // first we put _LayerEdge's on shapes to smooth (EGDEs go first)
-  // vector< _LayerEdge* > edges;
-  // list< TGeomID >::iterator gIt = shapesToSmooth.begin();
-  // for ( ; gIt != shapesToSmooth.end(); ++gIt )
-  // {
-  //   _EdgesOnShape& eos = edgesByGeom[ *gIt ];
-  //   if ( eos._edges.empty() ) continue;
-  //   eos._edges.swap( edges ); // avoid copying array
-  //   eos._toSmooth = true;
-  //   data._edgesOnShape.push_back( eos );
-  //   data._edgesOnShape.back()._edges.swap( edges );
-  // }
 
-  // // then the rest _LayerEdge's
-  // for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS )
-  // {
-  //   _EdgesOnShape& eos = edgesByGeom[ *gIt ];
-  //   if ( eos._edges.empty() ) continue;
-  //   eos._edges.swap( edges ); // avoid copying array
-  //   eos._toSmooth = false;
-  //   data._edgesOnShape.push_back( eos );
-  //   data._edgesOnShape.back()._edges.swap( edges );
-  // }
 
   return ok;
 }
@@ -2683,6 +3115,7 @@ void _ViscousBuilder::setShapeData( _EdgesOnShape& eos,
   if ( eos.ShapeType() == TopAbs_FACE )
     eos._shape.Orientation( helper.GetSubShapeOri( data._solid, eos._shape ));
   eos._toSmooth = false;
+  eos._data = &data;
 
   // set _SWOL
   map< TGeomID, TopoDS_Shape >::const_iterator s2s =
@@ -2690,6 +3123,14 @@ void _ViscousBuilder::setShapeData( _EdgesOnShape& eos,
   if ( s2s != data._shrinkShape2Shape.end() )
     eos._sWOL = s2s->second;
 
+  eos._isRegularSWOL = true;
+  if ( eos.SWOLType() == TopAbs_FACE )
+  {
+    const TopoDS_Face& F = TopoDS::Face( eos._sWOL );
+    Handle(ShapeAnalysis_Surface) surface = helper.GetSurface( F );
+    eos._isRegularSWOL = ( ! surface->HasSingularities( 1e-7 ));
+  }
+
   // set _hyp
   if ( data._hyps.size() == 1 )
   {
@@ -2774,7 +3215,7 @@ bool _EdgesOnShape::GetNormal( const SMDS_MeshElement* face, gp_Vec& norm )
   }
 
   if (( eos ) &&
-      ( ok = ( face->getIdInShape() < eos->_faceNormals.size() )))
+      ( ok = ( face->getIdInShape() < (int) eos->_faceNormals.size() )))
   {
     norm = eos->_faceNormals[ face->getIdInShape() ];
   }
@@ -2790,28 +3231,31 @@ bool _EdgesOnShape::GetNormal( const SMDS_MeshElement* face, gp_Vec& norm )
 //================================================================================
 /*!
  * \brief Set data of _LayerEdge needed for smoothing
- *  \param subIds - ids of sub-shapes of a SOLID to take into account faces from
  */
 //================================================================================
 
 bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
                                   _EdgesOnShape&      eos,
-                                  const set<TGeomID>& subIds,
                                   SMESH_MesherHelper& helper,
                                   _SolidData&         data)
 {
   const SMDS_MeshNode* node = edge._nodes[0]; // source node
 
   edge._len       = 0;
+  edge._maxLen    = Precision::Infinite();
+  edge._minAngle  = 0;
   edge._2neibors  = 0;
   edge._curvature = 0;
+  edge._flags     = 0;
 
   // --------------------------
   // Compute _normal and _cosin
   // --------------------------
 
-  edge._cosin = 0;
+  edge._cosin     = 0;
+  edge._lenFactor = 1.;
   edge._normal.SetCoord(0,0,0);
+  _Simplex::GetSimplices( node, edge._simplices, data._ignoreFaceIds, &data );
 
   int totalNbFaces = 0;
   TopoDS_Face F;
@@ -2821,7 +3265,7 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
 
   const bool onShrinkShape = !eos._sWOL.IsNull();
   const bool useGeometry   = (( eos._hyp.UseSurfaceNormal() ) ||
-                              ( eos.ShapeType() != TopAbs_FACE && !onShrinkShape ));
+                              ( eos.ShapeType() != TopAbs_FACE /*&& !onShrinkShape*/ ));
 
   // get geom FACEs the node lies on
   //if ( useGeometry )
@@ -2841,7 +3285,7 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
     for ( ; id != faceIds.end(); ++id )
     {
       const TopoDS_Shape& s = getMeshDS()->IndexToShape( *id );
-      if ( s.IsNull() || s.ShapeType() != TopAbs_FACE || !subIds.count( *id ))
+      if ( s.IsNull() || s.ShapeType() != TopAbs_FACE || data._ignoreFaceIds.count( *id ))
         continue;
       F = TopoDS::Face( s );
       face2Norm[ totalNbFaces ].first = F;
@@ -2872,9 +3316,7 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
                                    node, helper, normOK);
       }
     }
-
-    // layers are on all faces of SOLID the node is on
-    else
+    else // layers are on all FACEs of SOLID the node is on
     {
       int nbOkNorms = 0;
       for ( int iF = 0; iF < totalNbFaces; ++iF )
@@ -2908,32 +3350,30 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
         }
       }
 
-      if ( totalNbFaces < 3 )
-      {
-        //edge._normal /= totalNbFaces;
-      }
-      else
+      if ( totalNbFaces >= 3 )
       {
-        edge._normal = getWeigthedNormal( node, face2Norm, totalNbFaces );
+        edge._normal = getNormalByOffset( &edge, face2Norm, totalNbFaces );
       }
     }
   }
   else // !useGeometry - get _normal using surrounding mesh faces
   {
-    set<TGeomID> faceIds;
+    edge._normal = getWeigthedNormal( &edge );
 
-    SMDS_ElemIteratorPtr fIt = node->GetInverseElementIterator(SMDSAbs_Face);
-    while ( fIt->more() )
-    {
-      const SMDS_MeshElement* face = fIt->next();
-      if ( eos.GetNormal( face, geomNorm ))
-      {
-        if ( onShrinkShape && !faceIds.insert( face->getshapeId() ).second )
-          continue; // use only one mesh face on FACE
-        edge._normal += geomNorm.XYZ();
-        totalNbFaces++;
-      }
-    }
+    // set<TGeomID> faceIds;
+    //
+    // SMDS_ElemIteratorPtr fIt = node->GetInverseElementIterator(SMDSAbs_Face);
+    // while ( fIt->more() )
+    // {
+    //   const SMDS_MeshElement* face = fIt->next();
+    //   if ( eos.GetNormal( face, geomNorm ))
+    //   {
+    //     if ( onShrinkShape && !faceIds.insert( face->getshapeId() ).second )
+    //       continue; // use only one mesh face on FACE
+    //     edge._normal += geomNorm.XYZ();
+    //     totalNbFaces++;
+    //   }
+    // }
   }
 
   // compute _cosin
@@ -2950,7 +3390,6 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
       gp_Vec inFaceDir = getFaceDir( F, E, node, helper, normOK );
       double angle     = inFaceDir.Angle( edge._normal ); // [0,PI]
       edge._cosin      = Cos( angle );
-      //cout << "Cosin on EDGE " << edge._cosin << " node " << node->GetID() << endl;
       break;
     }
     case TopAbs_VERTEX: {
@@ -2966,11 +3405,12 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
             inFaceDir = getFaceDir( F, V, node, helper, normOK=true );
             if ( normOK ) {
               double angle = inFaceDir.Angle( edge._normal );
-              edge._cosin = Max( edge._cosin, Cos( angle ));
+              double cosin = Cos( angle );
+              if ( Abs( cosin ) > edge._cosin )
+                edge._cosin = cosin;
             }
           }
       }
-      //cout << "Cosin on VERTEX " << edge._cosin << " node " << node->GetID() << endl;
       break;
     }
     default:
@@ -2984,13 +3424,22 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
 
   edge._normal /= sqrt( normSize );
 
-  // TODO: if ( !normOK ) then get normal by mesh faces
+  if ( edge.Is( _LayerEdge::MULTI_NORMAL ) && edge._nodes.size() == 2 )
+  {
+    getMeshDS()->RemoveFreeNode( edge._nodes.back(), 0, /*fromGroups=*/false );
+    edge._nodes.resize( 1 );
+    edge._normal.SetCoord( 0,0,0 );
+    edge._maxLen = 0;
+  }
 
   // Set the rest data
   // --------------------
+
+  edge.SetCosin( edge._cosin ); // to update edge._lenFactor
+
   if ( onShrinkShape )
   {
-    SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( edge._nodes.back() );
+    const SMDS_MeshNode* tgtNode = edge._nodes.back();
     if ( SMESHDS_SubMesh* sm = getMeshDS()->MeshElements( data._solid ))
       sm->RemoveNode( tgtNode , /*isNodeDeleted=*/false );
 
@@ -3002,13 +3451,39 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
       if ( edge._nodes.size() > 1 )
         getMeshDS()->SetNodeOnEdge( tgtNode, TopoDS::Edge( eos._sWOL ), u );
     }
-    else // TopAbs_FACE
+    else // eos.SWOLType() == TopAbs_FACE
     {
       gp_XY uv = helper.GetNodeUV( TopoDS::Face( eos._sWOL ), node, 0, &normOK );
       edge._pos.push_back( gp_XYZ( uv.X(), uv.Y(), 0));
       if ( edge._nodes.size() > 1 )
         getMeshDS()->SetNodeOnFace( tgtNode, TopoDS::Face( eos._sWOL ), uv.X(), uv.Y() );
     }
+
+    if ( edge._nodes.size() > 1 )
+    {
+      // check if an angle between a FACE with layers and SWOL is sharp,
+      // else the edge should not inflate
+      F.Nullify();
+      for ( int iF = 0; iF < totalNbFaces  &&  F.IsNull();  ++iF ) // find a FACE with VL
+        if ( ! helper.IsSubShape( eos._sWOL, face2Norm[iF].first ))
+          F = face2Norm[iF].first;
+      if ( !F.IsNull())
+      {
+        geomNorm = getFaceNormal( node, F, helper, normOK );
+        if ( helper.GetSubShapeOri( data._solid, F ) != TopAbs_REVERSED )
+          geomNorm.Reverse(); // inside the SOLID
+        if ( geomNorm * edge._normal < -0.001 )
+        {
+          getMeshDS()->RemoveFreeNode( tgtNode, 0, /*fromGroups=*/false );
+          edge._nodes.resize( 1 );
+        }
+        else if ( edge._lenFactor > 3 )
+        {
+          edge._lenFactor = 2;
+          edge.Set( _LayerEdge::RISKY_SWOL );
+        }
+      }
+    }
   }
   else
   {
@@ -3016,29 +3491,24 @@ bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
 
     if ( eos.ShapeType() == TopAbs_FACE )
     {
-      _Simplex::GetSimplices( node, edge._simplices, data._ignoreFaceIds, &data );
+      double angle;
+      for ( size_t i = 0; i < edge._simplices.size(); ++i )
+      {
+        edge._simplices[i].IsMinAngleOK( edge._pos.back(), angle );
+        edge._minAngle = Max( edge._minAngle, angle ); // "angle" is actually cosine
+      }
     }
   }
 
-  // Set neighbour nodes for a _LayerEdge based on EDGE
+  // Set neighbor nodes for a _LayerEdge based on EDGE
 
   if ( eos.ShapeType() == TopAbs_EDGE /*||
        ( onShrinkShape && posType == SMDS_TOP_VERTEX && fabs( edge._cosin ) < 1e-10 )*/)
   {
     edge._2neibors = new _2NearEdges;
-    // target node instead of source ones will be set later
-    // if ( ! findNeiborsOnEdge( &edge,
-    //                           edge._2neibors->_nodes[0],
-    //                           edge._2neibors->_nodes[1], eos,
-    //                           data))
-    //   return false;
-    // edge.SetDataByNeighbors( edge._2neibors->_nodes[0],
-    //                          edge._2neibors->_nodes[1],
-    //                          helper);
+    // target nodes instead of source ones will be set later
   }
 
-  edge.SetCosin( edge._cosin ); // to update edge._lenFactor
-
   return true;
 }
 
@@ -3217,111 +3687,210 @@ bool _ViscousBuilder::getFaceNormalAtSingularity( const gp_XY&        uv,
 
 //================================================================================
 /*!
- * \brief Return a normal at a node weighted with angles taken by FACEs
- *  \param [in] n - the node
- *  \param [in] fId2Normal - FACE ids and normals
- *  \param [in] nbFaces - nb of FACEs meeting at the node
- *  \return gp_XYZ - computed normal
+ * \brief Return a normal at a node weighted with angles taken by faces
+ */
+//================================================================================
+
+gp_XYZ _ViscousBuilder::getWeigthedNormal( const _LayerEdge* edge )
+{
+  const SMDS_MeshNode* n = edge->_nodes[0];
+
+  gp_XYZ resNorm(0,0,0);
+  SMESH_TNodeXYZ p0( n ), pP, pN;
+  for ( size_t i = 0; i < edge->_simplices.size(); ++i )
+  {
+    pP.Set( edge->_simplices[i]._nPrev );
+    pN.Set( edge->_simplices[i]._nNext );
+    gp_Vec v0P( p0, pP ), v0N( p0, pN ), vPN( pP, pN ), norm = v0P ^ v0N;
+    double l0P = v0P.SquareMagnitude();
+    double l0N = v0N.SquareMagnitude();
+    double lPN = vPN.SquareMagnitude();
+    if ( l0P < std::numeric_limits<double>::min() ||
+         l0N < std::numeric_limits<double>::min() ||
+         lPN < std::numeric_limits<double>::min() )
+      continue;
+    double lNorm = norm.SquareMagnitude();
+    double  sin2 = lNorm / l0P / l0N;
+    double angle = ACos(( v0P * v0N ) / Sqrt( l0P ) / Sqrt( l0N ));
+
+    double weight = sin2 * angle / lPN;
+    resNorm += weight * norm.XYZ() / Sqrt( lNorm );
+  }
+
+  return resNorm;
+}
+
+//================================================================================
+/*!
+ * \brief Return a normal at a node by getting a common point of offset planes
+ *        defined by the FACE normals
  */
 //================================================================================
 
-gp_XYZ _ViscousBuilder::getWeigthedNormal( const SMDS_MeshNode*             n,
-                                           std::pair< TopoDS_Face, gp_XYZ > fId2Normal[],
+gp_XYZ _ViscousBuilder::getNormalByOffset( _LayerEdge*                      edge,
+                                           std::pair< TopoDS_Face, gp_XYZ > f2Normal[],
                                            int                              nbFaces )
 {
+  SMESH_TNodeXYZ p0 = edge->_nodes[0];
+
   gp_XYZ resNorm(0,0,0);
-  TopoDS_Shape V = SMESH_MesherHelper::GetSubShapeByNode( n, getMeshDS() );
-  if ( V.ShapeType() != TopAbs_VERTEX )
+  TopoDS_Shape V = SMESH_MesherHelper::GetSubShapeByNode( p0._node, getMeshDS() );
+  if ( V.ShapeType() != TopAbs_VERTEX || nbFaces < 3 )
   {
     for ( int i = 0; i < nbFaces; ++i )
-      resNorm += fId2Normal[i].second;
+      resNorm += f2Normal[i].second;
     return resNorm;
   }
 
-  // exclude equal normals
-  int nbUniqNorms = nbFaces;
-  for ( int i = 0; i < nbFaces; ++i ) {
-    for ( int j = i+1; j < nbFaces; ++j )
-      if ( fId2Normal[i].second.IsEqual( fId2Normal[j].second, 0.1 ))
-      {
-        fId2Normal[i].second.SetCoord( 0,0,0 );
-        --nbUniqNorms;
-        break;
-      }
-  }
+  // prepare _OffsetPlane's
+  vector< _OffsetPlane > pln( nbFaces );
   for ( int i = 0; i < nbFaces; ++i )
-    resNorm += fId2Normal[i].second;
+  {
+    pln[i]._faceIndex = i;
+    pln[i]._plane = gp_Pln( p0 + f2Normal[i].second, f2Normal[i].second );
+  }
 
-  // assure that resNorm is visible by every FACE (IPAL0052675)
-  if ( nbUniqNorms > 3 )
+  // intersect neighboring OffsetPlane's
+  PShapeIteratorPtr edgeIt = SMESH_MesherHelper::GetAncestors( V, *_mesh, TopAbs_EDGE );
+  while ( const TopoDS_Shape* edge = edgeIt->next() )
   {
-    bool change = false;
-    for ( int nbAttempts = 0; nbAttempts < nbFaces; ++nbAttempts)
-    {
-      for ( int i = 0; i < nbFaces; ++i )
-        if ( resNorm * fId2Normal[i].second < 0.5 )
-        {
-          resNorm += fId2Normal[i].second;
-          change = true;
-        }
-      if ( !change ) break;
-    }
+    int f1 = -1, f2 = -1;
+    for ( int i = 0; i < nbFaces &&  f2 < 0;  ++i )
+      if ( SMESH_MesherHelper::IsSubShape( *edge, f2Normal[i].first ))
+        (( f1 < 0 ) ? f1 : f2 ) = i;
+
+    if ( f2 >= 0 )
+      pln[ f1 ].ComputeIntersectionLine( pln[ f2 ]);
   }
 
-  // double angles[30];
-  // for ( int i = 0; i < nbFaces; ++i )
-  // {
-  //   const TopoDS_Face& F = fId2Normal[i].first;
+  // get a common point
+  gp_XYZ commonPnt( 0, 0, 0 );
+  int nbPoints = 0;
+  bool isPointFound;
+  for ( int i = 0; i < nbFaces; ++i )
+  {
+    commonPnt += pln[ i ].GetCommonPoint( isPointFound );
+    nbPoints  += isPointFound;
+  }
+  gp_XYZ wgtNorm = getWeigthedNormal( edge );
+  if ( nbPoints == 0 )
+    return wgtNorm;
 
-  //   // look for two EDGEs shared by F and other FACEs within fId2Normal
-  //   TopoDS_Edge ee[2];
-  //   int nbE = 0;
-  //   PShapeIteratorPtr eIt = SMESH_MesherHelper::GetAncestors( V, *_mesh, TopAbs_EDGE );
-  //   while ( const TopoDS_Shape* E = eIt->next() )
-  //   {
-  //     if ( !SMESH_MesherHelper::IsSubShape( *E, F ))
-  //       continue;
-  //     bool isSharedEdge = false;
-  //     for ( int j = 0; j < nbFaces && !isSharedEdge; ++j )
-  //     {
-  //       if ( i == j ) continue;
-  //       const TopoDS_Shape& otherF = fId2Normal[j].first;
-  //       isSharedEdge = SMESH_MesherHelper::IsSubShape( *E, otherF );
-  //     }
-  //     if ( !isSharedEdge )
-  //       continue;
-  //     ee[ nbE ] = TopoDS::Edge( *E );
-  //     ee[ nbE ].Orientation( SMESH_MesherHelper::GetSubShapeOri( F, *E ));
-  //     if ( ++nbE == 2 )
-  //       break;
-  //   }
+  commonPnt /= nbPoints;
+  resNorm = commonPnt - p0;
 
-  //   // get an angle between the two EDGEs
-  //   angles[i] = 0;
-  //   if ( nbE < 1 ) continue;
-  //   if ( nbE == 1 )
-  //   {
-  //     ee[ 1 ] == ee[ 0 ];
-  //   }
-  //   else
-  //   {
-  //     if ( !V.IsSame( SMESH_MesherHelper::IthVertex( 0, ee[ 1 ] )))
-  //       std::swap( ee[0], ee[1] );
-  //   }
-  //   angles[i] = SMESH_MesherHelper::GetAngle( ee[0], ee[1], F, TopoDS::Vertex( V ));
-  // }
+  // choose the best among resNorm and wgtNorm
+  resNorm.Normalize();
+  wgtNorm.Normalize();
+  double resMinDot = std::numeric_limits<double>::max();
+  double wgtMinDot = std::numeric_limits<double>::max();
+  for ( int i = 0; i < nbFaces; ++i )
+  {
+    resMinDot = Min( resMinDot, resNorm * f2Normal[i].second );
+    wgtMinDot = Min( wgtMinDot, wgtNorm * f2Normal[i].second );
+  }
 
-  // // compute a weighted normal
-  // double sumAngle = 0;
-  // for ( int i = 0; i < nbFaces; ++i )
-  // {
-  //   angles[i] = ( angles[i] > 2*M_PI )  ?  0  :  M_PI - angles[i];
-  //   sumAngle += angles[i];
-  // }
-  // for ( int i = 0; i < nbFaces; ++i )
-  //   resNorm += angles[i] / sumAngle * fId2Normal[i].second;
+  if ( Max( resMinDot, wgtMinDot ) < theMinSmoothCosin )
+  {
+    edge->Set( _LayerEdge::MULTI_NORMAL );
+  }
 
-  return resNorm;
+  return ( resMinDot > wgtMinDot ) ? resNorm : wgtNorm;
+}
+
+//================================================================================
+/*!
+ * \brief Compute line of intersection of 2 planes
+ */
+//================================================================================
+
+void _OffsetPlane::ComputeIntersectionLine( _OffsetPlane& pln )
+{
+  int iNext = bool( _faceIndexNext[0] >= 0 );
+  _faceIndexNext[ iNext ] = pln._faceIndex;
+
+  gp_XYZ n1 = _plane.Axis().Direction().XYZ();
+  gp_XYZ n2 = pln._plane.Axis().Direction().XYZ();
+
+  gp_XYZ lineDir = n1 ^ n2;
+
+  double x = Abs( lineDir.X() );
+  double y = Abs( lineDir.Y() );
+  double z = Abs( lineDir.Z() );
+
+  int cooMax; // max coordinate
+  if (x > y) {
+    if (x > z) cooMax = 1;
+    else       cooMax = 3;
+  }
+  else {
+    if (y > z) cooMax = 2;
+    else       cooMax = 3;
+  }
+
+  if ( Abs( lineDir.Coord( cooMax )) < 0.05 )
+    return;
+
+  gp_Pnt linePos;
+  // the constants in the 2 plane equations
+  double d1 = - ( _plane.Axis().Direction().XYZ()     * _plane.Location().XYZ() );
+  double d2 = - ( pln._plane.Axis().Direction().XYZ() * pln._plane.Location().XYZ() );
+
+  switch ( cooMax ) {
+  case 1:
+    linePos.SetX(  0 );
+    linePos.SetY(( d2*n1.Z() - d1*n2.Z()) / lineDir.X() );
+    linePos.SetZ(( d1*n2.Y() - d2*n1.Y()) / lineDir.X() );
+    break;
+  case 2:
+    linePos.SetX(( d1*n2.Z() - d2*n1.Z()) / lineDir.Y() );
+    linePos.SetY(  0 );
+    linePos.SetZ(( d2*n1.X() - d1*n2.X()) / lineDir.Y() );
+    break;
+  case 3:
+    linePos.SetX(( d2*n1.Y() - d1*n2.Y()) / lineDir.Z() );
+    linePos.SetY(( d1*n2.X() - d2*n1.X()) / lineDir.Z() );
+    linePos.SetZ(  0 );
+  }
+
+  gp_Lin& line = _lines[ iNext ];
+  line.SetDirection( lineDir );
+  line.SetLocation ( linePos );
+
+  _isLineOK[ iNext ] = true;
+
+
+  iNext = bool( pln._faceIndexNext[0] >= 0 );
+  pln._lines        [ iNext ] = line;
+  pln._faceIndexNext[ iNext ] = this->_faceIndex;
+  pln._isLineOK     [ iNext ] = true;
+}
+
+//================================================================================
+/*!
+ * \brief Computes intersection point of two _lines
+ */
+//================================================================================
+
+gp_XYZ _OffsetPlane::GetCommonPoint(bool& isFound) const
+{
+  gp_XYZ p( 0,0,0 );
+  isFound = false;
+
+  if ( NbLines() == 2 )
+  {
+    gp_Vec lPerp0 = _lines[0].Direction().XYZ() ^ _plane.Axis().Direction().XYZ();
+    gp_Vec   l0l1 = _lines[1].Location().XYZ() - _lines[0].Location().XYZ();
+    double  dot01 = lPerp0 * _lines[1].Direction().XYZ();
+    if ( Abs( dot01 ) > std::numeric_limits<double>::min() )
+    {
+      double u1 = - ( lPerp0 * l0l1 ) / dot01;
+      p = ( _lines[1].Location().XYZ() + _lines[1].Direction().XYZ() * u1 );
+      isFound = true;
+    }
+  }
+
+  return p;
 }
 
 //================================================================================
@@ -3383,7 +3952,7 @@ void _LayerEdge::SetDataByNeighbors( const SMDS_MeshNode* n1,
   if ( eos.ShapeType() != TopAbs_EDGE )
     return;
 
-  gp_XYZ pos = SMESH_TNodeXYZ( _nodes[0] );
+  gp_XYZ  pos = SMESH_TNodeXYZ( _nodes[0] );
   gp_XYZ vec1 = pos - SMESH_TNodeXYZ( n1 );
   gp_XYZ vec2 = pos - SMESH_TNodeXYZ( n2 );
 
@@ -3472,7 +4041,20 @@ void _LayerEdge::SetCosin( double cosin )
 {
   _cosin = cosin;
   cosin = Abs( _cosin );
-  _lenFactor = ( /*0.1 < cosin &&*/ cosin < 1-1e-12 ) ?  1./sqrt(1-cosin*cosin) : 1.0;
+  //_lenFactor = ( cosin < 1.-1e-12 ) ?  Min( 2., 1./sqrt(1-cosin*cosin )) : 1.0;
+  _lenFactor = ( cosin < 1.-1e-12 ) ?  1./sqrt(1-cosin*cosin ) : 1.0;
+}
+
+//================================================================================
+/*!
+ * \brief Check if another _LayerEdge is a neighbor on EDGE
+ */
+//================================================================================
+
+bool _LayerEdge::IsNeiborOnEdge( const _LayerEdge* edge ) const
+{
+  return (( this->_2neibors && this->_2neibors->include( edge )) ||
+          ( edge->_2neibors && edge->_2neibors->include( this )));
 }
 
 //================================================================================
@@ -3501,7 +4083,7 @@ void _Simplex::GetSimplices( const SMDS_MeshNode* node,
     const SMDS_MeshNode* nOpp  = f->GetNode( SMESH_MesherHelper::WrapIndex( srcInd+2, nbNodes ));
     if ( dataToCheckOri && dataToCheckOri->_reversedFaceIds.count( shapeInd ))
       std::swap( nPrev, nNext );
-    simplices.push_back( _Simplex( nPrev, nNext, nOpp ));
+    simplices.push_back( _Simplex( nPrev, nNext, ( nbNodes == 3 ? 0 : nOpp )));
   }
 
   if ( toSort )
@@ -3518,7 +4100,7 @@ void _Simplex::SortSimplices(vector<_Simplex>& simplices)
 {
   vector<_Simplex> sortedSimplices( simplices.size() );
   sortedSimplices[0] = simplices[0];
-  int nbFound = 0;
+  size_t nbFound = 0;
   for ( size_t i = 1; i < simplices.size(); ++i )
   {
     for ( size_t j = 1; j < simplices.size(); ++j )
@@ -3551,9 +4133,13 @@ void _ViscousBuilder::makeGroupOfLE()
     for ( n2e = _sdVec[i]._n2eMap.begin(); n2e != _sdVec[i]._n2eMap.end(); ++n2e )
     {
       _LayerEdge* le = n2e->second;
-      for ( size_t iN = 1; iN < le->_nodes.size(); ++iN )
-        dumpCmd(SMESH_Comment("mesh.AddEdge([ ") <<le->_nodes[iN-1]->GetID()
-                << ", " << le->_nodes[iN]->GetID() <<"])");
+      // for ( size_t iN = 1; iN < le->_nodes.size(); ++iN )
+      //   dumpCmd(SMESH_Comment("mesh.AddEdge([ ") <<le->_nodes[iN-1]->GetID()
+      //           << ", " << le->_nodes[iN]->GetID() <<"])");
+      if ( le ) {
+        dumpCmd(SMESH_Comment("mesh.AddEdge([ ") <<le->_nodes[0]->GetID()
+                << ", " << le->_nodes.back()->GetID() <<"]) # " << le->_flags );
+      }
     }
     dumpFunctionEnd();
 
@@ -3564,7 +4150,7 @@ void _ViscousBuilder::makeGroupOfLE()
       SMESH_TNodeXYZ nXYZ( edge->_nodes[0] );
       nXYZ += edge->_normal * _sdVec[i]._stepSize;
       dumpCmd(SMESH_Comment("mesh.AddEdge([ ") << edge->_nodes[0]->GetID()
-              << ", mesh.AddNode( " << nXYZ.X()<<","<< nXYZ.Y()<<","<< nXYZ.Z()<<")])");
+              << ", mesh.AddNode( "<< nXYZ.X()<<","<< nXYZ.Y()<<","<< nXYZ.Z()<<")])");
     }
     dumpFunctionEnd();
 
@@ -3573,7 +4159,7 @@ void _ViscousBuilder::makeGroupOfLE()
     TopExp_Explorer fExp( _sdVec[i]._solid, TopAbs_FACE );
     for ( ; fExp.More(); fExp.Next() )
     {
-      if (const SMESHDS_SubMesh* sm = _sdVec[i]._proxyMesh->GetProxySubMesh( fExp.Current()))
+      if ( const SMESHDS_SubMesh* sm = _sdVec[i]._proxyMesh->GetProxySubMesh( fExp.Current() ))
       {
         if ( sm->NbElements() == 0 ) continue;
         SMDS_ElemIteratorPtr fIt = sm->GetElements();
@@ -3581,8 +4167,8 @@ void _ViscousBuilder::makeGroupOfLE()
         {
           const SMDS_MeshElement* e = fIt->next();
           SMESH_Comment cmd("mesh.AddFace([");
-          for ( int j=0; j < e->NbCornerNodes(); ++j )
-            cmd << e->GetNode(j)->GetID() << (j+1<e->NbCornerNodes() ? ",": "])");
+          for ( int j = 0; j < e->NbCornerNodes(); ++j )
+            cmd << e->GetNode(j)->GetID() << (j+1 < e->NbCornerNodes() ? ",": "])");
           dumpCmd( cmd );
         }
       }
@@ -3606,20 +4192,46 @@ void _ViscousBuilder::computeGeomSize( _SolidData& data )
 {
   data._geomSize = Precision::Infinite();
   double intersecDist;
-  auto_ptr<SMESH_ElementSearcher> searcher
+  const SMDS_MeshElement* face;
+  SMESH_MesherHelper helper( *_mesh );
+
+  SMESHUtils::Deleter<SMESH_ElementSearcher> searcher
     ( SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(),
-                                           data._proxyMesh->GetFaces( data._solid )) );
+                                           data._proxyMesh->GetFaces( data._solid )));
 
   for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
     _EdgesOnShape& eos = data._edgesOnShape[ iS ];
-    if ( eos._edges.empty() || eos.ShapeType() == TopAbs_EDGE )
+    if ( eos._edges.empty() )
       continue;
+    // get neighbor faces intersection with which should not be considered since
+    // collisions are avoided by means of smoothing
+    set< TGeomID > neighborFaces;
+    if ( eos._hyp.ToSmooth() )
+    {
+      SMESH_subMeshIteratorPtr subIt =
+        eos._subMesh->getDependsOnIterator(/*includeSelf=*/eos.ShapeType() != TopAbs_FACE );
+      while ( subIt->more() )
+      {
+        SMESH_subMesh* sm = subIt->next();
+        PShapeIteratorPtr fIt = helper.GetAncestors( sm->GetSubShape(), *_mesh, TopAbs_FACE );
+        while ( const TopoDS_Shape* face = fIt->next() )
+          neighborFaces.insert( getMeshDS()->ShapeToIndex( *face ));
+      }
+    }
+    // find intersections
+    double thinkness = eos._hyp.GetTotalThickness();
     for ( size_t i = 0; i < eos._edges.size(); ++i )
     {
-      eos._edges[i]->FindIntersection( *searcher, intersecDist, data._epsilon, eos );
-      if ( data._geomSize > intersecDist && intersecDist > 0 )
-        data._geomSize = intersecDist;
+      if ( eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+      eos._edges[i]->_maxLen = thinkness;
+      eos._edges[i]->FindIntersection( *searcher, intersecDist, data._epsilon, eos, &face );
+      if ( intersecDist > 0 && face )
+      {
+        data._geomSize = Min( data._geomSize, intersecDist );
+        if ( !neighborFaces.count( face->getshapeId() ))
+          eos._edges[i]->_maxLen = Min( thinkness, intersecDist / ( face->GetID() < 0 ? 3. : 2. ));
+      }
     }
   }
 }
@@ -3648,6 +4260,15 @@ bool _ViscousBuilder::inflate(_SolidData& data)
 
   debugMsg( "-- geomSize = " << data._geomSize << ", stepSize = " << data._stepSize );
 
+  findCollisionEdges( data, helper );
+
+  // limit length of _LayerEdge's around MULTI_NORMAL _LayerEdge's
+  for ( size_t i = 0; i < data._edgesOnShape.size(); ++i )
+    if ( data._edgesOnShape[i].ShapeType() == TopAbs_VERTEX &&
+         data._edgesOnShape[i]._edges.size() > 0 &&
+         data._edgesOnShape[i]._edges[0]->Is( _LayerEdge::MULTI_NORMAL ))
+      data._edgesOnShape[i]._edges[0]->Block( data );
+
   const double safeFactor = ( 2*data._maxThickness < data._geomSize ) ? 1 : theThickToIntersection;
 
   double avgThick = 0, curThick = 0, distToIntersection = Precision::Infinite();
@@ -3655,6 +4276,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
   while ( avgThick < 0.99 )
   {
     // new target length
+    double prevThick = curThick;
     curThick += data._stepSize;
     if ( curThick > tgtThick )
     {
@@ -3662,6 +4284,9 @@ bool _ViscousBuilder::inflate(_SolidData& data)
       nbRepeats++;
     }
 
+    double stepSize = curThick - prevThick;
+    updateNormalsOfSmoothed( data, helper, nbSteps, stepSize ); // to ease smoothing
+
     // Elongate _LayerEdge's
     dumpFunction(SMESH_Comment("inflate")<<data._index<<"_step"<<nbSteps); // debug
     for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
@@ -3677,7 +4302,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
     }
     dumpFunctionEnd();
 
-    if ( !updateNormals( data, helper, nbSteps ))
+    if ( !updateNormals( data, helper, nbSteps, stepSize )) // to avoid collisions
       return false;
 
     // Improve and check quality
@@ -3704,6 +4329,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
 
     // Evaluate achieved thickness
     avgThick = 0;
+    int nbActiveEdges = 0;
     for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
     {
       _EdgesOnShape& eos = data._edgesOnShape[iS];
@@ -3712,12 +4338,20 @@ bool _ViscousBuilder::inflate(_SolidData& data)
       const double shapeTgtThick = eos._hyp.GetTotalThickness();
       for ( size_t i = 0; i < eos._edges.size(); ++i )
       {
-        avgThick += Min( 1., eos._edges[i]->_len / shapeTgtThick );
+        avgThick      += Min( 1., eos._edges[i]->_len / shapeTgtThick );
+        nbActiveEdges += ( ! eos._edges[i]->Is( _LayerEdge::BLOCKED ));
       }
     }
     avgThick /= data._n2eMap.size();
     debugMsg( "-- Thickness " << curThick << " ("<< avgThick*100 << "%) reached" );
 
+#ifdef BLOCK_INFLATION
+    if ( nbActiveEdges == 0 )
+    {
+      debugMsg( "-- Stop inflation since all _LayerEdge's BLOCKED " );
+      break;
+    }
+#else
     if ( distToIntersection < tgtThick * avgThick * safeFactor && avgThick < 0.9 )
     {
       debugMsg( "-- Stop inflation since "
@@ -3725,6 +4359,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
                 << tgtThick * avgThick << " ) * " << safeFactor );
       break;
     }
+#endif
     // new step size
     limitStepSize( data, 0.25 * distToIntersection );
     if ( data._stepSizeNodes[0] )
@@ -3733,7 +4368,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
 
   } // while ( avgThick < 0.99 )
 
-  if (nbSteps == 0 )
+  if ( nbSteps == 0 )
     return error("failed at the very first inflation step", data._index);
 
   if ( avgThick < 0.99 )
@@ -3748,7 +4383,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
     }
   }
 
-  // Restore position of src nodes moved by infaltion on _noShrinkShapes
+  // Restore position of src nodes moved by inflation on _noShrinkShapes
   dumpFunction(SMESH_Comment("restoNoShrink_So")<<data._index); // debug
   for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
@@ -3761,7 +4396,7 @@ bool _ViscousBuilder::inflate(_SolidData& data)
   }
   dumpFunctionEnd();
 
-  return true;
+  return safeFactor > 0; // == true (avoid warning: unused variable 'safeFactor')
 }
 
 //================================================================================
@@ -3771,24 +4406,27 @@ bool _ViscousBuilder::inflate(_SolidData& data)
 //================================================================================
 
 bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
-                                     const int   nbSteps,
+                                     const int   infStep,
                                      double &    distToIntersection)
 {
   if ( data._nbShapesToSmooth == 0 )
     return true; // no shapes needing smoothing
 
   bool moved, improved;
-  vector< _LayerEdge* > badSmooEdges;
+  double vol;
+  vector< _LayerEdge* >    movedEdges, badSmooEdges;
+  vector< _EdgesOnShape* > eosC1; // C1 continues shapes
+  vector< bool >           isConcaveFace;
 
   SMESH_MesherHelper helper(*_mesh);
-  Handle(Geom_Surface) surface;
+  Handle(ShapeAnalysis_Surface) surface;
   TopoDS_Face F;
 
   for ( int isFace = 0; isFace < 2; ++isFace ) // smooth on [ EDGEs, FACEs ]
   {
     const TopAbs_ShapeEnum shapeType = isFace ? TopAbs_FACE : TopAbs_EDGE;
 
-    for ( int iS = 0; iS < data._edgesOnShape.size(); ++iS )
+    for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
     {
       _EdgesOnShape& eos = data._edgesOnShape[ iS ];
       if ( !eos._toSmooth ||
@@ -3797,24 +4435,28 @@ bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
         continue;
 
       // already smoothed?
-      bool toSmooth = ( eos._edges[ 0 ]->NbSteps() >= nbSteps+1 );
-      if ( !toSmooth ) continue;
+      // bool toSmooth = ( eos._edges[ 0 ]->NbSteps() >= infStep+1 );
+      // if ( !toSmooth ) continue;
 
       if ( !eos._hyp.ToSmooth() )
       {
         // smooth disabled by the user; check validy only
         if ( !isFace ) continue;
-        double vol;
         for ( size_t i = 0; i < eos._edges.size(); ++i )
         {
           _LayerEdge* edge = eos._edges[i];
-          const gp_XYZ& curPos (  );
           for ( size_t iF = 0; iF < edge->_simplices.size(); ++iF )
-            if ( !edge->_simplices[iF].IsForward( edge->_nodes[0],
-                                                 &edge->_pos.back(), vol ))
+            if ( !edge->_simplices[iF].IsForward( edge->_nodes[0], edge->_pos.back(), vol ))
+            {
+              debugMsg( "-- Stop inflation. Bad simplex ("
+                        << " "<< edge->_nodes[0]->GetID()
+                        << " "<< edge->_nodes.back()->GetID()
+                        << " "<< edge->_simplices[iF]._nPrev->GetID()
+                        << " "<< edge->_simplices[iF]._nNext->GetID() << " ) ");
               return false;
+            }
         }
-        continue; // goto to the next EDGE or FACE
+        continue; // goto the next EDGE or FACE
       }
 
       // prepare data
@@ -3823,7 +4465,7 @@ bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
         if ( !F.IsSame( eos._sWOL )) {
           F = TopoDS::Face( eos._sWOL );
           helper.SetSubShape( F );
-          surface = BRep_Tool::Surface( F );
+          surface = helper.GetSurface( F );
         }
       }
       else
@@ -3836,12 +4478,11 @@ bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
 
       if ( eos.ShapeType() == TopAbs_EDGE )
       {
-        dumpFunction(SMESH_Comment("smooth")<<data._index << "_Ed"<<sInd <<"_InfStep"<<nbSteps);
+        dumpFunction(SMESH_Comment("smooth")<<data._index << "_Ed"<<sInd <<"_InfStep"<<infStep);
 
-        // try a simple solution on an analytic EDGE
-        if ( !smoothAnalyticEdge( data, eos, surface, F, helper ))
+        if ( !eos._edgeSmoother->Perform( data, surface, F, helper ))
         {
-          // smooth on EDGE's
+          // smooth on EDGE's (normally we should not get here)
           int step = 0;
           do {
             moved = false;
@@ -3855,118 +4496,240 @@ bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
         }
         dumpFunctionEnd();
       }
-      else
+
+      else // smooth on FACE
       {
-        // smooth on FACE's
+        eosC1.clear();
+        eosC1.push_back( & eos );
+        eosC1.insert( eosC1.end(), eos._eosC1.begin(), eos._eosC1.end() );
 
-        const bool isConcaveFace = data._concaveFaces.count( sInd );
+        movedEdges.clear();
+        isConcaveFace.resize( eosC1.size() );
+        for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
+        {
+          isConcaveFace[ iEOS ] = data._concaveFaces.count( eosC1[ iEOS ]->_shapeID  );
+          vector< _LayerEdge* > & edges = eosC1[ iEOS ]->_edges;
+          for ( size_t i = 0; i < edges.size(); ++i )
+            if ( edges[i]->Is( _LayerEdge::MOVED ) ||
+                 edges[i]->Is( _LayerEdge::NEAR_BOUNDARY ))
+              movedEdges.push_back( edges[i] );
+
+          makeOffsetSurface( *eosC1[ iEOS ], helper );
+        }
 
         int step = 0, stepLimit = 5, badNb = 0;
         while (( ++step <= stepLimit ) || improved )
         {
           dumpFunction(SMESH_Comment("smooth")<<data._index<<"_Fa"<<sInd
-                       <<"_InfStep"<<nbSteps<<"_"<<step); // debug
+                       <<"_InfStep"<<infStep<<"_"<<step); // debug
           int oldBadNb = badNb;
           badSmooEdges.clear();
 
-          if ( step % 2 ) {
-            for ( size_t i = 0; i < eos._edges.size(); ++i )  // iterate forward
-              if ( eos._edges[i]->Smooth( step, isConcaveFace, false ))
-                badSmooEdges.push_back( eos._edges[i] );
+#ifdef INCREMENTAL_SMOOTH
+          bool findBest = false; // ( step == stepLimit );
+          for ( size_t i = 0; i < movedEdges.size(); ++i )
+          {
+            movedEdges[i]->Unset( _LayerEdge::SMOOTHED );
+            if ( movedEdges[i]->Smooth( step, findBest, movedEdges ) > 0 )
+              badSmooEdges.push_back( movedEdges[i] );
           }
-
-          else {
-            for ( int i = eos._edges.size()-1; i >= 0; --i ) // iterate backward
-              if ( eos._edges[i]->Smooth( step, isConcaveFace, false ))
+#else
+          bool findBest = ( step == stepLimit || isConcaveFace[ iEOS ]);
+          for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
+          {
+            vector< _LayerEdge* > & edges = eosC1[ iEOS ]->_edges;
+            for ( size_t i = 0; i < edges.size(); ++i )
+            {
+              edges[i]->Unset( _LayerEdge::SMOOTHED );
+              if ( edges[i]->Smooth( step, findBest, false ) > 0 )
                 badSmooEdges.push_back( eos._edges[i] );
+            }
           }
+#endif
           badNb = badSmooEdges.size();
-          improved = ( badNb < oldBadNb );
+
+          if ( badNb > 0 )
+            debugMsg(SMESH_Comment("badNb = ") << badNb );
 
           if ( !badSmooEdges.empty() && step >= stepLimit / 2 )
           {
+            if ( badSmooEdges[0]->Is( _LayerEdge::ON_CONCAVE_FACE ))
+              stepLimit = 9;
+
+            // resolve hard smoothing situation around concave VERTEXes
+            for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
+            {
+              vector< _EdgesOnShape* > & eosCoVe = eosC1[ iEOS ]->_eosConcaVer;
+              for ( size_t i = 0; i < eosCoVe.size(); ++i )
+                eosCoVe[i]->_edges[0]->MoveNearConcaVer( eosCoVe[i], eosC1[ iEOS ],
+                                                         step, badSmooEdges );
+            }
             // look for the best smooth of _LayerEdge's neighboring badSmooEdges
-            vector<_Simplex> simplices;
+            badNb = 0;
             for ( size_t i = 0; i < badSmooEdges.size(); ++i )
             {
               _LayerEdge* ledge = badSmooEdges[i];
-              _Simplex::GetSimplices( ledge->_nodes[0], simplices, data._ignoreFaceIds );
-              for ( size_t iS = 0; iS < simplices.size(); ++iS )
+              for ( size_t iN = 0; iN < ledge->_neibors.size(); ++iN )
               {
-                TNode2Edge::iterator n2e = data._n2eMap.find( simplices[iS]._nNext );
-                if ( n2e != data._n2eMap.end()) {
-                  _LayerEdge* ledge2 = n2e->second;
-                  if ( ledge2->_nodes[0]->getshapeId() == sInd )
-                    ledge2->Smooth( step, isConcaveFace, /*findBest=*/true );
-                }
+                ledge->_neibors[iN]->Unset( _LayerEdge::SMOOTHED );
+                badNb += ledge->_neibors[iN]->Smooth( step, true, /*findBest=*/true );
               }
+              ledge->Unset( _LayerEdge::SMOOTHED );
+              badNb += ledge->Smooth( step, true, /*findBest=*/true );
+            }
+            debugMsg(SMESH_Comment("badNb = ") << badNb );
+          }
+
+          if ( badNb == oldBadNb  &&
+               badNb > 0 &&
+               step < stepLimit ) // smooth w/o chech of validity
+          {
+            dumpFunctionEnd();
+            dumpFunction(SMESH_Comment("smoothWoCheck")<<data._index<<"_Fa"<<sInd
+                         <<"_InfStep"<<infStep<<"_"<<step); // debug
+            for ( size_t i = 0; i < movedEdges.size(); ++i )
+            {
+              movedEdges[i]->SmoothWoCheck();
             }
+            if ( stepLimit < 9 )
+              stepLimit++;
           }
-          // issue 22576 -- no bad faces but still there are intersections to fix
-          // if ( improved && badNb == 0 )
-          //   stepLimit = step + 3;
+
+          improved = ( badNb < oldBadNb );
 
           dumpFunctionEnd();
+
+          if (( step % 3 == 1 ) || ( badNb > 0 && step >= stepLimit / 2 ))
+            for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
+            {
+              putOnOffsetSurface( *eosC1[ iEOS ], infStep, step, /*moveAll=*/step == 1 );
+            }
+
+        } // smoothing steps
+
+        // project -- to prevent intersections or fix bad simplices
+        for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
+        {
+          if ( ! eosC1[ iEOS ]->_eosConcaVer.empty() || badNb > 0 )
+            putOnOffsetSurface( *eosC1[ iEOS ], infStep );
         }
-        if ( badNb > 0 )
+
+        if ( !badSmooEdges.empty() )
         {
-#ifdef __myDEBUG
-          double vol = 0;
-          for ( int i = 0; i < eos._edges.size(); ++i )
+          badSmooEdges.clear();
+          for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
           {
-            _LayerEdge* edge = eos._edges[i];
-            SMESH_TNodeXYZ tgtXYZ( edge->_nodes.back() );
-            for ( size_t j = 0; j < edge->_simplices.size(); ++j )
-              if ( !edge->_simplices[j].IsForward( edge->_nodes[0], &tgtXYZ, vol ))
+            for ( size_t i = 0; i < eosC1[ iEOS ]->_edges.size(); ++i )
+            {
+              if ( !eosC1[ iEOS ]->_sWOL.IsNull() ) continue;
+
+              _LayerEdge* edge = eosC1[ iEOS ]->_edges[i];
+              edge->CheckNeiborsOnBoundary( & badSmooEdges );
+              if ( badNb > 0 )
               {
-                cout << "Bad simplex ( " << edge->_nodes[0]->GetID()<< " "<< tgtXYZ._node->GetID()
-                     << " "<< edge->_simplices[j]._nPrev->GetID()
-                     << " "<< edge->_simplices[j]._nNext->GetID() << " )" << endl;
-                return false;
+                SMESH_TNodeXYZ tgtXYZ = edge->_nodes.back();
+                const gp_XYZ& prevXYZ = edge->PrevCheckPos();
+                for ( size_t j = 0; j < edge->_simplices.size(); ++j )
+                  if ( !edge->_simplices[j].IsForward( &prevXYZ, &tgtXYZ, vol ))
+                  {
+                    debugMsg("Bad simplex ( " << edge->_nodes[0]->GetID()
+                             << " "<< tgtXYZ._node->GetID()
+                             << " "<< edge->_simplices[j]._nPrev->GetID()
+                             << " "<< edge->_simplices[j]._nNext->GetID() << " )" );
+                    badSmooEdges.push_back( edge );
+                    break;
+                  }
               }
+            }
           }
-#endif
-          return false;
+
+          // try to fix bad simplices by removing the last inflation step of some _LayerEdge's
+          badNb = invalidateBadSmooth( data, helper, badSmooEdges, eosC1, infStep );
+
+          if ( badNb > 0 )
+            return false;
         }
+
       } // // smooth on FACE's
     } // loop on shapes
   } // smooth on [ EDGEs, FACEs ]
 
-  // Check orientation of simplices of _ConvexFace::_simplexTestEdges
-  map< TGeomID, _ConvexFace >::iterator id2face = data._convexFaces.begin();
-  for ( ; id2face != data._convexFaces.end(); ++id2face )
+  // Check orientation of simplices of _LayerEdge's on EDGEs and VERTEXes
+  eosC1.resize(1);
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
-    _ConvexFace & convFace = (*id2face).second;
-    if ( !convFace._simplexTestEdges.empty() &&
-         convFace._simplexTestEdges[0]->_nodes[0]->GetPosition()->GetDim() == 2 )
-      continue; // _simplexTestEdges are based on FACE -- already checked while smoothing
+    _EdgesOnShape& eos = data._edgesOnShape[ iS ];
+    if ( eos.ShapeType() == TopAbs_FACE ||
+         eos._edges.empty() ||
+         !eos._sWOL.IsNull() )
+      continue;
+
+    badSmooEdges.clear();
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
+    {
+      _LayerEdge*      edge = eos._edges[i];
+      if ( edge->_nodes.size() < 2 ) continue;
+      SMESH_TNodeXYZ tgtXYZ = edge->_nodes.back();
+      //const gp_XYZ& prevXYZ = edge->PrevCheckPos();
+      const gp_XYZ& prevXYZ = edge->PrevPos();
+      for ( size_t j = 0; j < edge->_simplices.size(); ++j )
+        if ( !edge->_simplices[j].IsForward( &prevXYZ, &tgtXYZ, vol ))
+        {
+          debugMsg("Bad simplex on bnd ( " << edge->_nodes[0]->GetID()
+                   << " "<< tgtXYZ._node->GetID()
+                   << " "<< edge->_simplices[j]._nPrev->GetID()
+                   << " "<< edge->_simplices[j]._nNext->GetID() << " )" );
+          badSmooEdges.push_back( edge );
+          break;
+        }
+    }
 
-    if ( !convFace.CheckPrisms() )
+    // try to fix bad simplices by removing the last inflation step of some _LayerEdge's
+    eosC1[0] = &eos;
+    int badNb = invalidateBadSmooth( data, helper, badSmooEdges, eosC1, infStep );
+    if ( badNb > 0 )
       return false;
   }
 
+
   // Check if the last segments of _LayerEdge intersects 2D elements;
   // checked elements are either temporary faces or faces on surfaces w/o the layers
 
-  auto_ptr<SMESH_ElementSearcher> searcher
+  SMESHUtils::Deleter<SMESH_ElementSearcher> searcher
     ( SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(),
                                            data._proxyMesh->GetFaces( data._solid )) );
 
+#ifdef BLOCK_INFLATION
+  const bool toBlockInfaltion = true;
+#else
+  const bool toBlockInfaltion = false;
+#endif
   distToIntersection = Precision::Infinite();
   double dist;
   const SMDS_MeshElement* intFace = 0;
   const SMDS_MeshElement* closestFace = 0;
   _LayerEdge* le = 0;
-  for ( int iS = 0; iS < data._edgesOnShape.size(); ++iS )
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
     _EdgesOnShape& eos = data._edgesOnShape[ iS ];
     if ( eos._edges.empty() || !eos._sWOL.IsNull() )
       continue;
     for ( size_t i = 0; i < eos._edges.size(); ++i )
     {
+      if ( eos._edges[i]->Is( _LayerEdge::INTERSECTED ) ||
+           eos._edges[i]->Is( _LayerEdge::MULTI_NORMAL ))
+        continue;
       if ( eos._edges[i]->FindIntersection( *searcher, dist, data._epsilon, eos, &intFace ))
         return false;
-      if ( distToIntersection > dist )
+      if ( !intFace )
+      {
+        SMESH_Comment msg("Invalid? normal at node "); msg << eos._edges[i]->_nodes[0]->GetID();
+        debugMsg( msg );
+        continue; 
+      }
+
+      const bool isShorterDist = ( distToIntersection > dist );
+      if ( toBlockInfaltion || isShorterDist )
       {
         // ignore intersection of a _LayerEdge based on a _ConvexFace with a face
         // lying on this _ConvexFace
@@ -3979,12 +4742,78 @@ bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
         if ( intFace->getshapeId() == eos._shapeID  )
           continue;
 
-        distToIntersection = dist;
-        le = eos._edges[i];
-        closestFace = intFace;
-      }
-    }
-  }
+        // ignore intersection with intFace of an adjacent FACE
+        if ( dist > 0 )
+        {
+          bool toIgnore = false;
+          if (  eos._edges[i]->Is( _LayerEdge::TO_SMOOTH ))
+          {
+            const TopoDS_Shape& S = getMeshDS()->IndexToShape( intFace->getshapeId() );
+            if ( !S.IsNull() && S.ShapeType() == TopAbs_FACE )
+            {
+              TopExp_Explorer edge( eos._shape, TopAbs_EDGE );
+              for ( ; !toIgnore && edge.More(); edge.Next() )
+                // is adjacent - has a common EDGE
+                toIgnore = ( helper.IsSubShape( edge.Current(), S ));
+
+              if ( toIgnore ) // check angle between normals
+              {
+                gp_XYZ normal;
+                if ( SMESH_MeshAlgos::FaceNormal( intFace, normal, /*normalized=*/true ))
+                  toIgnore  = ( normal * eos._edges[i]->_normal > -0.5 );
+              }
+            }
+          }
+          if ( !toIgnore ) // check if the edge is a neighbor of intFace
+          {
+            for ( size_t iN = 0; !toIgnore &&  iN < eos._edges[i]->_neibors.size(); ++iN )
+            {
+              int nInd = intFace->GetNodeIndex( eos._edges[i]->_neibors[ iN ]->_nodes.back() );
+              toIgnore = ( nInd >= 0 );
+            }
+          }
+          if ( toIgnore )
+            continue;
+        }
+
+        // intersection not ignored
+
+        if ( toBlockInfaltion &&
+             dist < ( eos._edges[i]->_len * theThickToIntersection ))
+        {
+          eos._edges[i]->Set( _LayerEdge::INTERSECTED ); // not to intersect
+          eos._edges[i]->Block( data );                  // not to inflate
+
+          if ( _EdgesOnShape* eof = data.GetShapeEdges( intFace->getshapeId() ))
+          {
+            // block _LayerEdge's, on top of which intFace is
+            if ( const _TmpMeshFace* f = dynamic_cast< const _TmpMeshFace*>( intFace ))
+            {
+              const SMDS_MeshElement* srcFace =
+                eof->_subMesh->GetSubMeshDS()->GetElement( f->getIdInShape() );
+              SMDS_ElemIteratorPtr nIt = srcFace->nodesIterator();
+              while ( nIt->more() )
+              {
+                const SMDS_MeshNode* srcNode = static_cast<const SMDS_MeshNode*>( nIt->next() );
+                TNode2Edge::iterator n2e = data._n2eMap.find( srcNode );
+                if ( n2e != data._n2eMap.end() )
+                  n2e->second->Block( data );
+              }
+            }
+          }
+        }
+
+        if ( isShorterDist )
+        {
+          distToIntersection = dist;
+          le = eos._edges[i];
+          closestFace = intFace;
+        }
+
+      } // if ( toBlockInfaltion || isShorterDist )
+    } // loop on eos._edges
+  } // loop on data._edgesOnShape
+
 #ifdef __myDEBUG
   if ( closestFace )
   {
@@ -4001,182 +4830,841 @@ bool _ViscousBuilder::smoothAndCheck(_SolidData& data,
 
 //================================================================================
 /*!
- * \brief Return a curve of the EDGE to be used for smoothing and arrange
- *        _LayerEdge's to be in a consequent order
+ * \brief try to fix bad simplices by removing the last inflation step of some _LayerEdge's
+ *  \param [in,out] badSmooEdges - _LayerEdge's to fix
+ *  \return int - resulting nb of bad _LayerEdge's
  */
 //================================================================================
 
-Handle(Geom_Curve) _SolidData::CurveForSmooth( const TopoDS_Edge&    E,
-                                               _EdgesOnShape&        eos,
-                                               SMESH_MesherHelper&   helper)
+int _ViscousBuilder::invalidateBadSmooth( _SolidData&               data,
+                                          SMESH_MesherHelper&       helper,
+                                          vector< _LayerEdge* >&    badSmooEdges,
+                                          vector< _EdgesOnShape* >& eosC1,
+                                          const int                 infStep )
 {
-  const TGeomID eIndex = eos._shapeID;
+  if ( badSmooEdges.empty() || infStep == 0 ) return 0;
 
-  map< TGeomID, Handle(Geom_Curve)>::iterator i2curve = _edge2curve.find( eIndex );
-
-  if ( i2curve == _edge2curve.end() )
-  {
-    // sort _LayerEdge's by position on the EDGE
-    SortOnEdge( E, eos._edges, helper );
+  dumpFunction(SMESH_Comment("invalidateBadSmooth")<<"_S"<<eosC1[0]->_shapeID<<"_InfStep"<<infStep);
 
-    SMESHDS_SubMesh* smDS = eos._subMesh->GetSubMeshDS();
+  data.UnmarkEdges();
 
-    TopLoc_Location loc; double f,l;
+  double vol;
+  for ( size_t i = 0; i < badSmooEdges.size(); ++i )
+  {
+    _LayerEdge* edge = badSmooEdges[i];
+    if ( edge->NbSteps() < 2 || edge->Is( _LayerEdge::MARKED ))
+      continue;
+    _EdgesOnShape* eos = data.GetShapeEdges( edge );
+    edge->InvalidateStep( edge->NbSteps(), *eos, /*restoreLength=*/true );
+    edge->Block( data );
+    edge->Set( _LayerEdge::MARKED );
+
+    if ( eos->ShapeType() == TopAbs_VERTEX )
+    {
+      // re-smooth on analytical EDGEs
+      PShapeIteratorPtr eIt = helper.GetAncestors( eos->_shape, *_mesh, TopAbs_EDGE );
+      while ( const TopoDS_Shape* e = eIt->next() )
+        if ( _EdgesOnShape* eoe = data.GetShapeEdges( *e ))
+          if ( eoe->_edgeSmoother && eoe->_edgeSmoother->isAnalytic() )
+          {
+            TopoDS_Face F; Handle(ShapeAnalysis_Surface) surface;
+            if ( eoe->SWOLType() == TopAbs_FACE ) {
+              F       = TopoDS::Face( eoe->_sWOL );
+              surface = helper.GetSurface( F );
+            }
+            eoe->_edgeSmoother->Perform( data, surface, F, helper );
+          }
+    }
 
-    Handle(Geom_Line)   line;
-    Handle(Geom_Circle) circle;
-    bool isLine, isCirc;
-    if ( eos._sWOL.IsNull() ) /////////////////////////////////////////// 3D case
+    // look for _LayerEdge's of bad _simplices
+    SMESH_TNodeXYZ tgtXYZ = edge->_nodes.back();
+    const gp_XYZ& prevXYZ = edge->PrevCheckPos();
+    for ( size_t j = 0; j < edge->_simplices.size(); ++j )
     {
-      // check if the EDGE is a line
-      Handle(Geom_Curve) curve = BRep_Tool::Curve( E, loc, f, l);
-      if ( curve->IsKind( STANDARD_TYPE( Geom_TrimmedCurve )))
-        curve = Handle(Geom_TrimmedCurve)::DownCast( curve )->BasisCurve();
-
-      line   = Handle(Geom_Line)::DownCast( curve );
-      circle = Handle(Geom_Circle)::DownCast( curve );
-      isLine = (!line.IsNull());
-      isCirc = (!circle.IsNull());
-
-      if ( !isLine && !isCirc ) // Check if the EDGE is close to a line
-      {
-        // Bnd_B3d bndBox;
-        // SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
-        // while ( nIt->more() )
-        //   bndBox.Add( SMESH_TNodeXYZ( nIt->next() ));
-        // gp_XYZ size = bndBox.CornerMax() - bndBox.CornerMin();
-
-        // gp_Pnt p0, p1;
-        // if ( eos._edges.size() > 1 ) {
-        //   p0 = SMESH_TNodeXYZ( eos._edges[0]->_nodes[0] );
-        //   p1 = SMESH_TNodeXYZ( eos._edges[1]->_nodes[0] );
-        // }
-        // else {
-        //   p0 = curve->Value( f );
-        //   p1 = curve->Value( l );
-        // }
-        // const double lineTol = 1e-2 * p0.Distance( p1 );
-        // for ( int i = 0; i < 3 && !isLine; ++i )
-        //   isLine = ( size.Coord( i+1 ) <= lineTol ); ////////// <--- WRONG
-
-        isLine = SMESH_Algo::IsStraight( E );
-
-        if ( isLine )
-          line = new Geom_Line( gp::OX() ); // only type does matter
-      }
-      if ( !isLine && !isCirc && eos._edges.size() > 2) // Check if the EDGE is close to a circle
-      {
-        // TODO
-      }
+      if ( edge->_simplices[j].IsForward( &prevXYZ, &tgtXYZ, vol ))
+        continue;
+      for ( size_t iN = 0; iN < edge->_neibors.size(); ++iN )
+        if ( edge->_simplices[j].Includes( edge->_neibors[iN]->_nodes.back() ))
+          badSmooEdges.push_back( edge->_neibors[iN] );
     }
-    else //////////////////////////////////////////////////////////////////////// 2D case
-    {
-      const TopoDS_Face& F = TopoDS::Face( eos._sWOL );
-
-      // check if the EDGE is a line
-      Handle(Geom2d_Curve) curve = BRep_Tool::CurveOnSurface( E, F, f, l);
-      if ( curve->IsKind( STANDARD_TYPE( Geom2d_TrimmedCurve )))
-        curve = Handle(Geom2d_TrimmedCurve)::DownCast( curve )->BasisCurve();
-
-      Handle(Geom2d_Line)   line2d   = Handle(Geom2d_Line)::DownCast( curve );
-      Handle(Geom2d_Circle) circle2d = Handle(Geom2d_Circle)::DownCast( curve );
-      isLine = (!line2d.IsNull());
-      isCirc = (!circle2d.IsNull());
-
-      if ( !isLine && !isCirc) // Check if the EDGE is close to a line
-      {
-        Bnd_B2d bndBox;
-        SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
-        while ( nIt->more() )
-          bndBox.Add( helper.GetNodeUV( F, nIt->next() ));
-        gp_XY size = bndBox.CornerMax() - bndBox.CornerMin();
+  }
 
-        const double lineTol = 1e-2 * sqrt( bndBox.SquareExtent() );
-        for ( int i = 0; i < 2 && !isLine; ++i )
-          isLine = ( size.Coord( i+1 ) <= lineTol );
-      }
-      if ( !isLine && !isCirc && eos._edges.size() > 2) // Check if the EDGE is close to a circle
-      {
-        // TODO
-      }
-      if ( isLine )
-      {
-        line = new Geom_Line( gp::OX() ); // only type does matter
-      }
-      else if ( isCirc )
-      {
-        gp_Pnt2d p = circle2d->Location();
-        gp_Ax2 ax( gp_Pnt( p.X(), p.Y(), 0), gp::DX());
-        circle = new Geom_Circle( ax, 1.); // only center position does matter
-      }
+  int badNb = 0;
+  for ( size_t iEOS = 0; iEOS < eosC1.size(); ++iEOS )
+  {
+    for ( size_t i = 0; i < eosC1[ iEOS ]->_edges.size(); ++i )
+    {
+      if ( !eosC1[ iEOS ]->_sWOL.IsNull() ) continue;
+      _LayerEdge*      edge = eosC1[ iEOS ]->_edges[i];
+      SMESH_TNodeXYZ tgtXYZ = edge->_nodes.back();
+      const gp_XYZ& prevXYZ = edge->PrevCheckPos();
+      for ( size_t j = 0; j < edge->_simplices.size(); ++j )
+        if ( !edge->_simplices[j].IsForward( &prevXYZ, &tgtXYZ, vol ))
+        {
+          ++badNb;
+          debugMsg("Bad simplex remains ( " << edge->_nodes[0]->GetID()
+                   << " "<< tgtXYZ._node->GetID()
+                   << " "<< edge->_simplices[j]._nPrev->GetID()
+                   << " "<< edge->_simplices[j]._nNext->GetID() << " )" );
+        }
     }
-
-    Handle(Geom_Curve)& res = _edge2curve[ eIndex ];
-    if ( isLine )
-      res = line;
-    else if ( isCirc )
-      res = circle;
-
-    return res;
   }
-  return i2curve->second;
+  dumpFunctionEnd();
+
+  return badNb;
 }
 
 //================================================================================
 /*!
- * \brief Sort _LayerEdge's by a parameter on a given EDGE
+ * \brief Create an offset surface
  */
 //================================================================================
 
-void _SolidData::SortOnEdge( const TopoDS_Edge&     E,
-                             vector< _LayerEdge* >& edges,
-                             SMESH_MesherHelper&    helper)
+void _ViscousBuilder::makeOffsetSurface( _EdgesOnShape& eos, SMESH_MesherHelper& helper )
 {
-  map< double, _LayerEdge* > u2edge;
-  for ( size_t i = 0; i < edges.size(); ++i )
-    u2edge.insert( make_pair( helper.GetNodeU( E, edges[i]->_nodes[0] ), edges[i] ));
+  if ( eos._offsetSurf.IsNull() ||
+       eos._edgeForOffset == 0 ||
+       eos._edgeForOffset->Is( _LayerEdge::BLOCKED ))
+    return;
 
-  ASSERT( u2edge.size() == edges.size() );
-  map< double, _LayerEdge* >::iterator u2e = u2edge.begin();
-  for ( int i = 0; i < edges.size(); ++i, ++u2e )
-    edges[i] = u2e->second;
+  Handle(ShapeAnalysis_Surface) baseSurface = helper.GetSurface( TopoDS::Face( eos._shape ));
 
-  Sort2NeiborsOnEdge( edges );
-}
+  // find offset
+  gp_Pnt   tgtP = SMESH_TNodeXYZ( eos._edgeForOffset->_nodes.back() );
+  gp_Pnt2d   uv = baseSurface->ValueOfUV( tgtP, Precision::Confusion() );
+  double offset = baseSurface->Gap();
 
-//================================================================================
-/*!
- * \brief Set _2neibors according to the order of _LayerEdge on EDGE
- */
-//================================================================================
+  eos._offsetSurf.Nullify();
 
-void _SolidData::Sort2NeiborsOnEdge( vector< _LayerEdge* >& edges )
-{
-  for ( size_t i = 0; i < edges.size()-1; ++i )
-    if ( edges[i]->_2neibors->tgtNode(1) != edges[i+1]->_nodes.back() )
-      edges[i]->_2neibors->reverse();
+  try
+  {
+    BRepOffsetAPI_MakeOffsetShape offsetMaker( eos._shape, -offset, Precision::Confusion() );
+    if ( !offsetMaker.IsDone() ) return;
 
-  const size_t iLast = edges.size() - 1;
-  if ( edges.size() > 1 &&
-       edges[iLast]->_2neibors->tgtNode(0) != edges[iLast-1]->_nodes.back() )
-    edges[iLast]->_2neibors->reverse();
+    TopExp_Explorer fExp( offsetMaker.Shape(), TopAbs_FACE );
+    if ( !fExp.More() ) return;
+
+    TopoDS_Face F = TopoDS::Face( fExp.Current() );
+    Handle(Geom_Surface) surf = BRep_Tool::Surface( F );
+    if ( surf.IsNull() ) return;
+
+    eos._offsetSurf = new ShapeAnalysis_Surface( surf );
+  }
+  catch ( Standard_Failure )
+  {
+  }
 }
 
 //================================================================================
 /*!
- * \brief Return _EdgesOnShape* corresponding to the shape
+ * \brief Put nodes of a curved FACE to its offset surface
  */
 //================================================================================
 
-_EdgesOnShape* _SolidData::GetShapeEdges(const TGeomID shapeID )
+void _ViscousBuilder::putOnOffsetSurface( _EdgesOnShape& eos,
+                                          int            infStep,
+                                          int            smooStep,
+                                          bool           moveAll )
 {
-  if ( shapeID < _edgesOnShape.size() &&
-       _edgesOnShape[ shapeID ]._shapeID == shapeID )
-    return & _edgesOnShape[ shapeID ];
+  if ( eos._offsetSurf.IsNull() ||
+       eos.ShapeType() != TopAbs_FACE ||
+       eos._edgeForOffset == 0 ||
+       eos._edgeForOffset->Is( _LayerEdge::BLOCKED ))
+    return;
 
-  for ( size_t i = 0; i < _edgesOnShape.size(); ++i )
+  double preci = BRep_Tool::Tolerance( TopoDS::Face( eos._shape )), vol;
+  for ( size_t i = 0; i < eos._edges.size(); ++i )
+  {
+    _LayerEdge* edge = eos._edges[i];
+    edge->Unset( _LayerEdge::MARKED );
+    if ( edge->Is( _LayerEdge::BLOCKED ) || !edge->_curvature )
+      continue;
+    if ( !moveAll && !edge->Is( _LayerEdge::MOVED ))
+        continue;
+
+    int nbBlockedAround = 0;
+    for ( size_t iN = 0; iN < edge->_neibors.size(); ++iN )
+      nbBlockedAround += edge->_neibors[iN]->Is( _LayerEdge::BLOCKED );
+    if ( nbBlockedAround > 1 )
+      continue;
+
+    gp_Pnt tgtP = SMESH_TNodeXYZ( edge->_nodes.back() );
+    gp_Pnt2d uv = eos._offsetSurf->NextValueOfUV( edge->_curvature->_uv, tgtP, preci );
+    if ( eos._offsetSurf->Gap() > edge->_len ) continue; // NextValueOfUV() bug 
+    edge->_curvature->_uv = uv;
+    if ( eos._offsetSurf->Gap() < 10 * preci ) continue; // same pos
+
+    gp_XYZ  newP = eos._offsetSurf->Value( uv ).XYZ();
+    gp_XYZ prevP = edge->PrevCheckPos();
+    bool      ok = true;
+    if ( !moveAll )
+      for ( size_t iS = 0; iS < edge->_simplices.size() && ok; ++iS )
+      {
+        ok = edge->_simplices[iS].IsForward( &prevP, &newP, vol );
+      }
+    if ( ok )
+    {
+      SMDS_MeshNode* n = const_cast< SMDS_MeshNode* >( edge->_nodes.back() );
+      n->setXYZ( newP.X(), newP.Y(), newP.Z());
+      edge->_pos.back() = newP;
+
+      edge->Set( _LayerEdge::MARKED );
+    }
+  }
+
+#ifdef _DEBUG_
+  // dumpMove() for debug
+  size_t i = 0;
+  for ( ; i < eos._edges.size(); ++i )
+    if ( eos._edges[i]->Is( _LayerEdge::MARKED ))
+      break;
+  if ( i < eos._edges.size() )
+  {
+    dumpFunction(SMESH_Comment("putOnOffsetSurface_F") << eos._shapeID
+                 << "_InfStep" << infStep << "_" << smooStep );
+    for ( ; i < eos._edges.size(); ++i )
+    {
+      if ( eos._edges[i]->Is( _LayerEdge::MARKED ))
+        dumpMove( eos._edges[i]->_nodes.back() );
+    }
+    dumpFunctionEnd();
+  }
+#endif
+}
+
+//================================================================================
+/*!
+ * \brief Return a curve of the EDGE to be used for smoothing and arrange
+ *        _LayerEdge's to be in a consequent order
+ */
+//================================================================================
+
+Handle(Geom_Curve) _Smoother1D::CurveForSmooth( const TopoDS_Edge&  E,
+                                                _EdgesOnShape&      eos,
+                                                SMESH_MesherHelper& helper)
+{
+  SMESHDS_SubMesh* smDS = eos._subMesh->GetSubMeshDS();
+
+  TopLoc_Location loc; double f,l;
+
+  Handle(Geom_Line)   line;
+  Handle(Geom_Circle) circle;
+  bool isLine, isCirc;
+  if ( eos._sWOL.IsNull() ) /////////////////////////////////////////// 3D case
+  {
+    // check if the EDGE is a line
+    Handle(Geom_Curve) curve = BRep_Tool::Curve( E, f, l);
+    if ( curve->IsKind( STANDARD_TYPE( Geom_TrimmedCurve )))
+      curve = Handle(Geom_TrimmedCurve)::DownCast( curve )->BasisCurve();
+
+    line   = Handle(Geom_Line)::DownCast( curve );
+    circle = Handle(Geom_Circle)::DownCast( curve );
+    isLine = (!line.IsNull());
+    isCirc = (!circle.IsNull());
+
+    if ( !isLine && !isCirc ) // Check if the EDGE is close to a line
+    {
+      isLine = SMESH_Algo::IsStraight( E );
+
+      if ( isLine )
+        line = new Geom_Line( gp::OX() ); // only type does matter
+    }
+    if ( !isLine && !isCirc && eos._edges.size() > 2) // Check if the EDGE is close to a circle
+    {
+      // TODO
+    }
+  }
+  else //////////////////////////////////////////////////////////////////////// 2D case
+  {
+    if ( !eos._isRegularSWOL ) // 23190
+      return NULL;
+
+    const TopoDS_Face& F = TopoDS::Face( eos._sWOL );
+
+    // check if the EDGE is a line
+    Handle(Geom2d_Curve) curve = BRep_Tool::CurveOnSurface( E, F, f, l );
+    if ( curve->IsKind( STANDARD_TYPE( Geom2d_TrimmedCurve )))
+      curve = Handle(Geom2d_TrimmedCurve)::DownCast( curve )->BasisCurve();
+
+    Handle(Geom2d_Line)   line2d   = Handle(Geom2d_Line)::DownCast( curve );
+    Handle(Geom2d_Circle) circle2d = Handle(Geom2d_Circle)::DownCast( curve );
+    isLine = (!line2d.IsNull());
+    isCirc = (!circle2d.IsNull());
+
+    if ( !isLine && !isCirc ) // Check if the EDGE is close to a line
+    {
+      Bnd_B2d bndBox;
+      SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
+      while ( nIt->more() )
+        bndBox.Add( helper.GetNodeUV( F, nIt->next() ));
+      gp_XY size = bndBox.CornerMax() - bndBox.CornerMin();
+
+      const double lineTol = 1e-2 * sqrt( bndBox.SquareExtent() );
+      for ( int i = 0; i < 2 && !isLine; ++i )
+        isLine = ( size.Coord( i+1 ) <= lineTol );
+    }
+    if ( !isLine && !isCirc && eos._edges.size() > 2 ) // Check if the EDGE is close to a circle
+    {
+      // TODO
+    }
+    if ( isLine )
+    {
+      line = new Geom_Line( gp::OX() ); // only type does matter
+    }
+    else if ( isCirc )
+    {
+      gp_Pnt2d p = circle2d->Location();
+      gp_Ax2 ax( gp_Pnt( p.X(), p.Y(), 0), gp::DX());
+      circle = new Geom_Circle( ax, 1.); // only center position does matter
+    }
+  }
+
+  if ( isLine )
+    return line;
+  if ( isCirc )
+    return circle;
+
+  return Handle(Geom_Curve)();
+}
+
+//================================================================================
+/*!
+ * \brief smooth _LayerEdge's on a staight EDGE or circular EDGE
+ */
+//================================================================================
+
+bool _Smoother1D::smoothAnalyticEdge( _SolidData&                    data,
+                                      Handle(ShapeAnalysis_Surface)& surface,
+                                      const TopoDS_Face&             F,
+                                      SMESH_MesherHelper&            helper)
+{
+  if ( !isAnalytic() ) return false;
+
+  const size_t iFrom = 0, iTo = _eos._edges.size();
+
+  if ( _anaCurve->IsKind( STANDARD_TYPE( Geom_Line )))
+  {
+    if ( F.IsNull() ) // 3D
+    {
+      SMESH_TNodeXYZ p0   ( _eos._edges[iFrom]->_2neibors->tgtNode(0) );
+      SMESH_TNodeXYZ p1   ( _eos._edges[iTo-1]->_2neibors->tgtNode(1) );
+      SMESH_TNodeXYZ pSrc0( _eos._edges[iFrom]->_2neibors->srcNode(0) );
+      SMESH_TNodeXYZ pSrc1( _eos._edges[iTo-1]->_2neibors->srcNode(1) );
+      gp_XYZ newPos;
+      for ( size_t i = iFrom; i < iTo; ++i )
+      {
+        if ( _eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+
+        _LayerEdge*       edge = _eos._edges[i];
+        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( edge->_nodes.back() );
+        newPos = p0 * ( 1. - _leParams[i] ) + p1 * _leParams[i];
+
+        if ( _eos._edges[i]->Is( _LayerEdge::NORMAL_UPDATED ))
+        {
+          gp_XYZ curPos  = SMESH_TNodeXYZ ( tgtNode );
+          gp_XYZ lineDir = pSrc1 - pSrc0;
+          double   shift = ( lineDir * ( newPos - pSrc0 ) -
+                             lineDir * ( curPos - pSrc0 ));
+          newPos = curPos + lineDir * shift / lineDir.SquareModulus();
+        }
+        edge->_pos.back() = newPos;
+        tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+        dumpMove( tgtNode );
+      }
+    }
+    else
+    {
+      _LayerEdge* e0 = getLEdgeOnV( 0 );
+      _LayerEdge* e1 = getLEdgeOnV( 1 );
+      gp_XY uv0 = e0->LastUV( F, *data.GetShapeEdges( e0 ));
+      gp_XY uv1 = e1->LastUV( F, *data.GetShapeEdges( e1 ));
+      if ( e0->_nodes.back() == e1->_nodes.back() ) // closed edge
+      {
+        int iPeriodic = helper.GetPeriodicIndex();
+        if ( iPeriodic == 1 || iPeriodic == 2 )
+        {
+          uv1.SetCoord( iPeriodic, helper.GetOtherParam( uv1.Coord( iPeriodic )));
+          if ( uv0.Coord( iPeriodic ) > uv1.Coord( iPeriodic ))
+            std::swap( uv0, uv1 );
+        }
+      }
+      const gp_XY rangeUV = uv1 - uv0;
+      for ( size_t i = iFrom; i < iTo; ++i )
+      {
+        if ( _eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+        gp_XY newUV = uv0 + _leParams[i] * rangeUV;
+        _eos._edges[i]->_pos.back().SetCoord( newUV.X(), newUV.Y(), 0 );
+
+        gp_Pnt newPos = surface->Value( newUV.X(), newUV.Y() );
+        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( _eos._edges[i]->_nodes.back() );
+        tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+        dumpMove( tgtNode );
+
+        SMDS_FacePosition* pos = static_cast<SMDS_FacePosition*>( tgtNode->GetPosition() );
+        pos->SetUParameter( newUV.X() );
+        pos->SetVParameter( newUV.Y() );
+      }
+    }
+    return true;
+  }
+
+  if ( _anaCurve->IsKind( STANDARD_TYPE( Geom_Circle )))
+  {
+    Handle(Geom_Circle) circle = Handle(Geom_Circle)::DownCast( _anaCurve );
+    gp_Pnt center3D = circle->Location();
+
+    if ( F.IsNull() ) // 3D
+    {
+      if ( getLEdgeOnV( 0 )->_nodes.back() == getLEdgeOnV( 1 )->_nodes.back() )
+        return true; // closed EDGE - nothing to do
+
+      // circle is a real curve of EDGE
+      gp_Circ circ = circle->Circ();
+
+      // new center is shifted along its axis
+      const gp_Dir& axis = circ.Axis().Direction();
+      _LayerEdge*     e0 = getLEdgeOnV(0);
+      _LayerEdge*     e1 = getLEdgeOnV(1);
+      SMESH_TNodeXYZ  p0 = e0->_nodes.back();
+      SMESH_TNodeXYZ  p1 = e1->_nodes.back();
+      double      shift1 = axis.XYZ() * ( p0 - center3D.XYZ() );
+      double      shift2 = axis.XYZ() * ( p1 - center3D.XYZ() );
+      gp_Pnt   newCenter = center3D.XYZ() + axis.XYZ() * 0.5 * ( shift1 + shift2 );
+
+      double newRadius = 0.5 * ( newCenter.Distance( p0 ) + newCenter.Distance( p1 ));
+
+      gp_Ax2  newAxis( newCenter, axis, gp_Vec( newCenter, p0 ));
+      gp_Circ newCirc( newAxis, newRadius );
+      gp_Vec  vecC1  ( newCenter, p1 );
+
+      double uLast = newAxis.XDirection().AngleWithRef( vecC1, newAxis.Direction() ); // -PI - +PI
+      if ( uLast < 0 )
+        uLast += 2 * M_PI;
+      
+      for ( size_t i = iFrom; i < iTo; ++i )
+      {
+        if ( _eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+        double u = uLast * _leParams[i];
+        gp_Pnt p = ElCLib::Value( u, newCirc );
+        _eos._edges[i]->_pos.back() = p.XYZ();
+
+        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( _eos._edges[i]->_nodes.back() );
+        tgtNode->setXYZ( p.X(), p.Y(), p.Z() );
+        dumpMove( tgtNode );
+      }
+      return true;
+    }
+    else // 2D
+    {
+      const gp_XY center( center3D.X(), center3D.Y() );
+
+      _LayerEdge* e0 = getLEdgeOnV(0);
+      _LayerEdge* eM = _eos._edges[ 0 ];
+      _LayerEdge* e1 = getLEdgeOnV(1);
+      gp_XY      uv0 = e0->LastUV( F, *data.GetShapeEdges( e0 ) );
+      gp_XY      uvM = eM->LastUV( F, *data.GetShapeEdges( eM ) );
+      gp_XY      uv1 = e1->LastUV( F, *data.GetShapeEdges( e1 ) );
+      gp_Vec2d vec0( center, uv0 );
+      gp_Vec2d vecM( center, uvM );
+      gp_Vec2d vec1( center, uv1 );
+      double uLast = vec0.Angle( vec1 ); // -PI - +PI
+      double uMidl = vec0.Angle( vecM );
+      if ( uLast * uMidl <= 0. )
+        uLast += ( uMidl > 0 ? +2. : -2. ) * M_PI;
+      const double radius = 0.5 * ( vec0.Magnitude() + vec1.Magnitude() );
+
+      gp_Ax2d   axis( center, vec0 );
+      gp_Circ2d circ( axis, radius );
+      for ( size_t i = iFrom; i < iTo; ++i )
+      {
+        if ( _eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+        double    newU = uLast * _leParams[i];
+        gp_Pnt2d newUV = ElCLib::Value( newU, circ );
+        _eos._edges[i]->_pos.back().SetCoord( newUV.X(), newUV.Y(), 0 );
+
+        gp_Pnt newPos = surface->Value( newUV.X(), newUV.Y() );
+        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( _eos._edges[i]->_nodes.back() );
+        tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+        dumpMove( tgtNode );
+
+        SMDS_FacePosition* pos = static_cast<SMDS_FacePosition*>( tgtNode->GetPosition() );
+        pos->SetUParameter( newUV.X() );
+        pos->SetVParameter( newUV.Y() );
+      }
+    }
+    return true;
+  }
+
+  return false;
+}
+
+//================================================================================
+/*!
+ * \brief smooth _LayerEdge's on a an EDGE
+ */
+//================================================================================
+
+bool _Smoother1D::smoothComplexEdge( _SolidData&                    data,
+                                     Handle(ShapeAnalysis_Surface)& surface,
+                                     const TopoDS_Face&             F,
+                                     SMESH_MesherHelper&            helper)
+{
+  if ( _offPoints.empty() )
+    return false;
+
+  // move _offPoints to a new position
+
+  _LayerEdge* e[2] = { getLEdgeOnV(0), getLEdgeOnV(1) };
+  if ( e[0]->Is( _LayerEdge::NORMAL_UPDATED )) setNormalOnV( 0, helper );
+  if ( e[1]->Is( _LayerEdge::NORMAL_UPDATED )) setNormalOnV( 1, helper );
+  _leOnV[0]._len = e[0]->_len;
+  _leOnV[1]._len = e[1]->_len;
+  for ( size_t i = 0; i < _offPoints.size(); i++ )
+  {
+    _LayerEdge*  e0 = _offPoints[i]._2edges._edges[0];
+    _LayerEdge*  e1 = _offPoints[i]._2edges._edges[1];
+    const double w0 = _offPoints[i]._2edges._wgt[0];
+    const double w1 = _offPoints[i]._2edges._wgt[1];
+    gp_XYZ  avgNorm = ( e0->_normal    * w0 + e1->_normal    * w1 ).Normalized();
+    double  avgLen  = ( e0->_len       * w0 + e1->_len       * w1 );
+    double  avgFact = ( e0->_lenFactor * w0 + e1->_lenFactor * w1 );
+
+    _offPoints[i]._xyz += avgNorm * ( avgLen - _offPoints[i]._len ) * avgFact;
+    _offPoints[i]._len  = avgLen;
+  }
+
+  double fTol;
+  if ( !surface.IsNull() ) // project _offPoints to the FACE
+  {
+    fTol = 100 * BRep_Tool::Tolerance( F );
+    //const double segLen = _offPoints[0].Distance( _offPoints[1] );
+
+    gp_Pnt2d uv = surface->ValueOfUV( _offPoints[0]._xyz, fTol );
+    //if ( surface->Gap() < 0.5 * segLen )
+      _offPoints[0]._xyz = surface->Value( uv ).XYZ();
+
+    for ( size_t i = 1; i < _offPoints.size(); ++i )
+    {
+      uv = surface->NextValueOfUV( uv, _offPoints[i]._xyz, fTol );
+      //if ( surface->Gap() < 0.5 * segLen )
+        _offPoints[i]._xyz = surface->Value( uv ).XYZ();
+    }
+  }
+
+  // project tgt nodes of extreme _LayerEdge's to the offset segments
+
+  gp_Pnt pExtreme[2], pProj[2];
+  for ( int is2nd = 0; is2nd < 2; ++is2nd )
+  {
+    pExtreme[ is2nd ] = SMESH_TNodeXYZ( e[is2nd]->_nodes.back() );
+    int  i = _iSeg[ is2nd ];
+    int di = is2nd ? -1 : +1;
+    bool projected = false;
+    double uOnSeg, uOnSegDiff, uOnSegBestDiff = Precision::Infinite();
+    do {
+      gp_Vec v0p( _offPoints[i]._xyz, pExtreme[ is2nd ]    );
+      gp_Vec v01( _offPoints[i]._xyz, _offPoints[i+1]._xyz );
+      uOnSeg     = ( v0p * v01 ) / v01.SquareMagnitude();
+      uOnSegDiff = Abs( uOnSeg - 0.5 );
+      projected  = ( uOnSegDiff <= 0.5 );
+      if ( uOnSegDiff < uOnSegBestDiff )
+      {
+        _iSeg[ is2nd ] = i;
+        pProj[ is2nd ] = _offPoints[i]._xyz + ( v01 * uOnSeg ).XYZ();
+        uOnSegBestDiff = uOnSegDiff;
+      }
+      i += di;
+    }
+    while ( !projected &&
+            i >= 0 && i+1 < (int)_offPoints.size() );
+
+    if ( !projected )
+    {
+      if (( is2nd && _iSeg[1] != _offPoints.size()-2 ) || ( !is2nd && _iSeg[0] != 0 ))
+      {
+        _iSeg[0] = 0;
+        _iSeg[1] = _offPoints.size()-2;
+        debugMsg( "smoothComplexEdge() failed to project nodes of extreme _LayerEdge's" );
+        return false;
+      }
+    }
+  }
+  if ( _iSeg[0] > _iSeg[1] )
+  {
+    debugMsg( "smoothComplexEdge() incorrectly projected nodes of extreme _LayerEdge's" );
+    return false;
+  }
+
+  // compute normalized length of the offset segments located between the projections
+
+  size_t iSeg = 0, nbSeg = _iSeg[1] - _iSeg[0] + 1;
+  vector< double > len( nbSeg + 1 );
+  len[ iSeg++ ] = 0;
+  len[ iSeg++ ] = pProj[ 0 ].Distance( _offPoints[ _iSeg[0]+1 ]._xyz );
+  for ( size_t i = _iSeg[0]+1; i <= _iSeg[1]; ++i, ++iSeg )
+  {
+    len[ iSeg ] = len[ iSeg-1 ] + _offPoints[i].Distance( _offPoints[i+1] );
+  }
+  len[ nbSeg ] -= pProj[ 1 ].Distance( _offPoints[ _iSeg[1]+1 ]._xyz );
+
+  double d0 = pProj[0].Distance( pExtreme[0]);
+  double d1 = pProj[1].Distance( pExtreme[1]);
+  double fullLen = len.back() - d0 - d1;
+  for ( iSeg = 0; iSeg < len.size(); ++iSeg )
+    len[iSeg] = ( len[iSeg] - d0 ) / fullLen;
+
+  // temporary replace extreme _offPoints by pExtreme
+  gp_XYZ op[2] = { _offPoints[ _iSeg[0]   ]._xyz,
+                   _offPoints[ _iSeg[1]+1 ]._xyz };
+  _offPoints[ _iSeg[0]   ]._xyz = pExtreme[0].XYZ();
+  _offPoints[ _iSeg[1]+ 1]._xyz = pExtreme[1].XYZ();
+
+  // distribute tgt nodes of _LayerEdge's between the projections
+
+  iSeg = 0;
+  for ( size_t i = 0; i < _eos._edges.size(); ++i )
+  {
+    if ( _eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+    while ( iSeg+2 < len.size() && _leParams[i] > len[ iSeg+1 ] )
+      iSeg++;
+    double r = ( _leParams[i] - len[ iSeg ]) / ( len[ iSeg+1 ] - len[ iSeg ]);
+    gp_XYZ p = ( _offPoints[ iSeg + _iSeg[0]     ]._xyz * ( 1 - r ) +
+                 _offPoints[ iSeg + _iSeg[0] + 1 ]._xyz * r );
+
+    if ( surface.IsNull() )
+    {
+      _eos._edges[i]->_pos.back() = p;
+    }
+    else // project a new node position to a FACE
+    {
+      gp_Pnt2d uv ( _eos._edges[i]->_pos.back().X(), _eos._edges[i]->_pos.back().Y() );
+      gp_Pnt2d uv2( surface->NextValueOfUV( uv, p, fTol ));
+
+      p = surface->Value( uv2 ).XYZ();
+      _eos._edges[i]->_pos.back().SetCoord( uv2.X(), uv2.Y(), 0 );
+    }
+    SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( _eos._edges[i]->_nodes.back() );
+    tgtNode->setXYZ( p.X(), p.Y(), p.Z() );
+    dumpMove( tgtNode );
+  }
+
+  _offPoints[ _iSeg[0]   ]._xyz = op[0];
+  _offPoints[ _iSeg[1]+1 ]._xyz = op[1];
+
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Prepare for smoothing
+ */
+//================================================================================
+
+void _Smoother1D::prepare(_SolidData& data)
+{
+  // sort _LayerEdge's by position on the EDGE
+  const TopoDS_Edge& E = TopoDS::Edge( _eos._shape );
+  data.SortOnEdge( E, _eos._edges );
+
+  // compute normalized param of _eos._edges on EDGE
+  _leParams.resize( _eos._edges.size() + 1 );
+  {
+    double curLen, prevLen = _leParams[0] = 1.0;
+    gp_Pnt pPrev = SMESH_TNodeXYZ( getLEdgeOnV( 0 )->_nodes[0] );
+    _leParams[0] = 0;
+    for ( size_t i = 0; i < _eos._edges.size(); ++i )
+    {
+      gp_Pnt p = SMESH_TNodeXYZ( _eos._edges[i]->_nodes[0] );
+      //curLen = prevLen * _eos._edges[i]->_2neibors->_wgt[1] / _eos._edges[i]->_2neibors->_wgt[0];
+      curLen = p.Distance( pPrev );
+      _leParams[i+1] = _leParams[i] + curLen;
+      prevLen = curLen;
+      pPrev = p;
+    }
+    double fullLen = _leParams.back() + pPrev.Distance( SMESH_TNodeXYZ( getLEdgeOnV(1)->_nodes[0]));
+    for ( size_t i = 0; i < _leParams.size(); ++i )
+      _leParams[i] = _leParams[i+1] / fullLen;
+  }
+
+  if ( isAnalytic() )
+    return;
+
+  // divide E to have offset segments with low deflection
+  BRepAdaptor_Curve c3dAdaptor( E );
+  const double curDeflect = 0.1; //0.3; // 0.01; // Curvature deflection
+  const double angDeflect = 0.1; //0.2; // 0.09; // Angular deflection
+  GCPnts_TangentialDeflection discret(c3dAdaptor, angDeflect, curDeflect);
+  if ( discret.NbPoints() <= 2 )
+  {
+    _anaCurve = new Geom_Line( gp::OX() ); // only type does matter
+    return;
+  }
+
+  const double edgeLen = SMESH_Algo::EdgeLength( E );
+  const double u0      = c3dAdaptor.FirstParameter();
+  _offPoints.resize( discret.NbPoints() );
+  for ( size_t i = 0; i < _offPoints.size(); i++ )
+  {
+    _offPoints[i]._xyz = discret.Value( i+1 ).XYZ();
+    // use OffPnt::_len to  TEMPORARY  store normalized param of an offset point
+    double u = discret.Parameter( i+1 );
+    _offPoints[i]._len = GCPnts_AbscissaPoint::Length( c3dAdaptor, u0, u ) / edgeLen;
+  }
+
+  _LayerEdge* leOnV[2] = { getLEdgeOnV(0), getLEdgeOnV(1) };
+
+  // set _2edges
+  _offPoints    [0]._2edges.set( &_leOnV[0], &_leOnV[0], 0.5, 0.5 );
+  _offPoints.back()._2edges.set( &_leOnV[1], &_leOnV[1], 0.5, 0.5 );
+  _2NearEdges tmp2edges;
+  tmp2edges._edges[1] = _eos._edges[0];
+  _leOnV[0]._2neibors = & tmp2edges;
+  _leOnV[0]._nodes    = leOnV[0]->_nodes;
+  _leOnV[1]._nodes    = leOnV[1]->_nodes;
+  _LayerEdge* eNext, *ePrev = & _leOnV[0];
+  for ( size_t iLE = 0, i = 1; i < _offPoints.size()-1; i++ )
+  {
+    // find _LayerEdge's located before and after an offset point
+    // (_eos._edges[ iLE ] is next after ePrev)
+    while ( iLE < _eos._edges.size() && _offPoints[i]._len > _leParams[ iLE ] )
+      ePrev = _eos._edges[ iLE++ ];
+    eNext = ePrev->_2neibors->_edges[1];
+
+    gp_Pnt p0 = SMESH_TNodeXYZ( ePrev->_nodes[0] );
+    gp_Pnt p1 = SMESH_TNodeXYZ( eNext->_nodes[0] );
+    double  r = p0.Distance( _offPoints[i]._xyz ) / p0.Distance( p1 );
+    _offPoints[i]._2edges.set( ePrev, eNext, 1-r, r );
+  }
+
+  int iLBO = _offPoints.size() - 2; // last but one
+  _offPoints[iLBO]._2edges._edges[1] = & _leOnV[1];
+
+  // {
+  //   TopoDS_Face face[2]; // FACEs sharing the EDGE
+  //   PShapeIteratorPtr fIt = helper.GetAncestors( _eos._shape, *helper.GetMesh(), TopAbs_FACE );
+  //   while ( const TopoDS_Shape* F = fIt->next() )
+  //   {
+  //     TGeomID fID = helper.GetMeshDS()->ShapeToIndex( *F );
+  //     if ( ! data._ignoreFaceIds.count( fID ))
+  //       face[ !face[0].IsNull() ] = *F;
+  //   }
+  //   if ( face[0].IsNull() ) return;
+  //   if ( face[1].IsNull() ) face[1] = face[0];
+  // }
+
+
+  // set _normal of _leOnV[0] and _leOnV[1] to be normal to the EDGE
+
+  setNormalOnV( 0, data.GetHelper() );
+  setNormalOnV( 1, data.GetHelper() );
+  _leOnV[ 0 ]._len = 0;
+  _leOnV[ 1 ]._len = 0;
+  _leOnV[ 0 ]._lenFactor = _offPoints[1   ]._2edges._edges[1]->_lenFactor;
+  _leOnV[ 1 ]._lenFactor = _offPoints[iLBO]._2edges._edges[0]->_lenFactor;
+
+  _iSeg[0] = 0;
+  _iSeg[1] = _offPoints.size()-2;
+
+  // initialize OffPnt::_len
+  for ( size_t i = 0; i < _offPoints.size(); ++i )
+    _offPoints[i]._len = 0;
+
+  if ( _eos._edges[0]->NbSteps() > 1 ) // already inflated several times, init _xyz
+  {
+    _leOnV[0]._len = leOnV[0]->_len;
+    _leOnV[1]._len = leOnV[1]->_len;
+    for ( size_t i = 0; i < _offPoints.size(); i++ )
+    {
+      _LayerEdge*  e0 = _offPoints[i]._2edges._edges[0];
+      _LayerEdge*  e1 = _offPoints[i]._2edges._edges[1];
+      const double w0 = _offPoints[i]._2edges._wgt[0];
+      const double w1 = _offPoints[i]._2edges._wgt[1];
+      double  avgLen  = ( e0->_len * w0 + e1->_len * w1 );
+      gp_XYZ  avgXYZ  = ( SMESH_TNodeXYZ( e0->_nodes.back() ) * w0 +
+                          SMESH_TNodeXYZ( e1->_nodes.back() ) * w1 );
+      _offPoints[i]._xyz = avgXYZ;
+      _offPoints[i]._len = avgLen;
+    }
+  }
+}
+
+//================================================================================
+/*!
+ * \brief set _normal of _leOnV[is2nd] to be normal to the EDGE
+ */
+//================================================================================
+
+void _Smoother1D::setNormalOnV( const bool          is2nd,
+                                SMESH_MesherHelper& helper)
+{
+  _LayerEdge*    leOnV = getLEdgeOnV( is2nd );
+  const TopoDS_Edge& E = TopoDS::Edge( _eos._shape );
+  TopoDS_Shape       V = helper.GetSubShapeByNode( leOnV->_nodes[0], helper.GetMeshDS() );
+  gp_XYZ          eDir = getEdgeDir( E, TopoDS::Vertex( V ));
+  gp_XYZ         cross = leOnV->_normal ^ eDir;
+  gp_XYZ          norm = eDir ^ cross;
+  double          size = norm.Modulus();
+
+  _leOnV[ is2nd ]._normal = norm / size;
+}
+
+//================================================================================
+/*!
+ * \brief Sort _LayerEdge's by a parameter on a given EDGE
+ */
+//================================================================================
+
+void _SolidData::SortOnEdge( const TopoDS_Edge&     E,
+                             vector< _LayerEdge* >& edges)
+{
+  map< double, _LayerEdge* > u2edge;
+  for ( size_t i = 0; i < edges.size(); ++i )
+    u2edge.insert( u2edge.end(),
+                   make_pair( _helper->GetNodeU( E, edges[i]->_nodes[0] ), edges[i] ));
+
+  ASSERT( u2edge.size() == edges.size() );
+  map< double, _LayerEdge* >::iterator u2e = u2edge.begin();
+  for ( size_t i = 0; i < edges.size(); ++i, ++u2e )
+    edges[i] = u2e->second;
+
+  Sort2NeiborsOnEdge( edges );
+}
+
+//================================================================================
+/*!
+ * \brief Set _2neibors according to the order of _LayerEdge on EDGE
+ */
+//================================================================================
+
+void _SolidData::Sort2NeiborsOnEdge( vector< _LayerEdge* >& edges )
+{
+  if ( edges.size() < 2 || !edges[0]->_2neibors ) return;
+
+  for ( size_t i = 0; i < edges.size()-1; ++i )
+    if ( edges[i]->_2neibors->tgtNode(1) != edges[i+1]->_nodes.back() )
+      edges[i]->_2neibors->reverse();
+
+  const size_t iLast = edges.size() - 1;
+  if ( edges.size() > 1 &&
+       edges[iLast]->_2neibors->tgtNode(0) != edges[iLast-1]->_nodes.back() )
+    edges[iLast]->_2neibors->reverse();
+}
+
+//================================================================================
+/*!
+ * \brief Return _EdgesOnShape* corresponding to the shape
+ */
+//================================================================================
+
+_EdgesOnShape* _SolidData::GetShapeEdges(const TGeomID shapeID )
+{
+  if ( shapeID < (int)_edgesOnShape.size() &&
+       _edgesOnShape[ shapeID ]._shapeID == shapeID )
+    return _edgesOnShape[ shapeID ]._subMesh ? & _edgesOnShape[ shapeID ] : 0;
+
+  for ( size_t i = 0; i < _edgesOnShape.size(); ++i )
     if ( _edgesOnShape[i]._shapeID == shapeID )
-      return & _edgesOnShape[i];
+      return _edgesOnShape[i]._subMesh ? & _edgesOnShape[i] : 0;
 
   return 0;
 }
@@ -4199,28 +5687,94 @@ _EdgesOnShape* _SolidData::GetShapeEdges(const TopoDS_Shape& shape )
  */
 //================================================================================
 
-void _SolidData::PrepareEdgesToSmoothOnFace( _EdgesOnShape* eof, bool substituteSrcNodes )
+void _SolidData::PrepareEdgesToSmoothOnFace( _EdgesOnShape* eos, bool substituteSrcNodes )
 {
-  set< TGeomID > vertices;
   SMESH_MesherHelper helper( *_proxyMesh->GetMesh() );
-  if ( isConcave( TopoDS::Face( eof->_shape ), helper, &vertices ))
-    _concaveFaces.insert( eof->_shapeID );
 
-  for ( size_t i = 0; i < eof->_edges.size(); ++i )
-    eof->_edges[i]->_smooFunction = 0;
+  set< TGeomID > vertices;
+  TopoDS_Face F;
+  if ( eos->ShapeType() == TopAbs_FACE )
+  {
+    // check FACE concavity and get concave VERTEXes
+    F = TopoDS::Face( eos->_shape );
+    if ( isConcave( F, helper, &vertices ))
+      _concaveFaces.insert( eos->_shapeID );
+
+    // set eos._eosConcaVer
+    eos->_eosConcaVer.clear();
+    eos->_eosConcaVer.reserve( vertices.size() );
+    for ( set< TGeomID >::iterator v = vertices.begin(); v != vertices.end(); ++v )
+    {
+      _EdgesOnShape* eov = GetShapeEdges( *v );
+      if ( eov && eov->_edges.size() == 1 )
+      {
+        eos->_eosConcaVer.push_back( eov );
+        for ( size_t i = 0; i < eov->_edges[0]->_neibors.size(); ++i )
+          eov->_edges[0]->_neibors[i]->Set( _LayerEdge::DIFFICULT );
+      }
+    }
+
+    // SetSmooLen() to _LayerEdge's on FACE
+    for ( size_t i = 0; i < eos->_edges.size(); ++i )
+    {
+      eos->_edges[i]->SetSmooLen( Precision::Infinite() );
+    }
+    SMESH_subMeshIteratorPtr smIt = eos->_subMesh->getDependsOnIterator(/*includeSelf=*/false);
+    while ( smIt->more() ) // loop on sub-shapes of the FACE
+    {
+      _EdgesOnShape* eoe = GetShapeEdges( smIt->next()->GetId() );
+      if ( !eoe ) continue;
+
+      vector<_LayerEdge*>& eE = eoe->_edges;
+      for ( size_t iE = 0; iE < eE.size(); ++iE ) // loop on _LayerEdge's on EDGE or VERTEX
+      {
+        if ( eE[iE]->_cosin <= theMinSmoothCosin )
+          continue;
+
+        SMDS_ElemIteratorPtr segIt = eE[iE]->_nodes[0]->GetInverseElementIterator(SMDSAbs_Edge);
+        while ( segIt->more() )
+        {
+          const SMDS_MeshElement* seg = segIt->next();
+          if ( !eos->_subMesh->DependsOn( seg->getshapeId() ))
+            continue;
+          if ( seg->GetNode(0) != eE[iE]->_nodes[0] )
+            continue; // not to check a seg twice
+          for ( size_t iN = 0; iN < eE[iE]->_neibors.size(); ++iN )
+          {
+            _LayerEdge* eN = eE[iE]->_neibors[iN];
+            if ( eN->_nodes[0]->getshapeId() != eos->_shapeID )
+              continue;
+            double dist    = SMESH_MeshAlgos::GetDistance( seg, SMESH_TNodeXYZ( eN->_nodes[0] ));
+            double smooLen = getSmoothingThickness( eE[iE]->_cosin, dist );
+            eN->SetSmooLen( Min( smooLen, eN->GetSmooLen() ));
+            eN->Set( _LayerEdge::NEAR_BOUNDARY );
+          }
+        }
+      }
+    }
+  } // if ( eos->ShapeType() == TopAbs_FACE )
 
-  for ( size_t i = 0; i < eof->_edges.size(); ++i )
+  for ( size_t i = 0; i < eos->_edges.size(); ++i )
+  {
+    eos->_edges[i]->_smooFunction = 0;
+    eos->_edges[i]->Set( _LayerEdge::TO_SMOOTH );
+  }
+  bool isCurved = false;
+  for ( size_t i = 0; i < eos->_edges.size(); ++i )
   {
-    _LayerEdge* edge = eof->_edges[i];
-    _Simplex::GetSimplices
-      ( edge->_nodes[0], edge->_simplices, _ignoreFaceIds, this, /*sort=*/true );
+    _LayerEdge* edge = eos->_edges[i];
 
+    // get simplices sorted
+    _Simplex::SortSimplices( edge->_simplices );
+
+    // smoothing function
     edge->ChooseSmooFunction( vertices, _n2eMap );
 
+    // set _curvature
     double avgNormProj = 0, avgLen = 0;
-    for ( size_t i = 0; i < edge->_simplices.size(); ++i )
+    for ( size_t iS = 0; iS < edge->_simplices.size(); ++iS )
     {
-      _Simplex& s = edge->_simplices[i];
+      _Simplex& s = edge->_simplices[iS];
 
       gp_XYZ  vec = edge->_pos.back() - SMESH_TNodeXYZ( s._nPrev );
       avgNormProj += edge->_normal * vec;
@@ -4233,7 +5787,39 @@ void _SolidData::PrepareEdgesToSmoothOnFace( _EdgesOnShape* eof, bool substitute
     }
     avgNormProj /= edge->_simplices.size();
     avgLen      /= edge->_simplices.size();
-    edge->_curvature = _Curvature::New( avgNormProj, avgLen );
+    if (( edge->_curvature = _Curvature::New( avgNormProj, avgLen )))
+    {
+      isCurved = true;
+      SMDS_FacePosition* fPos = dynamic_cast<SMDS_FacePosition*>( edge->_nodes[0]->GetPosition() );
+      if ( !fPos )
+        for ( size_t iS = 0; iS < edge->_simplices.size()  &&  !fPos; ++iS )
+          fPos = dynamic_cast<SMDS_FacePosition*>( edge->_simplices[iS]._nPrev->GetPosition() );
+      if ( fPos )
+        edge->_curvature->_uv.SetCoord( fPos->GetUParameter(), fPos->GetVParameter() );
+    }
+  }
+
+  // prepare for putOnOffsetSurface()
+  if (( eos->ShapeType() == TopAbs_FACE ) &&
+      ( isCurved || !eos->_eosConcaVer.empty() ))
+  {
+    eos->_offsetSurf = helper.GetSurface( TopoDS::Face( eos->_shape ));
+    eos->_edgeForOffset = 0;
+
+    double maxCosin = -1;
+    for ( TopExp_Explorer eExp( eos->_shape, TopAbs_EDGE ); eExp.More(); eExp.Next() )
+    {
+      _EdgesOnShape* eoe = GetShapeEdges( eExp.Current() );
+      if ( !eoe || eoe->_edges.empty() ) continue;
+
+      vector<_LayerEdge*>& eE = eoe->_edges;
+      _LayerEdge* e = eE[ eE.size() / 2 ];
+      if ( e->_cosin > maxCosin )
+      {
+        eos->_edgeForOffset = e;
+        maxCosin = e->_cosin;
+      }
+    }
   }
 }
 
@@ -4243,10 +5829,11 @@ void _SolidData::PrepareEdgesToSmoothOnFace( _EdgesOnShape* eof, bool substitute
  */
 //================================================================================
 
-void _SolidData::AddShapesToSmooth( const set< _EdgesOnShape* >& eosSet )
+void _SolidData::AddShapesToSmooth( const set< _EdgesOnShape* >& eosToSmooth,
+                                    const set< _EdgesOnShape* >* edgesNoAnaSmooth )
 {
-  set< _EdgesOnShape * >::const_iterator eos = eosSet.begin();
-  for ( ; eos != eosSet.end(); ++eos )
+  set< _EdgesOnShape * >::const_iterator eos = eosToSmooth.begin();
+  for ( ; eos != eosToSmooth.end(); ++eos )
   {
     if ( !*eos || (*eos)->_toSmooth ) continue;
 
@@ -4254,151 +5841,218 @@ void _SolidData::AddShapesToSmooth( const set< _EdgesOnShape* >& eosSet )
 
     if ( (*eos)->ShapeType() == TopAbs_FACE )
     {
-      PrepareEdgesToSmoothOnFace( *eos, /*substituteSrcNodes=*/true );
+      PrepareEdgesToSmoothOnFace( *eos, /*substituteSrcNodes=*/false );
+      (*eos)->_toSmooth = true;
     }
   }
+
+  // avoid _Smoother1D::smoothAnalyticEdge() of edgesNoAnaSmooth
+  if ( edgesNoAnaSmooth )
+    for ( eos = edgesNoAnaSmooth->begin(); eos != edgesNoAnaSmooth->end(); ++eos )
+    {
+      if ( (*eos)->_edgeSmoother )
+        (*eos)->_edgeSmoother->_anaCurve.Nullify();
+    }
 }
 
 //================================================================================
 /*!
- * \brief smooth _LayerEdge's on a staight EDGE or circular EDGE
+ * \brief Fill data._collisionEdges
  */
 //================================================================================
 
-bool _ViscousBuilder::smoothAnalyticEdge( _SolidData&           data,
-                                          _EdgesOnShape&        eos,
-                                          Handle(Geom_Surface)& surface,
-                                          const TopoDS_Face&    F,
-                                          SMESH_MesherHelper&   helper)
+void _ViscousBuilder::findCollisionEdges( _SolidData& data, SMESH_MesherHelper& helper )
 {
-  const TopoDS_Edge& E = TopoDS::Edge( eos._shape );
+  data._collisionEdges.clear();
 
-  Handle(Geom_Curve) curve = data.CurveForSmooth( E, eos, helper );
-  if ( curve.IsNull() ) return false;
-
-  const size_t iFrom = 0, iTo = eos._edges.size();
-
-  // compute a relative length of segments
-  vector< double > len( iTo-iFrom+1 );
+  // set the full thickness of the layers to LEs
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
-    double curLen, prevLen = len[0] = 1.0;
-    for ( int i = iFrom; i < iTo; ++i )
+    _EdgesOnShape& eos = data._edgesOnShape[iS];
+    if ( eos._edges.empty() ) continue;
+    if ( eos.ShapeType() != TopAbs_EDGE && eos.ShapeType() != TopAbs_VERTEX ) continue;
+
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
     {
-      curLen = prevLen * eos._edges[i]->_2neibors->_wgt[0] / eos._edges[i]->_2neibors->_wgt[1];
-      len[i-iFrom+1] = len[i-iFrom] + curLen;
-      prevLen = curLen;
+      if ( eos._edges[i]->Is( _LayerEdge::BLOCKED )) continue;
+      double maxLen = eos._edges[i]->_maxLen;
+      eos._edges[i]->_maxLen = Precision::Infinite(); // avoid blocking
+      eos._edges[i]->SetNewLength( 1.5 * maxLen, eos, helper );
+      eos._edges[i]->_maxLen = maxLen;
     }
   }
 
-  if ( curve->IsKind( STANDARD_TYPE( Geom_Line )))
+  // make temporary quadrangles got by extrusion of
+  // mesh edges along _LayerEdge._normal's
+
+  vector< const SMDS_MeshElement* > tmpFaces;
+
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
   {
-    if ( F.IsNull() ) // 3D
+    _EdgesOnShape& eos = data._edgesOnShape[ iS ];
+    if ( eos.ShapeType() != TopAbs_EDGE )
+      continue;
+    if ( eos._edges.empty() )
     {
-      SMESH_TNodeXYZ p0( eos._edges[iFrom]->_2neibors->tgtNode(0));
-      SMESH_TNodeXYZ p1( eos._edges[iTo-1]->_2neibors->tgtNode(1));
-      for ( int i = iFrom; i < iTo; ++i )
+      _LayerEdge* edge[2] = { 0, 0 }; // LE of 2 VERTEX'es
+      SMESH_subMeshIteratorPtr smIt = eos._subMesh->getDependsOnIterator(/*includeSelf=*/false);
+      while ( smIt->more() )
+        if ( _EdgesOnShape* eov = data.GetShapeEdges( smIt->next()->GetId() ))
+          if ( eov->_edges.size() == 1 )
+            edge[ bool( edge[0]) ] = eov->_edges[0];
+
+      if ( edge[1] )
       {
-        double r = len[i-iFrom] / len.back();
-        gp_XYZ newPos = p0 * ( 1. - r ) + p1 * r;
-        eos._edges[i]->_pos.back() = newPos;
-        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( eos._edges[i]->_nodes.back() );
-        tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
-        dumpMove( tgtNode );
+        _TmpMeshFaceOnEdge* f = new _TmpMeshFaceOnEdge( edge[0], edge[1], --_tmpFaceID );
+        tmpFaces.push_back( f );
       }
     }
-    else
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
     {
-      // gp_XY uv0 = helper.GetNodeUV( F, eos._edges[iFrom]->_2neibors->tgtNode(0));
-      // gp_XY uv1 = helper.GetNodeUV( F, eos._edges[iTo-1]->_2neibors->tgtNode(1));
-      _LayerEdge* e0 = eos._edges[iFrom]->_2neibors->_edges[0];
-      _LayerEdge* e1 = eos._edges[iTo-1]->_2neibors->_edges[1];
-      gp_XY uv0 = e0->LastUV( F, *data.GetShapeEdges( e0 ));
-      gp_XY uv1 = e1->LastUV( F, *data.GetShapeEdges( e1 ));
-      if ( eos._edges[iFrom]->_2neibors->tgtNode(0) ==
-           eos._edges[iTo-1]->_2neibors->tgtNode(1) ) // closed edge
-      {
-        int iPeriodic = helper.GetPeriodicIndex();
-        if ( iPeriodic == 1 || iPeriodic == 2 )
-        {
-          uv1.SetCoord( iPeriodic, helper.GetOtherParam( uv1.Coord( iPeriodic )));
-          if ( uv0.Coord( iPeriodic ) > uv1.Coord( iPeriodic ))
-            std::swap( uv0, uv1 );
-        }
-      }
-      const gp_XY rangeUV = uv1 - uv0;
-      for ( int i = iFrom; i < iTo; ++i )
+      _LayerEdge* edge = eos._edges[i];
+      for ( int j = 0; j < 2; ++j ) // loop on _2NearEdges
       {
-        double r = len[i-iFrom] / len.back();
-        gp_XY newUV = uv0 + r * rangeUV;
-        eos._edges[i]->_pos.back().SetCoord( newUV.X(), newUV.Y(), 0 );
+        const SMDS_MeshNode* src2 = edge->_2neibors->srcNode(j);
+        if ( src2->GetPosition()->GetDim() > 0 &&
+             src2->GetID() < edge->_nodes[0]->GetID() )
+          continue; // avoid using same segment twice
 
-        gp_Pnt newPos = surface->Value( newUV.X(), newUV.Y() );
-        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( eos._edges[i]->_nodes.back() );
-        tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
-        dumpMove( tgtNode );
+        // a _LayerEdge containg tgt2
+        _LayerEdge* neiborEdge = edge->_2neibors->_edges[j];
 
-        SMDS_FacePosition* pos = static_cast<SMDS_FacePosition*>( tgtNode->GetPosition() );
-        pos->SetUParameter( newUV.X() );
-        pos->SetVParameter( newUV.Y() );
+        _TmpMeshFaceOnEdge* f = new _TmpMeshFaceOnEdge( edge, neiborEdge, --_tmpFaceID );
+        tmpFaces.push_back( f );
       }
     }
-    return true;
   }
 
-  if ( curve->IsKind( STANDARD_TYPE( Geom_Circle )))
-  {
-    Handle(Geom_Circle) circle = Handle(Geom_Circle)::DownCast( curve );
-    gp_Pnt center3D = circle->Location();
+  // Find _LayerEdge's intersecting tmpFaces.
 
-    if ( F.IsNull() ) // 3D
-    {
-      if ( eos._edges[iFrom]->_2neibors->tgtNode(0) ==
-           eos._edges[iTo-1]->_2neibors->tgtNode(1) )
-        return true; // closed EDGE - nothing to do
+  SMDS_ElemIteratorPtr fIt( new SMDS_ElementVectorIterator( tmpFaces.begin(),
+                                                            tmpFaces.end()));
+  SMESHUtils::Deleter<SMESH_ElementSearcher> searcher
+    ( SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), fIt ));
+
+  double dist1, dist2, segLen, eps;
+  _CollisionEdges collEdges;
+  vector< const SMDS_MeshElement* > suspectFaces;
+  const double angle30 = Cos( 30. * M_PI / 180. );
 
-      return false; // TODO ???
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
+  {
+    _EdgesOnShape& eos = data._edgesOnShape[ iS ];
+    if ( eos.ShapeType() == TopAbs_FACE || !eos._sWOL.IsNull() )
+      continue;
+    // find sub-shapes whose VL can influence VL on eos
+    set< TGeomID > neighborShapes;
+    PShapeIteratorPtr fIt = helper.GetAncestors( eos._shape, *_mesh, TopAbs_FACE );
+    while ( const TopoDS_Shape* face = fIt->next() )
+    {
+      TGeomID faceID = getMeshDS()->ShapeToIndex( *face );
+      if ( _EdgesOnShape* eof = data.GetShapeEdges( faceID ))
+      {
+        SMESH_subMeshIteratorPtr subIt = eof->_subMesh->getDependsOnIterator(/*includeSelf=*/false);
+        while ( subIt->more() )
+          neighborShapes.insert( subIt->next()->GetId() );
+      }
     }
-    else // 2D
+    if ( eos.ShapeType() == TopAbs_VERTEX )
     {
-      const gp_XY center( center3D.X(), center3D.Y() );
-
-      _LayerEdge* e0 = eos._edges[iFrom]->_2neibors->_edges[0];
-      _LayerEdge* eM = eos._edges[iFrom];
-      _LayerEdge* e1 = eos._edges[iTo-1]->_2neibors->_edges[1];
-      gp_XY uv0 = e0->LastUV( F, *data.GetShapeEdges( e0 ) );
-      gp_XY uvM = eM->LastUV( F, *data.GetShapeEdges( eM ) );
-      gp_XY uv1 = e1->LastUV( F, *data.GetShapeEdges( e1 ) );
-      gp_Vec2d vec0( center, uv0 );
-      gp_Vec2d vecM( center, uvM );
-      gp_Vec2d vec1( center, uv1 );
-      double uLast = vec0.Angle( vec1 ); // -PI - +PI
-      double uMidl = vec0.Angle( vecM );
-      if ( uLast * uMidl <= 0. )
-        uLast += ( uMidl > 0 ? +2. : -2. ) * M_PI;
-      const double radius = 0.5 * ( vec0.Magnitude() + vec1.Magnitude() );
+      PShapeIteratorPtr eIt = helper.GetAncestors( eos._shape, *_mesh, TopAbs_EDGE );
+      while ( const TopoDS_Shape* edge = eIt->next() )
+        neighborShapes.erase( getMeshDS()->ShapeToIndex( *edge ));
+    }
+    // find intersecting _LayerEdge's
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
+    {
+      _LayerEdge*   edge = eos._edges[i];
+      gp_Ax1 lastSegment = edge->LastSegment( segLen, eos );
+      eps     = 0.5 * edge->_len;
+      segLen *= 1.2;
 
-      gp_Ax2d   axis( center, vec0 );
-      gp_Circ2d circ( axis, radius );
-      for ( int i = iFrom; i < iTo; ++i )
+      gp_Vec eSegDir0, eSegDir1;
+      if ( edge->IsOnEdge() )
       {
-        double    newU = uLast * len[i-iFrom] / len.back();
-        gp_Pnt2d newUV = ElCLib::Value( newU, circ );
-        eos._edges[i]->_pos.back().SetCoord( newUV.X(), newUV.Y(), 0 );
+        SMESH_TNodeXYZ eP( edge->_nodes[0] );
+        eSegDir0 = SMESH_TNodeXYZ( edge->_2neibors->srcNode(0) ) - eP;
+        eSegDir1 = SMESH_TNodeXYZ( edge->_2neibors->srcNode(1) ) - eP;
+      }
+      suspectFaces.clear();
+      searcher->GetElementsInSphere( SMESH_TNodeXYZ( edge->_nodes.back()), edge->_len,
+                                     SMDSAbs_Face, suspectFaces );
+      collEdges._intEdges.clear();
+      for ( size_t j = 0 ; j < suspectFaces.size(); ++j )
+      {
+        const _TmpMeshFaceOnEdge* f = (const _TmpMeshFaceOnEdge*) suspectFaces[j];
+        if ( f->_le1 == edge || f->_le2 == edge ) continue;
+        if ( !neighborShapes.count( f->_le1->_nodes[0]->getshapeId() )) continue;
+        if ( !neighborShapes.count( f->_le2->_nodes[0]->getshapeId() )) continue;
+        if ( edge->IsOnEdge() ) {
+          if ( edge->_2neibors->include( f->_le1 ) ||
+               edge->_2neibors->include( f->_le2 )) continue;
+        }
+        else {
+          if (( f->_le1->IsOnEdge() && f->_le1->_2neibors->include( edge )) ||
+              ( f->_le2->IsOnEdge() && f->_le2->_2neibors->include( edge )))  continue;
+        }
+        dist1 = dist2 = Precision::Infinite();
+        if ( !edge->SegTriaInter( lastSegment, f->_nn[0], f->_nn[1], f->_nn[2], dist1, eps ))
+          dist1 = Precision::Infinite();
+        if ( !edge->SegTriaInter( lastSegment, f->_nn[3], f->_nn[2], f->_nn[0], dist2, eps ))
+          dist2 = Precision::Infinite();
+        if (( dist1 > segLen ) && ( dist2 > segLen ))
+          continue;
 
-        gp_Pnt newPos = surface->Value( newUV.X(), newUV.Y() );
-        SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( eos._edges[i]->_nodes.back() );
-        tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
-        dumpMove( tgtNode );
+        if ( edge->IsOnEdge() )
+        {
+          // skip perpendicular EDGEs
+          gp_Vec fSegDir  = SMESH_TNodeXYZ( f->_nn[0] ) - SMESH_TNodeXYZ( f->_nn[3] );
+          bool isParallel = ( isLessAngle( eSegDir0, fSegDir, angle30 ) ||
+                              isLessAngle( eSegDir1, fSegDir, angle30 ) ||
+                              isLessAngle( eSegDir0, fSegDir.Reversed(), angle30 ) ||
+                              isLessAngle( eSegDir1, fSegDir.Reversed(), angle30 ));
+          if ( !isParallel )
+            continue;
+        }
 
-        SMDS_FacePosition* pos = static_cast<SMDS_FacePosition*>( tgtNode->GetPosition() );
-        pos->SetUParameter( newUV.X() );
-        pos->SetVParameter( newUV.Y() );
+        // either limit inflation of edges or remember them for updating _normal
+        // double dot = edge->_normal * f->GetDir();
+        // if ( dot > 0.1 )
+        {
+          collEdges._intEdges.push_back( f->_le1 );
+          collEdges._intEdges.push_back( f->_le2 );
+        }
+        // else
+        // {
+        //   double shortLen = 0.75 * ( Min( dist1, dist2 ) / edge->_lenFactor );
+        //   edge->_maxLen = Min( shortLen, edge->_maxLen );
+        // }
+      }
+
+      if ( !collEdges._intEdges.empty() )
+      {
+        collEdges._edge = edge;
+        data._collisionEdges.push_back( collEdges );
       }
     }
-    return true;
   }
 
-  return false;
+  for ( size_t i = 0 ; i < tmpFaces.size(); ++i )
+    delete tmpFaces[i];
+
+  // restore the zero thickness
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
+  {
+    _EdgesOnShape& eos = data._edgesOnShape[iS];
+    if ( eos._edges.empty() ) continue;
+    if ( eos.ShapeType() != TopAbs_EDGE && eos.ShapeType() != TopAbs_VERTEX ) continue;
+
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
+    {
+      eos._edges[i]->InvalidateStep( 1, eos );
+      eos._edges[i]->_len = 0;
+    }
+  }
 }
 
 //================================================================================
@@ -4410,224 +6064,195 @@ bool _ViscousBuilder::smoothAnalyticEdge( _SolidData&           data,
 
 bool _ViscousBuilder::updateNormals( _SolidData&         data,
                                      SMESH_MesherHelper& helper,
-                                     int                 stepNb )
+                                     int                 stepNb,
+                                     double              stepSize)
 {
-  if ( stepNb > 0 )
-    return updateNormalsOfConvexFaces( data, helper, stepNb );
+  updateNormalsOfC1Vertices( data );
 
-  // make temporary quadrangles got by extrusion of
-  // mesh edges along _LayerEdge._normal's
+  if ( stepNb > 0 && !updateNormalsOfConvexFaces( data, helper, stepNb ))
+    return false;
 
-  vector< const SMDS_MeshElement* > tmpFaces;
+  // map to store new _normal and _cosin for each intersected edge
+  map< _LayerEdge*, _LayerEdge, _LayerEdgeCmp >           edge2newEdge;
+  map< _LayerEdge*, _LayerEdge, _LayerEdgeCmp >::iterator e2neIt;
+  _LayerEdge zeroEdge;
+  zeroEdge._normal.SetCoord( 0,0,0 );
+  zeroEdge._maxLen = Precision::Infinite();
+  zeroEdge._nodes.resize(1); // to init _TmpMeshFaceOnEdge
+
+  set< _EdgesOnShape* > shapesToSmooth, edgesNoAnaSmooth;
+
+  double segLen, dist1, dist2;
+  vector< pair< _LayerEdge*, double > > intEdgesDist;
+  _TmpMeshFaceOnEdge quad( &zeroEdge, &zeroEdge, 0 );
+
+  for ( int iter = 0; iter < 5; ++iter )
   {
-    set< SMESH_TLink > extrudedLinks; // contains target nodes
-    vector< const SMDS_MeshNode*> nodes(4); // of a tmp mesh face
+    edge2newEdge.clear();
 
-    dumpFunction(SMESH_Comment("makeTmpFacesOnEdges")<<data._index);
-    for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
+    for ( size_t iE = 0; iE < data._collisionEdges.size(); ++iE )
     {
-      _EdgesOnShape& eos = data._edgesOnShape[ iS ];
-      if ( eos.ShapeType() != TopAbs_EDGE || !eos._sWOL.IsNull() )
-        continue;
-      for ( size_t i = 0; i < eos._edges.size(); ++i )
+      _CollisionEdges& ce = data._collisionEdges[iE];
+      _LayerEdge*   edge1 = ce._edge;
+      if ( !edge1 || edge1->Is( _LayerEdge::BLOCKED )) continue;
+      _EdgesOnShape* eos1 = data.GetShapeEdges( edge1 );
+      if ( !eos1 ) continue;
+
+      // detect intersections
+      gp_Ax1 lastSeg = edge1->LastSegment( segLen, *eos1 );
+      double testLen = 1.5 * edge1->_maxLen; //2 + edge1->_len * edge1->_lenFactor;
+      double     eps = 0.5 * edge1->_len;
+      intEdgesDist.clear();
+      double minIntDist = Precision::Infinite();
+      for ( size_t i = 0; i < ce._intEdges.size(); i += 2 )
       {
-        _LayerEdge* edge = eos._edges[i];
-        const SMDS_MeshNode* tgt1 = edge->_nodes.back();
-        for ( int j = 0; j < 2; ++j ) // loop on _2NearEdges
+        if ( ce._intEdges[i  ]->Is( _LayerEdge::BLOCKED ) ||
+             ce._intEdges[i+1]->Is( _LayerEdge::BLOCKED ))
+          continue;
+        double dot  = edge1->_normal * quad.GetDir( ce._intEdges[i], ce._intEdges[i+1] );
+        double fact = ( 1.1 + dot * dot );
+        SMESH_TNodeXYZ pSrc0( ce.nSrc(i) ), pSrc1( ce.nSrc(i+1) );
+        SMESH_TNodeXYZ pTgt0( ce.nTgt(i) ), pTgt1( ce.nTgt(i+1) );
+        gp_XYZ pLast0 = pSrc0 + ( pTgt0 - pSrc0 ) * fact;
+        gp_XYZ pLast1 = pSrc1 + ( pTgt1 - pSrc1 ) * fact;
+        dist1 = dist2 = Precision::Infinite();
+        if ( !edge1->SegTriaInter( lastSeg, pSrc0, pTgt0, pSrc1, dist1, eps ) &&
+             !edge1->SegTriaInter( lastSeg, pSrc1, pTgt1, pTgt0, dist2, eps ))
+          continue;
+        if (( dist1 > testLen || dist1 < 0 ) &&
+            ( dist2 > testLen || dist2 < 0 ))
+          continue;
+
+        // choose a closest edge
+        gp_Pnt intP( lastSeg.Location().XYZ() +
+                     lastSeg.Direction().XYZ() * ( Min( dist1, dist2 ) + segLen ));
+        double d1 = intP.SquareDistance( pSrc0 );
+        double d2 = intP.SquareDistance( pSrc1 );
+        int iClose = i + ( d2 < d1 );
+        _LayerEdge* edge2 = ce._intEdges[iClose];
+        edge2->Unset( _LayerEdge::MARKED );
+
+        // choose a closest edge among neighbors
+        gp_Pnt srcP( SMESH_TNodeXYZ( edge1->_nodes[0] ));
+        d1 = srcP.SquareDistance( SMESH_TNodeXYZ( edge2->_nodes[0] ));
+        for ( size_t j = 0; j < intEdgesDist.size(); ++j )
         {
-          const SMDS_MeshNode* tgt2 = edge->_2neibors->tgtNode(j);
-          pair< set< SMESH_TLink >::iterator, bool > link_isnew =
-            extrudedLinks.insert( SMESH_TLink( tgt1, tgt2 ));
-          if ( !link_isnew.second )
+          _LayerEdge * edgeJ = intEdgesDist[j].first;
+          if ( edge2->IsNeiborOnEdge( edgeJ ))
           {
-            extrudedLinks.erase( link_isnew.first );
-            continue; // already extruded and will no more encounter
+            d2 = srcP.SquareDistance( SMESH_TNodeXYZ( edgeJ->_nodes[0] ));
+            ( d1 < d2 ? edgeJ : edge2 )->Set( _LayerEdge::MARKED );
           }
-          // a _LayerEdge containg tgt2
-          _LayerEdge* neiborEdge = edge->_2neibors->_edges[j];
-
-          _TmpMeshFaceOnEdge* f = new _TmpMeshFaceOnEdge( edge, neiborEdge, --_tmpFaceID );
-          tmpFaces.push_back( f );
-
-          dumpCmd(SMESH_Comment("mesh.AddFace([ ")
-                  <<f->_nn[0]->GetID()<<", "<<f->_nn[1]->GetID()<<", "
-                  <<f->_nn[2]->GetID()<<", "<<f->_nn[3]->GetID()<<" ])");
         }
+        intEdgesDist.push_back( make_pair( edge2, Min( dist1, dist2 )));
+        // if ( Abs( d2 - d1 ) / Max( d2, d1 ) < 0.5 )
+        // {
+        //   iClose = i + !( d2 < d1 );
+        //   intEdges.push_back( ce._intEdges[iClose] );
+        //   ce._intEdges[iClose]->Unset( _LayerEdge::MARKED );
+        // }
+        minIntDist = Min( edge1->_len * edge1->_lenFactor - segLen + dist1, minIntDist );
+        minIntDist = Min( edge1->_len * edge1->_lenFactor - segLen + dist2, minIntDist );
       }
-    }
-    dumpFunctionEnd();
-  }
-  // Check if _LayerEdge's based on EDGE's intersects tmpFaces.
-  // Perform two loops on _LayerEdge on EDGE's:
-  // 1) to find and fix intersection
-  // 2) to check that no new intersection appears as result of 1)
-
-  SMDS_ElemIteratorPtr fIt( new SMDS_ElementVectorIterator( tmpFaces.begin(),
-                                                            tmpFaces.end()));
-  auto_ptr<SMESH_ElementSearcher> searcher
-    ( SMESH_MeshAlgos::GetElementSearcher( *getMeshDS(), fIt ));
 
-  // 1) Find intersections
-  double dist;
-  const SMDS_MeshElement* face;
-  typedef map< _LayerEdge*, set< _LayerEdge*, _LayerEdgeCmp >, _LayerEdgeCmp > TLEdge2LEdgeSet;
-  TLEdge2LEdgeSet edge2CloseEdge;
+      //ce._edge = 0;
 
-  const double eps = data._epsilon * data._epsilon;
-  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
-  {
-    _EdgesOnShape& eos = data._edgesOnShape[ iS ];
-    if (( eos.ShapeType() != TopAbs_EDGE ) && 
-        ( eos._sWOL.IsNull() || eos.SWOLType() != TopAbs_FACE ))
-      continue;
-    for ( size_t i = 0; i < eos._edges.size(); ++i )
-    {
-      _LayerEdge* edge = eos._edges[i];
-      if ( edge->FindIntersection( *searcher, dist, eps, eos, &face ))
+      // compute new _normals
+      for ( size_t i = 0; i < intEdgesDist.size(); ++i )
       {
-        const _TmpMeshFaceOnEdge* f = (const _TmpMeshFaceOnEdge*) face;
-        set< _LayerEdge*, _LayerEdgeCmp > & ee = edge2CloseEdge[ edge ];
-        ee.insert( f->_le1 );
-        ee.insert( f->_le2 );
-        if ( f->_le1->IsOnEdge() && data.GetShapeEdges( f->_le1 )->_sWOL.IsNull() )
-          edge2CloseEdge[ f->_le1 ].insert( edge );
-        if ( f->_le2->IsOnEdge() && data.GetShapeEdges( f->_le2 )->_sWOL.IsNull() )
-          edge2CloseEdge[ f->_le2 ].insert( edge );
-      }
-    }
-  }
-
-  // Set _LayerEdge._normal
-
-  if ( !edge2CloseEdge.empty() )
-  {
-    dumpFunction(SMESH_Comment("updateNormals")<<data._index);
-
-    set< _EdgesOnShape* > shapesToSmooth;
+        _LayerEdge* edge2    = intEdgesDist[i].first;
+        double       distWgt = edge1->_len / intEdgesDist[i].second;
+        if ( edge2->Is( _LayerEdge::MARKED )) continue;
+        edge2->Set( _LayerEdge::MARKED );
 
-    // vector to store new _normal and _cosin for each edge in edge2CloseEdge
-    vector< pair< _LayerEdge*, _LayerEdge > > edge2newEdge( edge2CloseEdge.size() );
-
-    TLEdge2LEdgeSet::iterator e2ee = edge2CloseEdge.begin();
-    for ( size_t iE = 0; e2ee != edge2CloseEdge.end(); ++e2ee, ++iE )
-    {
-      _LayerEdge* edge1 = e2ee->first;
-      _LayerEdge* edge2 = 0;
-      set< _LayerEdge*, _LayerEdgeCmp >& ee = e2ee->second;
+        // get a new normal
+        gp_XYZ dir1 = edge1->_normal, dir2 = edge2->_normal;
 
-      edge2newEdge[ iE ].first = NULL;
+        double cos1 = Abs( edge1->_cosin ), cos2 = Abs( edge2->_cosin );
+        double wgt1 = ( cos1 + 0.001 ) / ( cos1 + cos2 + 0.002 );
+        double wgt2 = ( cos2 + 0.001 ) / ( cos1 + cos2 + 0.002 );
+        // double cos1 = Abs( edge1->_cosin ),        cos2 = Abs( edge2->_cosin );
+        // double sgn1 = 0.1 * ( 1 + edge1->_cosin ), sgn2 = 0.1 * ( 1 + edge2->_cosin );
+        // double wgt1 = ( cos1 + sgn1 ) / ( cos1 + cos2 + sgn1 + sgn2 );
+        // double wgt2 = ( cos2 + sgn2 ) / ( cos1 + cos2 + sgn1 + sgn2 );
+        gp_XYZ newNormal = wgt1 * dir1 + wgt2 * dir2;
+        newNormal.Normalize();
 
-      _EdgesOnShape* eos1 = data.GetShapeEdges( edge1 );
-      if ( !eos1 ) continue;
+        // get new cosin
+        double newCos;
+        double sgn1 = edge1->_cosin / cos1, sgn2 = edge2->_cosin / cos2;
+        if ( cos1 < theMinSmoothCosin )
+        {
+          newCos = cos2 * sgn1;
+        }
+        else if ( cos2 > theMinSmoothCosin ) // both cos1 and cos2 > theMinSmoothCosin
+        {
+          newCos = ( wgt1 * cos1 + wgt2 * cos2 ) * edge1->_cosin / cos1;
+        }
+        else
+        {
+          newCos = edge1->_cosin;
+        }
 
-      // find EDGEs the edges reside
-      // TopoDS_Edge E1, E2;
-      // TopoDS_Shape S = helper.GetSubShapeByNode( edge1->_nodes[0], getMeshDS() );
-      // if ( S.ShapeType() != TopAbs_EDGE )
-      //   continue; // TODO: find EDGE by VERTEX
-      // E1 = TopoDS::Edge( S );
-      set< _LayerEdge*, _LayerEdgeCmp >::iterator eIt = ee.begin();
-      for ( ; !edge2 && eIt != ee.end(); ++eIt )
-      {
-        if ( eos1->_sWOL == data.GetShapeEdges( *eIt  )->_sWOL )
-          edge2 = *eIt;
+        e2neIt = edge2newEdge.insert( make_pair( edge1, zeroEdge )).first;
+        e2neIt->second._normal += distWgt * newNormal;
+        e2neIt->second._cosin   = newCos;
+        e2neIt->second._maxLen  = 0.7 * minIntDist / edge1->_lenFactor;
+        if ( iter > 0 && sgn1 * sgn2 < 0 && edge1->_cosin < 0 )
+          e2neIt->second._normal += dir2;
+        e2neIt = edge2newEdge.insert( make_pair( edge2, zeroEdge )).first;
+        e2neIt->second._normal += distWgt * newNormal;
+        e2neIt->second._cosin   = edge2->_cosin;
+        if ( iter > 0 && sgn1 * sgn2 < 0 && edge2->_cosin < 0 )
+          e2neIt->second._normal += dir1;
       }
-      if ( !edge2 ) continue;
+    }
 
-      edge2newEdge[ iE ].first = edge1;
-      _LayerEdge& newEdge = edge2newEdge[ iE ].second;
-      // while ( E2.IsNull() && eIt != ee.end())
-      // {
-      //   _LayerEdge* e2 = *eIt++;
-      //   TopoDS_Shape S = helper.GetSubShapeByNode( e2->_nodes[0], getMeshDS() );
-      //   if ( S.ShapeType() == TopAbs_EDGE )
-      //     E2 = TopoDS::Edge( S ), edge2 = e2;
-      // }
-      // if ( E2.IsNull() ) continue; // TODO: find EDGE by VERTEX
+    if ( edge2newEdge.empty() )
+      break; //return true;
 
-      // find 3 FACEs sharing 2 EDGEs
+    dumpFunction(SMESH_Comment("updateNormals")<< data._index << "_" << stepNb << "_it" << iter);
 
-      // TopoDS_Face FF1[2], FF2[2];
-      // PShapeIteratorPtr fIt = helper.GetAncestors(E1, *_mesh, TopAbs_FACE);
-      // while ( fIt->more() && FF1[1].IsNull() )
-      // {
-      //   const TopoDS_Face *F = (const TopoDS_Face*) fIt->next();
-      //   if ( helper.IsSubShape( *F, data._solid))
-      //     FF1[ FF1[0].IsNull() ? 0 : 1 ] = *F;
-      // }
-      // fIt = helper.GetAncestors(E2, *_mesh, TopAbs_FACE);
-      // while ( fIt->more() && FF2[1].IsNull())
-      // {
-      //   const TopoDS_Face *F = (const TopoDS_Face*) fIt->next();
-      //   if ( helper.IsSubShape( *F, data._solid))
-      //     FF2[ FF2[0].IsNull() ? 0 : 1 ] = *F;
-      // }
-      // // exclude a FACE common to E1 and E2 (put it to FFn[1] )
-      // if ( FF1[0].IsSame( FF2[0]) || FF1[0].IsSame( FF2[1]))
-      //   std::swap( FF1[0], FF1[1] );
-      // if ( FF2[0].IsSame( FF1[0]) )
-      //   std::swap( FF2[0], FF2[1] );
-      // if ( FF1[0].IsNull() || FF2[0].IsNull() )
-      //   continue;
-
-      // get a new normal for edge1
-      //bool ok;
-      gp_Vec dir1 = edge1->_normal, dir2 = edge2->_normal;
-      // if ( edge1->_cosin < 0 )
-      //   dir1 = getFaceDir( FF1[0], E1, edge1->_nodes[0], helper, ok ).Normalized();
-      // if ( edge2->_cosin < 0 )
-      //   dir2 = getFaceDir( FF2[0], E2, edge2->_nodes[0], helper, ok ).Normalized();
-
-      double cos1 = Abs( edge1->_cosin ), cos2 = Abs( edge2->_cosin );
-      double wgt1 = ( cos1 + 0.001 ) / ( cos1 + cos2 + 0.002 );
-      double wgt2 = ( cos2 + 0.001 ) / ( cos1 + cos2 + 0.002 );
-      newEdge._normal = ( wgt1 * dir1 + wgt2 * dir2 ).XYZ();
-      newEdge._normal.Normalize();
+    // Update data of edges depending on a new _normal
 
-      // cout << edge1->_nodes[0]->GetID() << " "
-      //      << edge2->_nodes[0]->GetID() << " NORM: "
-      //      << newEdge._normal.X() << ", " << newEdge._normal.Y() << ", " << newEdge._normal.Z() << endl;
+    data.UnmarkEdges();
+    for ( e2neIt = edge2newEdge.begin(); e2neIt != edge2newEdge.end(); ++e2neIt )
+    {
+      _LayerEdge*    edge = e2neIt->first;
+      _LayerEdge& newEdge = e2neIt->second;
+      _EdgesOnShape*  eos = data.GetShapeEdges( edge );
 
-      // get new cosin
-      if ( cos1 < theMinSmoothCosin )
-      {
-        newEdge._cosin = edge2->_cosin;
-      }
-      else if ( cos2 > theMinSmoothCosin ) // both cos1 and cos2 > theMinSmoothCosin
-      {
-        // gp_Vec dirInFace;
-        // if ( edge1->_cosin < 0 )
-        //   dirInFace = dir1;
-        // else
-        //   dirInFace = getFaceDir( FF1[0], E1, edge1->_nodes[0], helper, ok );
-        // double angle = dirInFace.Angle( edge1->_normal ); // [0,PI]
-        // edge1->SetCosin( Cos( angle ));
-        //newEdge._cosin = 0; // ???????????
-        newEdge._cosin = ( wgt1 * cos1 + wgt2 * cos2 ) * edge1->_cosin / cos1;
-      }
-      else
+      // Check if a new _normal is OK:
+      newEdge._normal.Normalize();
+      if ( !isNewNormalOk( data, *edge, newEdge._normal ))
       {
-        newEdge._cosin = edge1->_cosin;
+        if ( newEdge._maxLen < edge->_len && iter > 0 ) // limit _maxLen
+        {
+          edge->InvalidateStep( stepNb + 1, *eos, /*restoreLength=*/true  );
+          edge->_maxLen = newEdge._maxLen;
+          edge->SetNewLength( newEdge._maxLen, *eos, helper );
+        }
+        continue; // the new _normal is bad
       }
+      // the new _normal is OK
 
       // find shapes that need smoothing due to change of _normal
-      if ( edge1->_cosin  < theMinSmoothCosin &&
+      if ( edge->_cosin   < theMinSmoothCosin &&
            newEdge._cosin > theMinSmoothCosin )
       {
-        if ( eos1->_sWOL.IsNull() )
+        if ( eos->_sWOL.IsNull() )
         {
-          SMDS_ElemIteratorPtr fIt = edge1->_nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
+          SMDS_ElemIteratorPtr fIt = edge->_nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
           while ( fIt->more() )
             shapesToSmooth.insert( data.GetShapeEdges( fIt->next()->getshapeId() ));
-          //limitStepSize( data, fIt->next(), edge1->_cosin ); // too late
         }
-        else // edge1 inflates along a FACE
+        else // edge inflates along a FACE
         {
-          TopoDS_Shape V = helper.GetSubShapeByNode( edge1->_nodes[0], getMeshDS() );
+          TopoDS_Shape V = helper.GetSubShapeByNode( edge->_nodes[0], getMeshDS() );
           PShapeIteratorPtr eIt = helper.GetAncestors( V, *_mesh, TopAbs_EDGE );
           while ( const TopoDS_Shape* E = eIt->next() )
           {
-            if ( !helper.IsSubShape( *E, /*FACE=*/eos1->_sWOL ))
+            if ( !helper.IsSubShape( *E, /*FACE=*/eos->_sWOL ))
               continue;
             gp_Vec edgeDir = getEdgeDir( TopoDS::Edge( *E ), TopoDS::Vertex( V ));
             double   angle = edgeDir.Angle( newEdge._normal ); // [0,PI]
@@ -4636,25 +6261,27 @@ bool _ViscousBuilder::updateNormals( _SolidData&         data,
           }
         }
       }
-    }
 
-    data.AddShapesToSmooth( shapesToSmooth );
+      double len = edge->_len;
+      edge->InvalidateStep( stepNb + 1, *eos, /*restoreLength=*/true  );
+      edge->SetNormal( newEdge._normal );
+      edge->SetCosin( newEdge._cosin );
+      edge->SetNewLength( len, *eos, helper );
+      edge->Set( _LayerEdge::MARKED );
+      edge->Set( _LayerEdge::NORMAL_UPDATED );
+      edgesNoAnaSmooth.insert( eos );
+    }
 
-    // Update data of edges depending on a new _normal
+    // Update normals and other dependent data of not intersecting _LayerEdge's
+    // neighboring the intersecting ones
 
-    for ( size_t iE = 0; iE < edge2newEdge.size(); ++iE )
+    for ( e2neIt = edge2newEdge.begin(); e2neIt != edge2newEdge.end(); ++e2neIt )
     {
-      _LayerEdge*   edge1 = edge2newEdge[ iE ].first;
-      _LayerEdge& newEdge = edge2newEdge[ iE ].second;
-      if ( !edge1 ) continue;
+      _LayerEdge*   edge1 = e2neIt->first;
       _EdgesOnShape* eos1 = data.GetShapeEdges( edge1 );
-      if ( !eos1 ) continue;
+      if ( !edge1->Is( _LayerEdge::MARKED ))
+        continue;
 
-      edge1->_normal = newEdge._normal;
-      edge1->SetCosin( newEdge._cosin );
-      edge1->InvalidateStep( 1, *eos1 );
-      edge1->_len = 0;
-      edge1->SetNewLength( data._stepSize, *eos1, helper );
       if ( edge1->IsOnEdge() )
       {
         const SMDS_MeshNode * n1 = edge1->_2neibors->srcNode(0);
@@ -4662,62 +6289,203 @@ bool _ViscousBuilder::updateNormals( _SolidData&         data,
         edge1->SetDataByNeighbors( n1, n2, *eos1, helper );
       }
 
-      // Update normals and other dependent data of not intersecting _LayerEdge's
-      // neighboring the intersecting ones
-
       if ( !edge1->_2neibors )
         continue;
       for ( int j = 0; j < 2; ++j ) // loop on 2 neighbors
       {
         _LayerEdge* neighbor = edge1->_2neibors->_edges[j];
-        if ( edge2CloseEdge.count ( neighbor ))
+        if ( neighbor->Is( _LayerEdge::MARKED ) /*edge2newEdge.count ( neighbor )*/)
           continue; // j-th neighbor is also intersected
-        _EdgesOnShape* eos = data.GetShapeEdges( neighbor );
-        if ( !eos ) continue;
         _LayerEdge* prevEdge = edge1;
         const int nbSteps = 10;
         for ( int step = nbSteps; step; --step ) // step from edge1 in j-th direction
         {
-          if ( !neighbor->_2neibors )
-            break; // neighbor is on VERTEX
-          int iNext = 0;
-          _LayerEdge* nextEdge = neighbor->_2neibors->_edges[iNext];
-          if ( nextEdge == prevEdge )
-            nextEdge = neighbor->_2neibors->_edges[ ++iNext ];
+          if ( neighbor->Is( _LayerEdge::BLOCKED ) ||
+               neighbor->Is( _LayerEdge::MARKED ))
+            break;
+          _EdgesOnShape* eos = data.GetShapeEdges( neighbor );
+          if ( !eos ) continue;
+          _LayerEdge* nextEdge = neighbor;
+          if ( neighbor->_2neibors )
+          {
+            int iNext = 0;
+            nextEdge = neighbor->_2neibors->_edges[iNext];
+            if ( nextEdge == prevEdge )
+              nextEdge = neighbor->_2neibors->_edges[ ++iNext ];
+          }
           double r = double(step-1)/nbSteps;
           if ( !nextEdge->_2neibors )
-            r = 0.5;
+            r = Min( r, 0.5 );
+
+          gp_XYZ newNorm = prevEdge->_normal * r + nextEdge->_normal * (1-r);
+          newNorm.Normalize();
+          if ( !isNewNormalOk( data, *neighbor, newNorm ))
+            break;
+
+          double len = neighbor->_len;
+          neighbor->InvalidateStep( stepNb + 1, *eos, /*restoreLength=*/true  );
+          neighbor->SetNormal( newNorm );
+          neighbor->SetCosin( prevEdge->_cosin * r + nextEdge->_cosin * (1-r) );
+          if ( neighbor->_2neibors )
+            neighbor->SetDataByNeighbors( prevEdge->_nodes[0], nextEdge->_nodes[0], *eos, helper );
+          neighbor->SetNewLength( len, *eos, helper );
+          neighbor->Set( _LayerEdge::MARKED );
+          neighbor->Set( _LayerEdge::NORMAL_UPDATED );
+          edgesNoAnaSmooth.insert( eos );
+
+          if ( !neighbor->_2neibors )
+            break; // neighbor is on VERTEX
+
+          // goto the next neighbor
+          prevEdge = neighbor;
+          neighbor = nextEdge;
+        }
+      }
+    }
+    dumpFunctionEnd();
+  } // iterations
+
+  data.AddShapesToSmooth( shapesToSmooth, &edgesNoAnaSmooth );
+
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Check if a new normal is OK
+ */
+//================================================================================
+
+bool _ViscousBuilder::isNewNormalOk( _SolidData&   data,
+                                     _LayerEdge&   edge,
+                                     const gp_XYZ& newNormal)
+{
+  // check a min angle between the newNormal and surrounding faces
+  vector<_Simplex> simplices;
+  SMESH_TNodeXYZ n0( edge._nodes[0] ), n1, n2;
+  _Simplex::GetSimplices( n0._node, simplices, data._ignoreFaceIds, &data );
+  double newMinDot = 1, curMinDot = 1;
+  for ( size_t i = 0; i < simplices.size(); ++i )
+  {
+    n1.Set( simplices[i]._nPrev );
+    n2.Set( simplices[i]._nNext );
+    gp_XYZ normFace = ( n1 - n0 ) ^ ( n2 - n0 );
+    double normLen2 = normFace.SquareModulus();
+    if ( normLen2 < std::numeric_limits<double>::min() )
+      continue;
+    normFace /= Sqrt( normLen2 );
+    newMinDot = Min( newNormal    * normFace, newMinDot );
+    curMinDot = Min( edge._normal * normFace, curMinDot );
+  }
+  if ( newMinDot < 0.5 )
+  {
+    return ( newMinDot >= curMinDot * 0.9 );
+    //return ( newMinDot >= ( curMinDot * ( 0.8 + 0.1 * edge.NbSteps() )));
+    // double initMinDot2 = 1. - edge._cosin * edge._cosin;
+    // return ( newMinDot * newMinDot ) >= ( 0.8 * initMinDot2 );
+  }
+  return true;
+}
+
+//================================================================================
+/*!
+ * \brief Modify normals of _LayerEdge's on FACE to reflex smoothing
+ */
+//================================================================================
+
+bool _ViscousBuilder::updateNormalsOfSmoothed( _SolidData&         data,
+                                               SMESH_MesherHelper& helper,
+                                               const int           nbSteps,
+                                               const double        stepSize )
+{
+  if ( data._nbShapesToSmooth == 0 || nbSteps == 0 )
+    return true; // no shapes needing smoothing
 
-          gp_XYZ newNorm = prevEdge->_normal * r + nextEdge->_normal * (1-r);
-          newNorm.Normalize();
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
+  {
+    _EdgesOnShape& eos = data._edgesOnShape[ iS ];
+    if ( //!eos._toSmooth ||  _eosC1 have _toSmooth == false
+         !eos._hyp.ToSmooth() ||
+         eos.ShapeType() != TopAbs_FACE ||
+         eos._edges.empty() )
+      continue;
 
-          neighbor->_normal = newNorm;
-          neighbor->SetCosin( prevEdge->_cosin * r + nextEdge->_cosin * (1-r) );
-          neighbor->SetDataByNeighbors( prevEdge->_nodes[0], nextEdge->_nodes[0], *eos, helper );
+    bool toSmooth = ( eos._edges[ 0 ]->NbSteps() >= nbSteps+1 );
+    if ( !toSmooth ) continue;
 
-          neighbor->InvalidateStep( 1, *eos );
-          neighbor->_len = 0;
-          neighbor->SetNewLength( data._stepSize, *eos, helper );
+    for ( size_t i = 0; i < eos._edges.size(); ++i )
+    {
+      _LayerEdge* edge = eos._edges[i];
+      if ( !edge->Is( _LayerEdge::SMOOTHED ))
+        continue;
+      if ( edge->Is( _LayerEdge::DIFFICULT ) && nbSteps != 1 )
+        continue;
 
-          // goto the next neighbor
-          prevEdge = neighbor;
-          neighbor = nextEdge;
-        }
-      }
+      const gp_XYZ& pPrev = edge->PrevPos();
+      const gp_XYZ& pLast = edge->_pos.back();
+      gp_XYZ      stepVec = pLast - pPrev;
+      double realStepSize = stepVec.Modulus();
+      if ( realStepSize < numeric_limits<double>::min() )
+        continue;
+
+      edge->_lenFactor = realStepSize / stepSize;
+      edge->_normal    = stepVec / realStepSize;
+      edge->Set( _LayerEdge::NORMAL_UPDATED );
     }
-    dumpFunctionEnd();
   }
-  // 2) Check absence of intersections
-  // TODO?
-
-  for ( size_t i = 0 ; i < tmpFaces.size(); ++i )
-    delete tmpFaces[i];
 
   return true;
 }
 
 //================================================================================
 /*!
+ * \brief Modify normals of _LayerEdge's on C1 VERTEXes
+ */
+//================================================================================
+
+void _ViscousBuilder::updateNormalsOfC1Vertices( _SolidData& data )
+{
+  for ( size_t iS = 0; iS < data._edgesOnShape.size(); ++iS )
+  {
+    _EdgesOnShape& eov = data._edgesOnShape[ iS ];
+    if ( eov._eosC1.empty() ||
+         eov.ShapeType() != TopAbs_VERTEX ||
+         eov._edges.empty() )
+      continue;
+
+    gp_XYZ newNorm   = eov._edges[0]->_normal;
+    double curThick  = eov._edges[0]->_len * eov._edges[0]->_lenFactor;
+    bool normChanged = false;
+
+    for ( size_t i = 0; i < eov._eosC1.size(); ++i )
+    {
+      _EdgesOnShape*   eoe = eov._eosC1[i];
+      const TopoDS_Edge& e = TopoDS::Edge( eoe->_shape );
+      const double    eLen = SMESH_Algo::EdgeLength( e );
+      TopoDS_Shape    oppV = SMESH_MesherHelper::IthVertex( 0, e );
+      if ( oppV.IsSame( eov._shape ))
+        oppV = SMESH_MesherHelper::IthVertex( 1, e );
+      _EdgesOnShape* eovOpp = data.GetShapeEdges( oppV );
+      if ( !eovOpp || eovOpp->_edges.empty() ) continue;
+
+      double curThickOpp = eovOpp->_edges[0]->_len * eovOpp->_edges[0]->_lenFactor;
+      if ( curThickOpp + curThick < eLen )
+        continue;
+
+      double wgt = 2. * curThick / eLen;
+      newNorm += wgt * eovOpp->_edges[0]->_normal;
+      normChanged = true;
+    }
+    if ( normChanged )
+    {
+      eov._edges[0]->SetNormal( newNorm.Normalized() );
+      eov._edges[0]->Set( _LayerEdge::NORMAL_UPDATED );
+    }
+  }
+}
+
+//================================================================================
+/*!
  * \brief Modify normals of _LayerEdge's on _ConvexFace's
  */
 //================================================================================
@@ -4844,7 +6612,10 @@ bool _ViscousBuilder::updateNormalsOfConvexFaces( _SolidData&         data,
             eos._edges[ i ]->_cosin = avgCosin;
 
         for ( size_t i = 0; i < eos._edges.size(); ++i )
-          eos._edges[ i ]->_normal = avgNormal;
+        {
+          eos._edges[ i ]->SetNormal( avgNormal );
+          eos._edges[ i ]->Set( _LayerEdge::NORMAL_UPDATED );
+        }
       }
     }
     else // if ( isSpherical )
@@ -4888,7 +6659,7 @@ bool _ViscousBuilder::updateNormalsOfConvexFaces( _SolidData&         data,
         else
         {
           if ( ! eos->_toSmooth )
-            data.SortOnEdge( edge, eos->_edges, helper );
+            data.SortOnEdge( edge, eos->_edges );
           edgeLEdge    = &eos->_edges[ 0 ];
           edgeLEdgeEnd = edgeLEdge + eos->_edges.size();
           vertexLEdges[0] = eos->_edges.front()->_2neibors->_edges[0];
@@ -4966,7 +6737,10 @@ bool _ViscousBuilder::updateNormalsOfConvexFaces( _SolidData&         data,
         if ( centerCurves[ iE ]._isDegenerated )
           continue;
         for ( size_t iLE = 0; iLE < centerCurves[ iE ]._ledges.size(); ++iLE )
-          centerCurves[ iE ]._ledges[ iLE ]->_normal = centerCurves[ iE ]._normals[ iLE ];
+        {
+          centerCurves[ iE ]._ledges[ iLE ]->SetNormal( centerCurves[ iE ]._normals[ iLE ]);
+          centerCurves[ iE ]._ledges[ iLE ]->Set( _LayerEdge::NORMAL_UPDATED );
+        }
       }
       // set new normals to _LayerEdge's of     degenerated central curves
       for ( size_t iE = 0; iE < centerCurves.size(); ++iE )
@@ -4986,8 +6760,9 @@ bool _ViscousBuilder::updateNormalsOfConvexFaces( _SolidData&         data,
                             0.5 * centerCurves[ iE ]._ledges.back ()->_cosin );
         for ( size_t iLE = 1, nb = centerCurves[ iE ]._ledges.size() - 1; iLE < nb; ++iLE )
         {
-          centerCurves[ iE ]._ledges[ iLE ]->_normal = newNorm;
-          centerCurves[ iE ]._ledges[ iLE ]->_cosin  = newCosin;
+          centerCurves[ iE ]._ledges[ iLE ]->SetNormal( newNorm );
+          centerCurves[ iE ]._ledges[ iLE ]->_cosin   = newCosin;
+          centerCurves[ iE ]._ledges[ iLE ]->Set( _LayerEdge::NORMAL_UPDATED );
         }
       }
 
@@ -5015,8 +6790,9 @@ bool _ViscousBuilder::updateNormalsOfConvexFaces( _SolidData&         data,
             newNorm.SetCoord( 0,0,0 );
             if ( centerCurves[ iE ].FindNewNormal( center, newNorm ))
             {
-              ledge->_normal = newNorm;
+              ledge->SetNormal( newNorm );
               ledge->_cosin  = avgCosin;
+              ledge->Set( _LayerEdge::NORMAL_UPDATED );
               break;
             }
           }
@@ -5042,7 +6818,21 @@ bool _ViscousBuilder::updateNormalsOfConvexFaces( _SolidData&         data,
         ledge->SetCosin( ledge->_cosin );
         ledge->SetNewLength( len, eos, helper );
       }
-
+      if ( eos.ShapeType() != TopAbs_FACE )
+        for ( size_t i = 0; i < eos._edges.size(); ++i )
+        {
+          _LayerEdge* ledge = eos._edges[ i ];
+          for ( size_t iN = 0; iN < ledge->_neibors.size(); ++iN )
+          {
+            _LayerEdge* neibor = ledge->_neibors[iN];
+            if ( neibor->_nodes[0]->GetPosition()->GetDim() == 2 )
+            {
+              neibor->Set( _LayerEdge::NEAR_BOUNDARY );
+              neibor->Set( _LayerEdge::MOVED );
+              neibor->SetSmooLen( neibor->_len );
+            }
+          }
+        }
     } // loop on sub-shapes of convFace._face
 
     // Find FACEs adjacent to convFace._face that got necessity to smooth
@@ -5114,7 +6904,7 @@ bool _ConvexFace::CheckPrisms() const
     const _LayerEdge* edge = _simplexTestEdges[i];
     SMESH_TNodeXYZ tgtXYZ( edge->_nodes.back() );
     for ( size_t j = 0; j < edge->_simplices.size(); ++j )
-      if ( !edge->_simplices[j].IsForward( edge->_nodes[0], &tgtXYZ, vol ))
+      if ( !edge->_simplices[j].IsForward( edge->_nodes[0], tgtXYZ, vol ))
       {
         debugMsg( "Bad simplex of _simplexTestEdges ("
                   << " "<< edge->_nodes[0]->GetID()<< " "<< tgtXYZ._node->GetID()
@@ -5209,7 +6999,7 @@ bool _LayerEdge::FindIntersection( SMESH_ElementSearcher&   searcher,
                                    double &                 distance,
                                    const double&            epsilon,
                                    _EdgesOnShape&           eos,
-                                   const SMDS_MeshElement** face)
+                                   const SMDS_MeshElement** intFace)
 {
   vector< const SMDS_MeshElement* > suspectFaces;
   double segLen;
@@ -5253,23 +7043,23 @@ bool _LayerEdge::FindIntersection( SMESH_ElementSearcher&   searcher,
         distance = dist, iFace = j;
     }
   }
-  if ( iFace != -1 && face ) *face = suspectFaces[iFace];
+  if ( intFace ) *intFace = ( iFace != -1 ) ? suspectFaces[iFace] : 0;
+
+  distance -= segLen;
 
   if ( segmentIntersected )
   {
 #ifdef __myDEBUG
     SMDS_MeshElement::iterator nIt = suspectFaces[iFace]->begin_nodes();
-    gp_XYZ intP( lastSegment.Location().XYZ() + lastSegment.Direction().XYZ() * distance );
+    gp_XYZ intP( lastSegment.Location().XYZ() + lastSegment.Direction().XYZ() * ( distance+segLen ));
     cout << "nodes: tgt " << _nodes.back()->GetID() << " src " << _nodes[0]->GetID()
          << ", intersection with face ("
          << (*nIt++)->GetID()<<" "<< (*nIt++)->GetID()<<" "<< (*nIt++)->GetID()
          << ") at point (" << intP.X() << ", " << intP.Y() << ", " << intP.Z()
-         << ") distance = " << distance - segLen<< endl;
+         << ") distance = " << distance << endl;
 #endif
   }
 
-  distance -= segLen;
-
   return segmentIntersected;
 }
 
@@ -5283,13 +7073,14 @@ gp_Ax1 _LayerEdge::LastSegment(double& segLen, _EdgesOnShape& eos) const
 {
   // find two non-coincident positions
   gp_XYZ orig = _pos.back();
-  gp_XYZ dir;
+  gp_XYZ vec;
   int iPrev = _pos.size() - 2;
-  const double tol = ( _len > 0 ) ? 0.3*_len : 1e-100; // adjusted for IPAL52478 + PAL22576
+  //const double tol = ( _len > 0 ) ? 0.3*_len : 1e-100; // adjusted for IPAL52478 + PAL22576
+  const double tol = ( _len > 0 ) ? ( 1e-6 * _len ) : 1e-100;
   while ( iPrev >= 0 )
   {
-    dir = orig - _pos[iPrev];
-    if ( dir.SquareModulus() > tol*tol )
+    vec = orig - _pos[iPrev];
+    if ( vec.SquareModulus() > tol*tol )
       break;
     else
       iPrev--;
@@ -5320,11 +7111,11 @@ gp_Ax1 _LayerEdge::LastSegment(double& segLen, _EdgesOnShape& eos) const
         Handle(Geom_Surface) surface = BRep_Tool::Surface( TopoDS::Face( eos._sWOL ), loc );
         pPrev = surface->Value( pPrev.X(), pPrev.Y() ).Transformed( loc );
       }
-      dir = SMESH_TNodeXYZ( _nodes.back() ) - pPrev.XYZ();
+      vec = SMESH_TNodeXYZ( _nodes.back() ) - pPrev.XYZ();
     }
     segDir.SetLocation( pPrev );
-    segDir.SetDirection( dir );
-    segLen = dir.Modulus();
+    segDir.SetDirection( vec );
+    segLen = vec.Modulus();
   }
 
   return segDir;
@@ -5363,22 +7154,16 @@ gp_XY _LayerEdge::LastUV( const TopoDS_Face& F, _EdgesOnShape& eos ) const
  */
 //================================================================================
 
-bool _LayerEdge::SegTriaInter( const gp_Ax1&        lastSegment,
-                               const SMDS_MeshNode* n0,
-                               const SMDS_MeshNode* n1,
-                               const SMDS_MeshNode* n2,
-                               double&              t,
-                               const double&        EPSILON) const
+bool _LayerEdge::SegTriaInter( const gp_Ax1& lastSegment,
+                               const gp_XYZ& vert0,
+                               const gp_XYZ& vert1,
+                               const gp_XYZ& vert2,
+                               double&       t,
+                               const double& EPSILON) const
 {
-  //const double EPSILON = 1e-6;
-
   const gp_Pnt& orig = lastSegment.Location();
   const gp_Dir& dir  = lastSegment.Direction();
 
-  SMESH_TNodeXYZ vert0( n0 );
-  SMESH_TNodeXYZ vert1( n1 );
-  SMESH_TNodeXYZ vert2( n2 );
-
   /* calculate distance from vert0 to ray origin */
   gp_XYZ tvec = orig.XYZ() - vert0;
 
@@ -5395,13 +7180,14 @@ bool _LayerEdge::SegTriaInter( const gp_Ax1&        lastSegment,
   /* if determinant is near zero, ray lies in plane of triangle */
   double det = edge1 * pvec;
 
-  if (det > -EPSILON && det < EPSILON)
+  const double ANGL_EPSILON = 1e-12;
+  if ( det > -ANGL_EPSILON && det < ANGL_EPSILON )
     return false;
 
   /* calculate U parameter and test bounds */
   double u = ( tvec * pvec ) / det;
   //if (u < 0.0 || u > 1.0)
-  if (u < -EPSILON || u > 1.0 + EPSILON)
+  if ( u < -EPSILON || u > 1.0 + EPSILON )
     return false;
 
   /* prepare to test V parameter */
@@ -5410,7 +7196,7 @@ bool _LayerEdge::SegTriaInter( const gp_Ax1&        lastSegment,
   /* calculate V parameter and test bounds */
   double v = (dir.XYZ() * qvec) / det;
   //if ( v < 0.0 || u + v > 1.0 )
-  if ( v < -EPSILON || u + v > 1.0 + EPSILON)
+  if ( v < -EPSILON || u + v > 1.0 + EPSILON )
     return false;
 
   /* calculate t, ray intersects triangle */
@@ -5422,14 +7208,166 @@ bool _LayerEdge::SegTriaInter( const gp_Ax1&        lastSegment,
 
 //================================================================================
 /*!
+ * \brief _LayerEdge, located at a concave VERTEX of a FACE, moves target nodes of
+ *        neighbor _LayerEdge's by it's own inflation vector.
+ *  \param [in] eov - EOS of the VERTEX
+ *  \param [in] eos - EOS of the FACE
+ *  \param [in] step - inflation step
+ *  \param [in,out] badSmooEdges - not untangled _LayerEdge's
+ */
+//================================================================================
+
+void _LayerEdge::MoveNearConcaVer( const _EdgesOnShape*    eov,
+                                   const _EdgesOnShape*    eos,
+                                   const int               step,
+                                   vector< _LayerEdge* > & badSmooEdges )
+{
+  // check if any of _neibors is in badSmooEdges
+  if ( std::find_first_of( _neibors.begin(), _neibors.end(),
+                           badSmooEdges.begin(), badSmooEdges.end() ) == _neibors.end() )
+    return;
+
+  // get all edges to move
+
+  set< _LayerEdge* > edges;
+
+  // find a distance between _LayerEdge on VERTEX and its neighbors
+  gp_XYZ  curPosV = SMESH_TNodeXYZ( _nodes.back() );
+  double dist2 = 0;
+  for ( size_t i = 0; i < _neibors.size(); ++i )
+  {
+    _LayerEdge* nEdge = _neibors[i];
+    if ( nEdge->_nodes[0]->getshapeId() == eos->_shapeID )
+    {
+      edges.insert( nEdge );
+      dist2 = Max( dist2, ( curPosV - nEdge->_pos.back() ).SquareModulus() );
+    }
+  }
+  // add _LayerEdge's close to curPosV
+  size_t nbE;
+  do {
+    nbE = edges.size();
+    for ( set< _LayerEdge* >::iterator e = edges.begin(); e != edges.end(); ++e )
+    {
+      _LayerEdge* edgeF = *e;
+      for ( size_t i = 0; i < edgeF->_neibors.size(); ++i )
+      {
+        _LayerEdge* nEdge = edgeF->_neibors[i];
+        if ( nEdge->_nodes[0]->getshapeId() == eos->_shapeID &&
+             dist2 > ( curPosV - nEdge->_pos.back() ).SquareModulus() )
+          edges.insert( nEdge );
+      }
+    }
+  }
+  while ( nbE < edges.size() );
+
+  // move the target node of the got edges
+
+  gp_XYZ prevPosV = PrevPos();
+  if ( eov->SWOLType() == TopAbs_EDGE )
+  {
+    BRepAdaptor_Curve curve ( TopoDS::Edge( eov->_sWOL ));
+    prevPosV = curve.Value( prevPosV.X() ).XYZ();
+  }
+  else if ( eov->SWOLType() == TopAbs_FACE )
+  {
+    BRepAdaptor_Surface surface( TopoDS::Face( eov->_sWOL ));
+    prevPosV = surface.Value( prevPosV.X(), prevPosV.Y() ).XYZ();
+  }
+
+  SMDS_FacePosition* fPos;
+  //double r = 1. - Min( 0.9, step / 10. );
+  for ( set< _LayerEdge* >::iterator e = edges.begin(); e != edges.end(); ++e )
+  {
+    _LayerEdge*       edgeF = *e;
+    const gp_XYZ     prevVF = edgeF->PrevPos() - prevPosV;
+    const gp_XYZ    newPosF = curPosV + prevVF;
+    SMDS_MeshNode* tgtNodeF = const_cast<SMDS_MeshNode*>( edgeF->_nodes.back() );
+    tgtNodeF->setXYZ( newPosF.X(), newPosF.Y(), newPosF.Z() );
+    edgeF->_pos.back() = newPosF;
+    dumpMoveComm( tgtNodeF, "MoveNearConcaVer" ); // debug
+
+    // set _curvature to make edgeF updated by putOnOffsetSurface()
+    if ( !edgeF->_curvature )
+      if (( fPos = dynamic_cast<SMDS_FacePosition*>( edgeF->_nodes[0]->GetPosition() )))
+      {
+        edgeF->_curvature = new _Curvature;
+        edgeF->_curvature->_r = 0;
+        edgeF->_curvature->_k = 0;
+        edgeF->_curvature->_h2lenRatio = 0;
+        edgeF->_curvature->_uv.SetCoord( fPos->GetUParameter(), fPos->GetVParameter() );
+      }
+  }
+  // gp_XYZ inflationVec( SMESH_TNodeXYZ( _nodes.back() ) -
+  //                      SMESH_TNodeXYZ( _nodes[0]    ));
+  // for ( set< _LayerEdge* >::iterator e = edges.begin(); e != edges.end(); ++e )
+  // {
+  //   _LayerEdge*      edgeF = *e;
+  //   gp_XYZ          newPos = SMESH_TNodeXYZ( edgeF->_nodes[0] ) + inflationVec;
+  //   SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( edgeF->_nodes.back() );
+  //   tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+  //   edgeF->_pos.back() = newPosF;
+  //   dumpMoveComm( tgtNode, "MoveNearConcaVer" ); // debug
+  // }
+
+  // smooth _LayerEdge's around moved nodes
+  //size_t nbBadBefore = badSmooEdges.size();
+  for ( set< _LayerEdge* >::iterator e = edges.begin(); e != edges.end(); ++e )
+  {
+    _LayerEdge* edgeF = *e;
+    for ( size_t j = 0; j < edgeF->_neibors.size(); ++j )
+      if ( edgeF->_neibors[j]->_nodes[0]->getshapeId() == eos->_shapeID )
+        //&& !edges.count( edgeF->_neibors[j] ))
+      {
+        _LayerEdge* edgeFN = edgeF->_neibors[j];
+        edgeFN->Unset( SMOOTHED );
+        int nbBad = edgeFN->Smooth( step, /*isConcaFace=*/true, /*findBest=*/true );
+        // if ( nbBad > 0 )
+        // {
+        //   gp_XYZ         newPos = SMESH_TNodeXYZ( edgeFN->_nodes[0] ) + inflationVec;
+        //   const gp_XYZ& prevPos = edgeFN->_pos[ edgeFN->_pos.size()-2 ];
+        //   int        nbBadAfter = edgeFN->_simplices.size();
+        //   double vol;
+        //   for ( size_t iS = 0; iS < edgeFN->_simplices.size(); ++iS )
+        //   {
+        //     nbBadAfter -= edgeFN->_simplices[iS].IsForward( &prevPos, &newPos, vol );
+        //   }
+        //   if ( nbBadAfter <= nbBad )
+        //   {
+        //     SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( edgeFN->_nodes.back() );
+        //     tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+        //     edgeF->_pos.back() = newPosF;
+        //     dumpMoveComm( tgtNode, "MoveNearConcaVer 2" ); // debug
+        //     nbBad = nbBadAfter;
+        //   }
+        // }
+        if ( nbBad > 0 )
+          badSmooEdges.push_back( edgeFN );
+      }
+  }
+    // move a bit not smoothed around moved nodes
+  //   for ( size_t i = nbBadBefore; i < badSmooEdges.size(); ++i )
+  //   {
+  //   _LayerEdge*      edgeF = badSmooEdges[i];
+  //   SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( edgeF->_nodes.back() );
+  //   gp_XYZ         newPos1 = SMESH_TNodeXYZ( edgeF->_nodes[0] ) + inflationVec;
+  //   gp_XYZ         newPos2 = 0.5 * ( newPos1 + SMESH_TNodeXYZ( tgtNode ));
+  //   tgtNode->setXYZ( newPos2.X(), newPos2.Y(), newPos2.Z() );
+  //   edgeF->_pos.back() = newPosF;
+  //   dumpMoveComm( tgtNode, "MoveNearConcaVer 2" ); // debug
+  // }
+}
+
+//================================================================================
+/*!
  * \brief Perform smooth of _LayerEdge's based on EDGE's
  *  \retval bool - true if node has been moved
  */
 //================================================================================
 
-bool _LayerEdge::SmoothOnEdge(Handle(Geom_Surface)& surface,
-                              const TopoDS_Face&    F,
-                              SMESH_MesherHelper&   helper)
+bool _LayerEdge::SmoothOnEdge(Handle(ShapeAnalysis_Surface)& surface,
+                              const TopoDS_Face&             F,
+                              SMESH_MesherHelper&            helper)
 {
   ASSERT( IsOnEdge() );
 
@@ -5450,70 +7388,296 @@ bool _LayerEdge::SmoothOnEdge(Handle(Geom_Surface)& surface,
     newPos.ChangeCoord() += _normal * lenDelta;
   }
 
-  distNewOld = newPos.Distance( oldPos );
+  distNewOld = newPos.Distance( oldPos );
+
+  if ( F.IsNull() )
+  {
+    if ( _2neibors->_plnNorm )
+    {
+      // put newPos on the plane defined by source node and _plnNorm
+      gp_XYZ new2src = SMESH_TNodeXYZ( _nodes[0] ) - newPos.XYZ();
+      double new2srcProj = (*_2neibors->_plnNorm) * new2src;
+      newPos.ChangeCoord() += (*_2neibors->_plnNorm) * new2srcProj;
+    }
+    tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+    _pos.back() = newPos.XYZ();
+  }
+  else
+  {
+    tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+    gp_XY uv( Precision::Infinite(), 0 );
+    helper.CheckNodeUV( F, tgtNode, uv, 1e-10, /*force=*/true );
+    _pos.back().SetCoord( uv.X(), uv.Y(), 0 );
+
+    newPos = surface->Value( uv );
+    tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
+  }
+
+  // commented for IPAL0052478
+  // if ( _curvature && lenDelta < 0 )
+  // {
+  //   gp_Pnt prevPos( _pos[ _pos.size()-2 ]);
+  //   _len -= prevPos.Distance( oldPos );
+  //   _len += prevPos.Distance( newPos );
+  // }
+  bool moved = distNewOld > dist01/50;
+  //if ( moved )
+  dumpMove( tgtNode ); // debug
+
+  return moved;
+}
+
+//================================================================================
+/*!
+ * \brief Perform 3D smooth of nodes inflated from FACE. No check of validity
+ */
+//================================================================================
+
+void _LayerEdge::SmoothWoCheck()
+{
+  if ( Is( DIFFICULT ))
+    return;
+
+  bool moved = Is( SMOOTHED );
+  for ( size_t i = 0; i < _neibors.size()  &&  !moved; ++i )
+    moved = _neibors[i]->Is( SMOOTHED );
+  if ( !moved )
+    return;
+
+  gp_XYZ newPos = (this->*_smooFunction)(); // fun chosen by ChooseSmooFunction()
+
+  SMDS_MeshNode* n = const_cast< SMDS_MeshNode* >( _nodes.back() );
+  n->setXYZ( newPos.X(), newPos.Y(), newPos.Z());
+  _pos.back() = newPos;
+
+  dumpMoveComm( n, SMESH_Comment("No check - ") << _funNames[ smooFunID() ]);
+}
+
+//================================================================================
+/*!
+ * \brief Checks validity of _neibors on EDGEs and VERTEXes
+ */
+//================================================================================
+
+int _LayerEdge::CheckNeiborsOnBoundary( vector< _LayerEdge* >* badNeibors )
+{
+  if ( ! Is( NEAR_BOUNDARY ))
+    return 0;
+
+  int nbBad = 0;
+  double vol;
+  for ( size_t iN = 0; iN < _neibors.size(); ++iN )
+  {
+    _LayerEdge* eN = _neibors[iN];
+    if ( eN->_nodes[0]->getshapeId() == _nodes[0]->getshapeId() )
+      continue;
+    SMESH_TNodeXYZ curPosN ( eN->_nodes.back() );
+    SMESH_TNodeXYZ prevPosN( eN->_nodes[0] );
+    for ( size_t i = 0; i < eN->_simplices.size(); ++i )
+      if ( eN->_nodes.size() > 1 &&
+           eN->_simplices[i].Includes( _nodes.back() ) &&
+           !eN->_simplices[i].IsForward( &prevPosN, &curPosN, vol ))
+      {
+        ++nbBad;
+        if ( badNeibors )
+        {
+          badNeibors->push_back( eN );
+          debugMsg("Bad boundary simplex ( "
+                   << " "<< eN->_nodes[0]->GetID()
+                   << " "<< eN->_nodes.back()->GetID()
+                   << " "<< eN->_simplices[i]._nPrev->GetID()
+                   << " "<< eN->_simplices[i]._nNext->GetID() << " )" );
+        }
+        else
+        {
+          break;
+        }
+      }
+  }
+  return nbBad;
+}
+
+//================================================================================
+/*!
+ * \brief Perform 'smart' 3D smooth of nodes inflated from FACE
+ *  \retval int - nb of bad simplices around this _LayerEdge
+ */
+//================================================================================
+
+int _LayerEdge::Smooth(const int step, bool findBest, vector< _LayerEdge* >& toSmooth )
+{
+  if ( !Is( MOVED ) || Is( SMOOTHED ))
+    return 0; // shape of simplices not changed
+  if ( _simplices.size() < 2 )
+    return 0; // _LayerEdge inflated along EDGE or FACE
+
+  if ( Is( DIFFICULT )) // || Is( ON_CONCAVE_FACE )
+    findBest = true;
+
+  const gp_XYZ& curPos  = _pos.back();
+  const gp_XYZ& prevPos = PrevCheckPos();
+
+  // quality metrics (orientation) of tetras around _tgtNode
+  int nbOkBefore = 0;
+  double vol, minVolBefore = 1e100;
+  for ( size_t i = 0; i < _simplices.size(); ++i )
+  {
+    nbOkBefore += _simplices[i].IsForward( &prevPos, &curPos, vol );
+    minVolBefore = Min( minVolBefore, vol );
+  }
+  int nbBad = _simplices.size() - nbOkBefore;
+
+  if ( nbBad == 0 )
+    nbBad = CheckNeiborsOnBoundary();
+  if ( nbBad > 0 )
+    Set( DISTORTED );
+
+  // evaluate min angle
+  if ( nbBad == 0 && !findBest )
+  {
+    size_t nbGoodAngles = _simplices.size();
+    double angle;
+    for ( size_t i = 0; i < _simplices.size(); ++i )
+    {
+      if ( !_simplices[i].IsMinAngleOK( curPos, angle ) && angle > _minAngle )
+        --nbGoodAngles;
+    }
+    if ( nbGoodAngles == _simplices.size() )
+    {
+      Unset( MOVED );
+      return 0;
+    }
+  }
+  if ( Is( ON_CONCAVE_FACE ))
+    findBest = true;
+
+  if ( step % 2 == 0 )
+    findBest = false;
+
+  if ( Is( ON_CONCAVE_FACE ) && !findBest ) // alternate FUN_CENTROIDAL and FUN_LAPLACIAN
+  {
+    if ( _smooFunction == _funs[ FUN_LAPLACIAN ] )
+      _smooFunction = _funs[ FUN_CENTROIDAL ];
+    else
+      _smooFunction = _funs[ FUN_LAPLACIAN ];
+  }
+
+  // compute new position for the last _pos using different _funs
+  gp_XYZ newPos;
+  bool moved = false;
+  for ( int iFun = -1; iFun < theNbSmooFuns; ++iFun )
+  {
+    if ( iFun < 0 )
+      newPos = (this->*_smooFunction)(); // fun chosen by ChooseSmooFunction()
+    else if ( _funs[ iFun ] == _smooFunction )
+      continue; // _smooFunction again
+    else if ( step > 1 )
+      newPos = (this->*_funs[ iFun ])(); // try other smoothing fun
+    else
+      break; // let "easy" functions improve elements around distorted ones
+
+    if ( _curvature )
+    {
+      double delta  = _curvature->lenDelta( _len );
+      if ( delta > 0 )
+        newPos += _normal * delta;
+      else
+      {
+        double segLen = _normal * ( newPos - prevPos );
+        if ( segLen + delta > 0 )
+          newPos += _normal * delta;
+      }
+      // double segLenChange = _normal * ( curPos - newPos );
+      // newPos += 0.5 * _normal * segLenChange;
+    }
+
+    int nbOkAfter = 0;
+    double minVolAfter = 1e100;
+    for ( size_t i = 0; i < _simplices.size(); ++i )
+    {
+      nbOkAfter += _simplices[i].IsForward( &prevPos, &newPos, vol );
+      minVolAfter = Min( minVolAfter, vol );
+    }
+    // get worse?
+    if ( nbOkAfter < nbOkBefore )
+      continue;
+
+    if (( findBest ) &&
+        ( nbOkAfter == nbOkBefore ) &&
+        ( minVolAfter <= minVolBefore ))
+      continue;
+
+    nbBad        = _simplices.size() - nbOkAfter;
+    minVolBefore = minVolAfter;
+    nbOkBefore   = nbOkAfter;
+    moved        = true;
+
+    SMDS_MeshNode* n = const_cast< SMDS_MeshNode* >( _nodes.back() );
+    n->setXYZ( newPos.X(), newPos.Y(), newPos.Z());
+    _pos.back() = newPos;
+
+    dumpMoveComm( n, SMESH_Comment( _funNames[ iFun < 0 ? smooFunID() : iFun ] )
+                  << (nbBad ? " --BAD" : ""));
 
-  if ( F.IsNull() )
-  {
-    if ( _2neibors->_plnNorm )
+    if ( iFun > -1 )
     {
-      // put newPos on the plane defined by source node and _plnNorm
-      gp_XYZ new2src = SMESH_TNodeXYZ( _nodes[0] ) - newPos.XYZ();
-      double new2srcProj = (*_2neibors->_plnNorm) * new2src;
-      newPos.ChangeCoord() += (*_2neibors->_plnNorm) * new2srcProj;
+      continue; // look for a better function
     }
-    tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
-    _pos.back() = newPos.XYZ();
-  }
-  else
-  {
-    tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
-    gp_XY uv( Precision::Infinite(), 0 );
-    helper.CheckNodeUV( F, tgtNode, uv, 1e-10, /*force=*/true );
-    _pos.back().SetCoord( uv.X(), uv.Y(), 0 );
 
-    newPos = surface->Value( uv.X(), uv.Y() );
-    tgtNode->setXYZ( newPos.X(), newPos.Y(), newPos.Z() );
-  }
+    if ( !findBest )
+      break;
 
-  // commented for IPAL0052478
-  // if ( _curvature && lenDelta < 0 )
-  // {
-  //   gp_Pnt prevPos( _pos[ _pos.size()-2 ]);
-  //   _len -= prevPos.Distance( oldPos );
-  //   _len += prevPos.Distance( newPos );
-  // }
-  bool moved = distNewOld > dist01/50;
-  //if ( moved )
-  dumpMove( tgtNode ); // debug
+  } // loop on smoothing functions
 
-  return moved;
+  if ( moved ) // notify _neibors
+  {
+    Set( SMOOTHED );
+    for ( size_t i = 0; i < _neibors.size(); ++i )
+      if ( !_neibors[i]->Is( MOVED ))
+      {
+        _neibors[i]->Set( MOVED );
+        toSmooth.push_back( _neibors[i] );
+      }
+  }
+
+  return nbBad;
 }
 
 //================================================================================
 /*!
- * \brief Perform laplacian smooth in 3D of nodes inflated from FACE
- *  \retval bool - true if _tgtNode has been moved
+ * \brief Perform 'smart' 3D smooth of nodes inflated from FACE
+ *  \retval int - nb of bad simplices around this _LayerEdge
  */
 //================================================================================
 
-int _LayerEdge::Smooth(const int step, const bool isConcaveFace, const bool findBest )
+int _LayerEdge::Smooth(const int step, const bool isConcaveFace, bool findBest )
 {
-  if ( _simplices.size() < 2 )
+  if ( !_smooFunction )
     return 0; // _LayerEdge inflated along EDGE or FACE
+  if ( Is( BLOCKED ))
+    return 0; // not inflated
 
-  const gp_XYZ& curPos ( _pos.back() );
-  const gp_XYZ& prevPos( _pos[ _pos.size()-2 ]);
+  const gp_XYZ& curPos  = _pos.back();
+  const gp_XYZ& prevPos = PrevCheckPos();
 
   // quality metrics (orientation) of tetras around _tgtNode
   int nbOkBefore = 0;
   double vol, minVolBefore = 1e100;
   for ( size_t i = 0; i < _simplices.size(); ++i )
   {
-    nbOkBefore += _simplices[i].IsForward( _nodes[0], &curPos, vol );
+    nbOkBefore += _simplices[i].IsForward( &prevPos, &curPos, vol );
     minVolBefore = Min( minVolBefore, vol );
   }
   int nbBad = _simplices.size() - nbOkBefore;
 
+  if ( isConcaveFace ) // alternate FUN_CENTROIDAL and FUN_LAPLACIAN
+  {
+    if      ( _smooFunction == _funs[ FUN_CENTROIDAL ] && step % 2 )
+      _smooFunction = _funs[ FUN_LAPLACIAN ];
+    else if ( _smooFunction == _funs[ FUN_LAPLACIAN ] && !( step % 2 ))
+      _smooFunction = _funs[ FUN_CENTROIDAL ];
+  }
+
   // compute new position for the last _pos using different _funs
   gp_XYZ newPos;
   for ( int iFun = -1; iFun < theNbSmooFuns; ++iFun )
@@ -5522,7 +7686,7 @@ int _LayerEdge::Smooth(const int step, const bool isConcaveFace, const bool find
       newPos = (this->*_smooFunction)(); // fun chosen by ChooseSmooFunction()
     else if ( _funs[ iFun ] == _smooFunction )
       continue; // _smooFunction again
-    else if ( step > 0 )
+    else if ( step > 1 )
       newPos = (this->*_funs[ iFun ])(); // try other smoothing fun
     else
       break; // let "easy" functions improve elements around distorted ones
@@ -5546,7 +7710,7 @@ int _LayerEdge::Smooth(const int step, const bool isConcaveFace, const bool find
     double minVolAfter = 1e100;
     for ( size_t i = 0; i < _simplices.size(); ++i )
     {
-      nbOkAfter += _simplices[i].IsForward( _nodes[0], &newPos, vol );
+      nbOkAfter += _simplices[i].IsForward( &prevPos, &newPos, vol );
       minVolAfter = Min( minVolAfter, vol );
     }
     // get worse?
@@ -5554,23 +7718,26 @@ int _LayerEdge::Smooth(const int step, const bool isConcaveFace, const bool find
       continue;
     if (( isConcaveFace || findBest ) &&
         ( nbOkAfter == nbOkBefore ) &&
-        //( iFun > -1 || nbOkAfter < _simplices.size() ) &&
-        ( minVolAfter <= minVolBefore ))
+        ( minVolAfter <= minVolBefore )
+        )
       continue;
 
+    nbBad        = _simplices.size() - nbOkAfter;
+    minVolBefore = minVolAfter;
+    nbOkBefore   = nbOkAfter;
+
     SMDS_MeshNode* n = const_cast< SMDS_MeshNode* >( _nodes.back() );
+    n->setXYZ( newPos.X(), newPos.Y(), newPos.Z());
+    _pos.back() = newPos;
+
+    dumpMoveComm( n, SMESH_Comment( _funNames[ iFun < 0 ? smooFunID() : iFun ] )
+                  << ( nbBad ? "--BAD" : ""));
 
     // commented for IPAL0052478
     // _len -= prevPos.Distance(SMESH_TNodeXYZ( n ));
     // _len += prevPos.Distance(newPos);
 
-    n->setXYZ( newPos.X(), newPos.Y(), newPos.Z());
-    _pos.back() = newPos;
-    dumpMoveComm( n, _funNames[ iFun < 0 ? smooFunID() : iFun ]);
-
-    nbBad = _simplices.size() - nbOkAfter;
-
-    if ( iFun > -1 )
+    if ( iFun > -1 ) // findBest || the chosen _fun makes worse
     {
       //_smooFunction = _funs[ iFun ];
       // cout << "# " << _funNames[ iFun ] << "\t N:" << _nodes.back()->GetID()
@@ -5578,8 +7745,6 @@ int _LayerEdge::Smooth(const int step, const bool isConcaveFace, const bool find
       // << " minVol: " << minVolAfter
       // << " " << newPos.X() << " " << newPos.Y() << " " << newPos.Z()
       // << endl;
-      minVolBefore = minVolAfter;
-      nbOkBefore = nbOkAfter;
       continue; // look for a better function
     }
 
@@ -5606,6 +7771,10 @@ void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
   // use smoothNefPolygon() near concaveVertices
   if ( !concaveVertices.empty() )
   {
+    _smooFunction = _funs[ FUN_CENTROIDAL ];
+
+    Set( ON_CONCAVE_FACE );
+
     for ( size_t i = 0; i < _simplices.size(); ++i )
     {
       if ( concaveVertices.count( _simplices[i]._nPrev->getshapeId() ))
@@ -5613,39 +7782,36 @@ void _LayerEdge::ChooseSmooFunction( const set< TGeomID >& concaveVertices,
         _smooFunction = _funs[ FUN_NEFPOLY ];
 
         // set FUN_CENTROIDAL to neighbor edges
-        TNode2Edge::const_iterator n2e;
-        for ( i = 0; i < _simplices.size(); ++i )
+        for ( i = 0; i < _neibors.size(); ++i )
         {
-          if (( _simplices[i]._nPrev->GetPosition()->GetDim() == 2 ) &&
-              (( n2e = n2eMap.find( _simplices[i]._nPrev )) != n2eMap.end() ))
+          if ( _neibors[i]->_nodes[0]->GetPosition()->GetDim() == 2 )
           {
-            n2e->second->_smooFunction = _funs[ FUN_CENTROIDAL ];
+            _neibors[i]->_smooFunction = _funs[ FUN_CENTROIDAL ];
           }
         }
         return;
       }
     }
-    //}
 
-    // this coice is done only if ( !concaveVertices.empty() ) for Grids/smesh/bugs_19/X1
-    // where the nodes are smoothed too far along a sphere thus creating
-    // inverted _simplices
-    double dist[theNbSmooFuns];
-    //double coef[theNbSmooFuns] = { 1., 1.2, 1.4, 1.4 };
-    double coef[theNbSmooFuns] = { 1., 1., 1., 1. };
+    // // this coice is done only if ( !concaveVertices.empty() ) for Grids/smesh/bugs_19/X1
+    // // where the nodes are smoothed too far along a sphere thus creating
+    // // inverted _simplices
+    // double dist[theNbSmooFuns];
+    // //double coef[theNbSmooFuns] = { 1., 1.2, 1.4, 1.4 };
+    // double coef[theNbSmooFuns] = { 1., 1., 1., 1. };
 
-    double minDist = Precision::Infinite();
-    gp_Pnt p = SMESH_TNodeXYZ( _nodes[0] );
-    for ( int i = 0; i < FUN_NEFPOLY; ++i )
-    {
-      gp_Pnt newP = (this->*_funs[i])();
-      dist[i] = p.SquareDistance( newP );
-      if ( dist[i]*coef[i] < minDist )
-      {
-        _smooFunction = _funs[i];
-        minDist = dist[i]*coef[i];
-      }
-    }
+    // double minDist = Precision::Infinite();
+    // gp_Pnt p = SMESH_TNodeXYZ( _nodes[0] );
+    // for ( int i = 0; i < FUN_NEFPOLY; ++i )
+    // {
+    //   gp_Pnt newP = (this->*_funs[i])();
+    //   dist[i] = p.SquareDistance( newP );
+    //   if ( dist[i]*coef[i] < minDist )
+    //   {
+    //     _smooFunction = _funs[i];
+    //     minDist = dist[i]*coef[i];
+    //   }
+    // }
   }
   else
   {
@@ -5714,9 +7880,9 @@ gp_XYZ _LayerEdge::smoothLaplacian()
 
 gp_XYZ _LayerEdge::smoothAngular()
 {
-  vector< gp_Vec > edgeDir;  edgeDir. reserve( _simplices.size() + 1);
-  vector< double > edgeSize; edgeSize.reserve( _simplices.size() );
-  vector< gp_XYZ > points;   points.  reserve( _simplices.size() );
+  vector< gp_Vec > edgeDir;  edgeDir. reserve( _simplices.size() + 1 );
+  vector< double > edgeSize; edgeSize.reserve( _simplices.size()     );
+  vector< gp_XYZ > points;   points.  reserve( _simplices.size() + 1 );
 
   gp_XYZ pPrev = SMESH_TNodeXYZ( _simplices.back()._nPrev );
   gp_XYZ pN( 0,0,0 );
@@ -5725,7 +7891,6 @@ gp_XYZ _LayerEdge::smoothAngular()
     gp_XYZ p = SMESH_TNodeXYZ( _simplices[i]._nPrev );
     edgeDir.push_back( p - pPrev );
     edgeSize.push_back( edgeDir.back().Magnitude() );
-    //double edgeSize = edgeDir.back().Magnitude();
     if ( edgeSize.back() < numeric_limits<double>::min() )
     {
       edgeDir.pop_back();
@@ -5744,18 +7909,17 @@ gp_XYZ _LayerEdge::smoothAngular()
   pN /= points.size();
 
   gp_XYZ newPos(0,0,0);
-  //gp_XYZ pN = SMESH_TNodeXYZ( _nodes.back() );
   double sumSize = 0;
   for ( size_t i = 0; i < points.size(); ++i )
   {
-    gp_Vec toN( pN - points[i]);
+    gp_Vec toN    = pN - points[i];
     double toNLen = toN.Magnitude();
     if ( toNLen < numeric_limits<double>::min() )
     {
       newPos += pN;
       continue;
     }
-    gp_Vec bisec = edgeDir[i] + edgeDir[i+1];
+    gp_Vec bisec    = edgeDir[i] + edgeDir[i+1];
     double bisecLen = bisec.SquareMagnitude();
     if ( bisecLen < numeric_limits<double>::min() )
     {
@@ -5767,7 +7931,6 @@ gp_XYZ _LayerEdge::smoothAngular()
     bisec /= bisecLen;
 
 #if 1
-    //bisecLen = 1.;
     gp_XYZ pNew = ( points[i] + bisec.XYZ() * toNLen ) * bisecLen;
     sumSize += bisecLen;
 #else
@@ -5778,6 +7941,29 @@ gp_XYZ _LayerEdge::smoothAngular()
   }
   newPos /= sumSize;
 
+  // project newPos to an average plane
+
+  gp_XYZ norm(0,0,0); // plane normal
+  points.push_back( points[0] );
+  for ( size_t i = 1; i < points.size(); ++i )
+  {
+    gp_XYZ vec1 = points[ i-1 ] - pN;
+    gp_XYZ vec2 = points[ i   ] - pN;
+    gp_XYZ cross = vec1 ^ vec2;
+    try {
+      cross.Normalize();
+      if ( cross * norm < numeric_limits<double>::min() )
+        norm += cross.Reversed();
+      else
+        norm += cross;
+    }
+    catch (Standard_Failure) { // if |cross| == 0.
+    }
+  }
+  gp_XYZ vec = newPos - pN;
+  double r   = ( norm * vec ) / norm.SquareModulus();  // param [0,1] on norm
+  newPos     = newPos - r * norm;
+
   return newPos;
 }
 
@@ -5853,27 +8039,229 @@ gp_XYZ _LayerEdge::smoothCentroidal()
 //================================================================================
 
 gp_XYZ _LayerEdge::smoothNefPolygon()
+#ifdef OLD_NEF_POLYGON
 {
   gp_XYZ newPos(0,0,0);
 
   // get a plane to seach a solution on
 
-  vector< gp_XYZ > vecs( _simplices.size() + 1 );
+  vector< gp_XYZ > vecs( _simplices.size() + 1 );
+  size_t i;
+  const double tol = numeric_limits<double>::min();
+  gp_XYZ center(0,0,0);
+  for ( i = 0; i < _simplices.size(); ++i )
+  {
+    vecs[i] = ( SMESH_TNodeXYZ( _simplices[i]._nNext ) -
+                SMESH_TNodeXYZ( _simplices[i]._nPrev ));
+    center += SMESH_TNodeXYZ( _simplices[i]._nPrev );
+  }
+  vecs.back() = vecs[0];
+  center /= _simplices.size();
+
+  gp_XYZ zAxis(0,0,0);
+  for ( i = 0; i < _simplices.size(); ++i )
+    zAxis += vecs[i] ^ vecs[i+1];
+
+  gp_XYZ yAxis;
+  for ( i = 0; i < _simplices.size(); ++i )
+  {
+    yAxis = vecs[i];
+    if ( yAxis.SquareModulus() > tol )
+      break;
+  }
+  gp_XYZ xAxis = yAxis ^ zAxis;
+  // SMESH_TNodeXYZ p0( _simplices[0]._nPrev );
+  // const double tol = 1e-6 * ( p0.Distance( _simplices[1]._nPrev ) +
+  //                             p0.Distance( _simplices[2]._nPrev ));
+  // gp_XYZ center = smoothLaplacian();
+  // gp_XYZ xAxis, yAxis, zAxis;
+  // for ( i = 0; i < _simplices.size(); ++i )
+  // {
+  //   xAxis = SMESH_TNodeXYZ( _simplices[i]._nPrev ) - center;
+  //   if ( xAxis.SquareModulus() > tol*tol )
+  //     break;
+  // }
+  // for ( i = 1; i < _simplices.size(); ++i )
+  // {
+  //   yAxis = SMESH_TNodeXYZ( _simplices[i]._nPrev ) - center;
+  //   zAxis = xAxis ^ yAxis;
+  //   if ( zAxis.SquareModulus() > tol*tol )
+  //     break;
+  // }
+  // if ( i == _simplices.size() ) return newPos;
+
+  yAxis = zAxis ^ xAxis;
+  xAxis /= xAxis.Modulus();
+  yAxis /= yAxis.Modulus();
+
+  // get half-planes of _simplices
+
+  vector< _halfPlane > halfPlns( _simplices.size() );
+  int nbHP = 0;
+  for ( size_t i = 0; i < _simplices.size(); ++i )
+  {
+    gp_XYZ OP1 = SMESH_TNodeXYZ( _simplices[i]._nPrev ) - center;
+    gp_XYZ OP2 = SMESH_TNodeXYZ( _simplices[i]._nNext ) - center;
+    gp_XY  p1( OP1 * xAxis, OP1 * yAxis );
+    gp_XY  p2( OP2 * xAxis, OP2 * yAxis );
+    gp_XY  vec12 = p2 - p1;
+    double dist12 = vec12.Modulus();
+    if ( dist12 < tol )
+      continue;
+    vec12 /= dist12;
+    halfPlns[ nbHP ]._pos = p1;
+    halfPlns[ nbHP ]._dir = vec12;
+    halfPlns[ nbHP ]._inNorm.SetCoord( -vec12.Y(), vec12.X() );
+    ++nbHP;
+  }
+
+  // intersect boundaries of half-planes, define state of intersection points
+  // in relation to all half-planes and calculate internal point of a 2D polygon
+
+  double sumLen = 0;
+  gp_XY newPos2D (0,0);
+
+  enum { UNDEF = -1, NOT_OUT, IS_OUT, NO_INT };
+  typedef std::pair< gp_XY, int > TIntPntState; // coord and isOut state
+  TIntPntState undefIPS( gp_XY(1e100,1e100), UNDEF );
+
+  vector< vector< TIntPntState > > allIntPnts( nbHP );
+  for ( int iHP1 = 0; iHP1 < nbHP; ++iHP1 )
+  {
+    vector< TIntPntState > & intPnts1 = allIntPnts[ iHP1 ];
+    if ( intPnts1.empty() ) intPnts1.resize( nbHP, undefIPS );
+
+    int iPrev = SMESH_MesherHelper::WrapIndex( iHP1 - 1, nbHP );
+    int iNext = SMESH_MesherHelper::WrapIndex( iHP1 + 1, nbHP );
+
+    int nbNotOut = 0;
+    const gp_XY* segEnds[2] = { 0, 0 }; // NOT_OUT points
+
+    for ( int iHP2 = 0; iHP2 < nbHP; ++iHP2 )
+    {
+      if ( iHP1 == iHP2 ) continue;
+
+      TIntPntState & ips1 = intPnts1[ iHP2 ];
+      if ( ips1.second == UNDEF )
+      {
+        // find an intersection point of boundaries of iHP1 and iHP2
+
+        if ( iHP2 == iPrev ) // intersection with neighbors is known
+          ips1.first = halfPlns[ iHP1 ]._pos;
+        else if ( iHP2 == iNext )
+          ips1.first = halfPlns[ iHP2 ]._pos;
+        else if ( !halfPlns[ iHP1 ].FindIntersection( halfPlns[ iHP2 ], ips1.first ))
+          ips1.second = NO_INT;
+
+        // classify the found intersection point
+        if ( ips1.second != NO_INT )
+        {
+          ips1.second = NOT_OUT;
+          for ( int i = 0; i < nbHP && ips1.second == NOT_OUT; ++i )
+            if ( i != iHP1 && i != iHP2 &&
+                 halfPlns[ i ].IsOut( ips1.first, tol ))
+              ips1.second = IS_OUT;
+        }
+        vector< TIntPntState > & intPnts2 = allIntPnts[ iHP2 ];
+        if ( intPnts2.empty() ) intPnts2.resize( nbHP, undefIPS );
+        TIntPntState & ips2 = intPnts2[ iHP1 ];
+        ips2 = ips1;
+      }
+      if ( ips1.second == NOT_OUT )
+      {
+        ++nbNotOut;
+        segEnds[ bool(segEnds[0]) ] = & ips1.first;
+      }
+    }
+
+    // find a NOT_OUT segment of boundary which is located between
+    // two NOT_OUT int points
+
+    if ( nbNotOut < 2 )
+      continue; // no such a segment
+
+    if ( nbNotOut > 2 )
+    {
+      // sort points along the boundary
+      map< double, TIntPntState* > ipsByParam;
+      for ( int iHP2 = 0; iHP2 < nbHP; ++iHP2 )
+      {
+        TIntPntState & ips1 = intPnts1[ iHP2 ];
+        if ( ips1.second != NO_INT )
+        {
+          gp_XY     op = ips1.first - halfPlns[ iHP1 ]._pos;
+          double param = op * halfPlns[ iHP1 ]._dir;
+          ipsByParam.insert( make_pair( param, & ips1 ));
+        }
+      }
+      // look for two neighboring NOT_OUT points
+      nbNotOut = 0;
+      map< double, TIntPntState* >::iterator u2ips = ipsByParam.begin();
+      for ( ; u2ips != ipsByParam.end(); ++u2ips )
+      {
+        TIntPntState & ips1 = *(u2ips->second);
+        if ( ips1.second == NOT_OUT )
+          segEnds[ bool( nbNotOut++ ) ] = & ips1.first;
+        else if ( nbNotOut >= 2 )
+          break;
+        else
+          nbNotOut = 0;
+      }
+    }
+
+    if ( nbNotOut >= 2 )
+    {
+      double len = ( *segEnds[0] - *segEnds[1] ).Modulus();
+      sumLen += len;
+
+      newPos2D += 0.5 * len * ( *segEnds[0] + *segEnds[1] );
+    }
+  }
+
+  if ( sumLen > 0 )
+  {
+    newPos2D /= sumLen;
+    newPos = center + xAxis * newPos2D.X() + yAxis * newPos2D.Y();
+  }
+  else
+  {
+    newPos = center;
+  }
+
+  return newPos;
+}
+#else // OLD_NEF_POLYGON
+{ ////////////////////////////////// NEW
+  gp_XYZ newPos(0,0,0);
+
+  // get a plane to seach a solution on
+
   size_t i;
-  const double tol = numeric_limits<double>::min();
   gp_XYZ center(0,0,0);
   for ( i = 0; i < _simplices.size(); ++i )
-  {
-    vecs[i] = ( SMESH_TNodeXYZ( _simplices[i]._nNext ) -
-                SMESH_TNodeXYZ( _simplices[i]._nPrev ));
     center += SMESH_TNodeXYZ( _simplices[i]._nPrev );
-  }
-  vecs.back() = vecs[0];
   center /= _simplices.size();
 
+  vector< gp_XYZ > vecs( _simplices.size() + 1 );
+  for ( i = 0; i < _simplices.size(); ++i )
+    vecs[i] = SMESH_TNodeXYZ( _simplices[i]._nPrev ) - center;
+  vecs.back() = vecs[0];
+
+  const double tol = numeric_limits<double>::min();
   gp_XYZ zAxis(0,0,0);
   for ( i = 0; i < _simplices.size(); ++i )
-    zAxis += vecs[i] ^ vecs[i+1];
+  {
+    gp_XYZ cross = vecs[i] ^ vecs[i+1];
+    try {
+      cross.Normalize();
+      if ( cross * zAxis < tol )
+        zAxis += cross.Reversed();
+      else
+        zAxis += cross;
+    }
+    catch (Standard_Failure) { // if |cross| == 0.
+    }
+  }
 
   gp_XYZ yAxis;
   for ( i = 0; i < _simplices.size(); ++i )
@@ -5913,8 +8301,8 @@ gp_XYZ _LayerEdge::smoothNefPolygon()
   int nbHP = 0;
   for ( size_t i = 0; i < _simplices.size(); ++i )
   {
-    gp_XYZ OP1 = SMESH_TNodeXYZ( _simplices[i]._nPrev ) - center;
-    gp_XYZ OP2 = SMESH_TNodeXYZ( _simplices[i]._nNext ) - center;
+    const gp_XYZ& OP1 = vecs[ i   ];
+    const gp_XYZ& OP2 = vecs[ i+1 ];
     gp_XY  p1( OP1 * xAxis, OP1 * yAxis );
     gp_XY  p2( OP2 * xAxis, OP2 * yAxis );
     gp_XY  vec12 = p2 - p1;
@@ -5963,7 +8351,7 @@ gp_XYZ _LayerEdge::smoothNefPolygon()
           ips1.first = halfPlns[ iHP1 ]._pos;
         else if ( iHP2 == iNext )
           ips1.first = halfPlns[ iHP2 ]._pos;
-        else if ( !halfPlns[ iHP1 ].FindInterestion( halfPlns[ iHP2 ], ips1.first ))
+        else if ( !halfPlns[ iHP1 ].FindIntersection( halfPlns[ iHP2 ], ips1.first ))
           ips1.second = NO_INT;
 
         // classify the found intersection point
@@ -6043,6 +8431,7 @@ gp_XYZ _LayerEdge::smoothNefPolygon()
 
   return newPos;
 }
+#endif // OLD_NEF_POLYGON
 
 //================================================================================
 /*!
@@ -6052,9 +8441,18 @@ gp_XYZ _LayerEdge::smoothNefPolygon()
 
 void _LayerEdge::SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelper& helper )
 {
-  if ( _len - len > -1e-6 )
+  if ( Is( BLOCKED ))
+    return;
+
+  if ( len > _maxLen )
+  {
+    len = _maxLen;
+    Block( eos.GetData() );
+  }
+  const double lenDelta = len - _len;
+  if ( lenDelta < len * 1e-3  )
   {
-    //_pos.push_back( _pos.back() );
+    Block( eos.GetData() );
     return;
   }
 
@@ -6073,36 +8471,37 @@ void _LayerEdge::SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelpe
         continue;
 
       // translate plane of a face
-      gp_XYZ baryCenter = oldXYZ + faceNorm.XYZ() * ( len - _len );
+      gp_XYZ baryCenter = oldXYZ + faceNorm.XYZ() * lenDelta;
 
       // find point of intersection of the face plane located at baryCenter
       // and _normal located at newXYZ
       double d    = -( faceNorm.XYZ() * baryCenter ); // d of plane equation ax+by+cz+d=0
       double dot  = ( faceNorm.XYZ() * _normal );
       if ( dot < std::numeric_limits<double>::min() )
-        dot = ( len - _len ) * 1e-3;
+        dot = lenDelta * 1e-3;
       double step = -( faceNorm.XYZ() * newXYZ + d ) / dot;
       newXYZ += step * _normal;
     }
   }
   else
   {
-    newXYZ = oldXYZ + _normal * ( len - _len ) * _lenFactor;
+    newXYZ = oldXYZ + _normal * lenDelta * _lenFactor;
   }
-  n->setXYZ( newXYZ.X(), newXYZ.Y(), newXYZ.Z() );
 
+  n->setXYZ( newXYZ.X(), newXYZ.Y(), newXYZ.Z() );
   _pos.push_back( newXYZ );
-  _len = len;
 
   if ( !eos._sWOL.IsNull() )
   {
     double distXYZ[4];
+    bool uvOK = false;
     if ( eos.SWOLType() == TopAbs_EDGE )
     {
       double u = Precision::Infinite(); // to force projection w/o distance check
-      helper.CheckNodeU( TopoDS::Edge( eos._sWOL ), n, u, 1e-10, /*force=*/true, distXYZ );
+      uvOK = helper.CheckNodeU( TopoDS::Edge( eos._sWOL ), n, u,
+                                /*tol=*/2*lenDelta, /*force=*/true, distXYZ );
       _pos.back().SetCoord( u, 0, 0 );
-      if ( _nodes.size() > 1 )
+      if ( _nodes.size() > 1 && uvOK )
       {
         SMDS_EdgePosition* pos = static_cast<SMDS_EdgePosition*>( n->GetPosition() );
         pos->SetUParameter( u );
@@ -6111,36 +8510,107 @@ void _LayerEdge::SetNewLength( double len, _EdgesOnShape& eos, SMESH_MesherHelpe
     else //  TopAbs_FACE
     {
       gp_XY uv( Precision::Infinite(), 0 );
-      helper.CheckNodeUV( TopoDS::Face( eos._sWOL ), n, uv, 1e-10, /*force=*/true, distXYZ );
+      uvOK = helper.CheckNodeUV( TopoDS::Face( eos._sWOL ), n, uv,
+                                 /*tol=*/2*lenDelta, /*force=*/true, distXYZ );
       _pos.back().SetCoord( uv.X(), uv.Y(), 0 );
-      if ( _nodes.size() > 1 )
+      if ( _nodes.size() > 1 && uvOK )
       {
         SMDS_FacePosition* pos = static_cast<SMDS_FacePosition*>( n->GetPosition() );
         pos->SetUParameter( uv.X() );
         pos->SetVParameter( uv.Y() );
       }
     }
-    n->setXYZ( distXYZ[1], distXYZ[2], distXYZ[3]);
+    if ( uvOK )
+    {
+      n->setXYZ( distXYZ[1], distXYZ[2], distXYZ[3]);
+    }
+    else
+    {
+      n->setXYZ( oldXYZ.X(), oldXYZ.Y(), oldXYZ.Z() );
+      _pos.pop_back();
+      Block( eos.GetData() );
+      return;
+    }
+  }
+
+  _len = len;
+
+  // notify _neibors
+  if ( eos.ShapeType() != TopAbs_FACE )
+  {
+    for ( size_t i = 0; i < _neibors.size(); ++i )
+      //if (  _len > _neibors[i]->GetSmooLen() )
+        _neibors[i]->Set( MOVED );
+
+    Set( MOVED );
   }
   dumpMove( n ); //debug
 }
 
 //================================================================================
 /*!
- * \brief Remove last inflation step
+ * \brief Set BLOCKED flag and propagate limited _maxLen to _neibors
  */
 //================================================================================
 
-void _LayerEdge::InvalidateStep( int curStep, const _EdgesOnShape& eos, bool restoreLength )
+void _LayerEdge::Block( _SolidData& data )
 {
-  if ( _pos.size() > curStep )
+  if ( Is( BLOCKED )) return;
+  Set( BLOCKED );
+
+  _maxLen = _len;
+  std::queue<_LayerEdge*> queue;
+  queue.push( this );
+
+  gp_Pnt pSrc, pTgt, pSrcN, pTgtN;
+  while ( !queue.empty() )
   {
-    if ( restoreLength )
-      _len -= ( _pos[ curStep-1 ] - _pos.back() ).Modulus();
+    _LayerEdge* edge = queue.front(); queue.pop();
+    pSrc = SMESH_TNodeXYZ( edge->_nodes[0] );
+    pTgt = SMESH_TNodeXYZ( edge->_nodes.back() );
+    for ( size_t iN = 0; iN < edge->_neibors.size(); ++iN )
+    {
+      _LayerEdge* neibor = edge->_neibors[iN];
+      if ( neibor->Is( BLOCKED ) ||
+           neibor->_maxLen < edge->_maxLen )
+        continue;
+      pSrcN = SMESH_TNodeXYZ( neibor->_nodes[0] );
+      pTgtN = SMESH_TNodeXYZ( neibor->_nodes.back() );
+      double minDist = pSrc.SquareDistance( pSrcN );
+      minDist   = Min( pTgt.SquareDistance( pTgtN ), minDist );
+      minDist   = Min( pSrc.SquareDistance( pTgtN ), minDist );
+      minDist   = Min( pTgt.SquareDistance( pSrcN ), minDist );
+      double newMaxLen = edge->_maxLen + 0.5 * Sqrt( minDist );
+      if ( neibor->_maxLen > newMaxLen )
+      {
+        neibor->_maxLen = newMaxLen;
+        if ( neibor->_maxLen < neibor->_len )
+        {
+          _EdgesOnShape* eos = data.GetShapeEdges( neibor );
+          neibor->InvalidateStep( neibor->NbSteps(), *eos, /*restoreLength=*/true );
+          neibor->SetNewLength( neibor->_maxLen, *eos, data.GetHelper() );
+        }
+        queue.push( neibor );
+      }
+    }
+  }
+}
+
+//================================================================================
+/*!
+ * \brief Remove last inflation step
+ */
+//================================================================================
 
+void _LayerEdge::InvalidateStep( size_t curStep, const _EdgesOnShape& eos, bool restoreLength )
+{
+  if ( _pos.size() > curStep && _nodes.size() > 1 )
+  {
     _pos.resize( curStep );
-    gp_Pnt nXYZ = _pos.back();
+
+    gp_Pnt      nXYZ = _pos.back();
     SMDS_MeshNode* n = const_cast< SMDS_MeshNode*>( _nodes.back() );
+    SMESH_TNodeXYZ curXYZ( n );
     if ( !eos._sWOL.IsNull() )
     {
       TopLoc_Location loc;
@@ -6163,6 +8633,61 @@ void _LayerEdge::InvalidateStep( int curStep, const _EdgesOnShape& eos, bool res
     }
     n->setXYZ( nXYZ.X(), nXYZ.Y(), nXYZ.Z() );
     dumpMove( n );
+
+    if ( restoreLength )
+      _len -= ( nXYZ.XYZ() - curXYZ ).Modulus() / _lenFactor;
+  }
+}
+
+//================================================================================
+/*!
+ * \brief Smooth a path formed by _pos of a _LayerEdge smoothed on FACE
+ */
+//================================================================================
+
+void _LayerEdge::SmoothPos( const vector< double >& segLen, const double tol )
+{
+  //return;
+  if ( Is( NORMAL_UPDATED ) || _pos.size() <= 2 )
+    return;
+
+  // find the 1st smoothed _pos
+  int iSmoothed = 0;
+  for ( size_t i = 1; i < _pos.size() && !iSmoothed; ++i )
+  {
+    double normDist = ( _pos[i] - _pos[0] ).Crossed( _normal ).SquareModulus();
+    if ( normDist > tol * tol )
+      iSmoothed = i;
+  }
+  if ( !iSmoothed ) return;
+
+  if ( 1 || Is( DISTORTED ))
+  {
+    // if ( segLen[ iSmoothed ] / segLen.back() < 0.5 )
+    //   return;
+    for ( size_t i = Max( 1, iSmoothed-1 ); i < _pos.size()-1; ++i )
+    {
+      gp_XYZ midPos = 0.5 * ( _pos[i-1] + _pos[i+1] );
+      gp_XYZ newPos = 0.5 * ( midPos + _pos[i] );
+      _pos[i] = newPos;
+      double midLen = 0.5 * ( segLen[i-1] + segLen[i+1] );
+      double newLen = 0.5 * ( midLen + segLen[i] );
+      const_cast< double& >( segLen[i] ) = newLen;
+    }
+  }
+  else
+  {
+    for ( size_t i = 1; i < _pos.size()-1; ++i )
+    {
+      if ((int) i < iSmoothed  &&  ( segLen[i] / segLen.back() < 0.5 ))
+        continue;
+
+      double     wgt = segLen[i] / segLen.back();
+      gp_XYZ normPos = _pos[0] + _normal * wgt * _len;
+      gp_XYZ tgtPos  = ( 1 - wgt ) * _pos[0] +  wgt * _pos.back();
+      gp_XYZ newPos  = ( 1 - wgt ) * normPos +  wgt * tgtPos;
+      _pos[i] = newPos;
+    }
   }
 }
 
@@ -6174,18 +8699,17 @@ void _LayerEdge::InvalidateStep( int curStep, const _EdgesOnShape& eos, bool res
 
 bool _ViscousBuilder::refine(_SolidData& data)
 {
-  SMESH_MesherHelper helper( *_mesh );
-  helper.SetSubShape( data._solid );
+  SMESH_MesherHelper& helper = data.GetHelper();
   helper.SetElementsOnShape(false);
 
   Handle(Geom_Curve) curve;
-  Handle(Geom_Surface) surface;
+  Handle(ShapeAnalysis_Surface) surface;
   TopoDS_Edge geomEdge;
   TopoDS_Face geomFace;
-  TopoDS_Shape prevSWOL;
   TopLoc_Location loc;
   double f,l, u;
   gp_XY uv;
+  vector< gp_XYZ > pos3D;
   bool isOnEdge;
   TGeomID prevBaseId = -1;
   TNode2Edge* n2eMap = 0;
@@ -6201,15 +8725,138 @@ bool _ViscousBuilder::refine(_SolidData& data)
     if ( eos._edges[0]->_nodes.size() < 2 )
       continue; // on _noShrinkShapes
 
+    // get data of a shrink shape
+    isOnEdge = false;
+    geomEdge.Nullify(); geomFace.Nullify();
+    curve.Nullify(); surface.Nullify();
+    if ( !eos._sWOL.IsNull() )
+    {
+      isOnEdge = ( eos.SWOLType() == TopAbs_EDGE );
+      if ( isOnEdge )
+      {
+        geomEdge = TopoDS::Edge( eos._sWOL );
+        curve    = BRep_Tool::Curve( geomEdge, loc, f,l);
+      }
+      else
+      {
+        geomFace = TopoDS::Face( eos._sWOL );
+        surface  = helper.GetSurface( geomFace );
+      }
+    }
+    else if ( eos.ShapeType() == TopAbs_FACE && eos._toSmooth )
+    {
+      geomFace = TopoDS::Face( eos._shape );
+      surface  = helper.GetSurface( geomFace );
+      // propagate _toSmooth back to _eosC1, which was unset in findShapesToSmooth()
+      for ( size_t i = 0; i < eos._eosC1.size(); ++i )
+      {
+        eos._eosC1[ i ]->_toSmooth = true;
+        for ( size_t j = 0; j < eos._eosC1[i]->_edges.size(); ++j )
+          eos._eosC1[i]->_edges[j]->Set( _LayerEdge::SMOOTHED_C1 );
+      }
+    }
+
+    vector< double > segLen;
     for ( size_t i = 0; i < eos._edges.size(); ++i )
     {
       _LayerEdge& edge = *eos._edges[i];
+      if ( edge._pos.size() < 2 )
+        continue;
 
       // get accumulated length of segments
-      vector< double > segLen( edge._pos.size() );
+      segLen.resize( edge._pos.size() );
       segLen[0] = 0.0;
-      for ( size_t j = 1; j < edge._pos.size(); ++j )
-        segLen[j] = segLen[j-1] + (edge._pos[j-1] - edge._pos[j] ).Modulus();
+      if ( eos._sWOL.IsNull() )
+      {
+        bool useNormal = true;
+        bool   usePos  = false;
+        bool smoothed  = false;
+        const double preci = 0.1 * edge._len;
+        if ( eos._toSmooth )
+        {
+          gp_Pnt tgtExpected = edge._pos[0] + edge._normal * edge._len;
+          smoothed = tgtExpected.SquareDistance( edge._pos.back() ) > preci * preci;
+        }
+        if ( smoothed )
+        {
+          if ( !surface.IsNull() &&
+               !data._convexFaces.count( eos._shapeID )) // edge smoothed on FACE
+          {
+            useNormal = usePos = false;
+            gp_Pnt2d uv = helper.GetNodeUV( geomFace, edge._nodes[0] );
+            for ( size_t j = 1; j < edge._pos.size() && !useNormal; ++j )
+            {
+              uv = surface->NextValueOfUV( uv, edge._pos[j], preci );
+              if ( surface->Gap() < 2. * edge._len )
+                segLen[j] = surface->Gap();
+              else
+                useNormal = true;
+            }
+          }
+        }
+        else
+        {
+          useNormal = usePos = false;
+          edge._pos[1] = edge._pos.back();
+          edge._pos.resize( 2 );
+          segLen.resize( 2 );
+          segLen[ 1 ] = edge._len;
+        }
+        if ( useNormal && edge.Is( _LayerEdge::NORMAL_UPDATED ))
+        {
+          useNormal = usePos = false;
+          _LayerEdge tmpEdge; // get original _normal
+          tmpEdge._nodes.push_back( edge._nodes[0] );
+          if ( !setEdgeData( tmpEdge, eos, helper, data ))
+            usePos = true;
+          else
+            for ( size_t j = 1; j < edge._pos.size(); ++j )
+              segLen[j] = ( edge._pos[j] - edge._pos[0] ) * tmpEdge._normal;
+        }
+        if ( useNormal )
+        {
+          for ( size_t j = 1; j < edge._pos.size(); ++j )
+            segLen[j] = ( edge._pos[j] - edge._pos[0] ) * edge._normal;
+        }
+        if ( usePos )
+        {
+          for ( size_t j = 1; j < edge._pos.size(); ++j )
+            segLen[j] = segLen[j-1] + ( edge._pos[j-1] - edge._pos[j] ).Modulus();
+        }
+        else
+        {
+          bool swapped = ( edge._pos.size() > 2 );
+          while ( swapped )
+          {
+            swapped = false;
+            for ( size_t j = 1; j < edge._pos.size(); ++j )
+              if ( segLen[j] < segLen[j-1] )
+              {
+                std::swap( segLen[j], segLen[j-1] );
+                std::swap( edge._pos[j], edge._pos[j-1] );
+                swapped = true;
+              }
+          }
+        }
+        // smooth a path formed by edge._pos
+        if (( smoothed ) &&
+            ( eos.ShapeType() == TopAbs_FACE || edge.Is( _LayerEdge::SMOOTHED_C1 )))
+          edge.SmoothPos( segLen, preci );
+      }
+      else if ( eos._isRegularSWOL ) // usual SWOL
+      {
+        for ( size_t j = 1; j < edge._pos.size(); ++j )
+          segLen[j] = segLen[j-1] + (edge._pos[j-1] - edge._pos[j] ).Modulus();
+      }
+      else if ( !surface.IsNull() ) // SWOL surface with singularities
+      {
+        pos3D.resize( edge._pos.size() );
+        for ( size_t j = 0; j < edge._pos.size(); ++j )
+          pos3D[j] = surface->Value( edge._pos[j].X(), edge._pos[j].Y() ).XYZ();
+
+        for ( size_t j = 1; j < edge._pos.size(); ++j )
+          segLen[j] = segLen[j-1] + ( pos3D[j-1] - pos3D[j] ).Modulus();
+      }
 
       // allocate memory for new nodes if it is not yet refined
       const SMDS_MeshNode* tgtNode = edge._nodes.back();
@@ -6219,34 +8866,20 @@ bool _ViscousBuilder::refine(_SolidData& data)
         edge._nodes[1] = 0;
         edge._nodes.back() = tgtNode;
       }
-      // get data of a shrink shape
-      if ( !eos._sWOL.IsNull() && eos._sWOL != prevSWOL )
-      {
-        isOnEdge = ( eos.SWOLType() == TopAbs_EDGE );
-        if ( isOnEdge )
-        {
-          geomEdge = TopoDS::Edge( eos._sWOL );
-          curve    = BRep_Tool::Curve( geomEdge, loc, f,l);
-        }
-        else
-        {
-          geomFace = TopoDS::Face( eos._sWOL );
-          surface  = BRep_Tool::Surface( geomFace, loc );
-        }
-        prevSWOL = eos._sWOL;
-      }
       // restore shapePos of the last node by already treated _LayerEdge of another _SolidData
       const TGeomID baseShapeId = edge._nodes[0]->getshapeId();
       if ( baseShapeId != prevBaseId )
       {
         map< TGeomID, TNode2Edge* >::iterator s2ne = data._s2neMap.find( baseShapeId );
-        n2eMap = ( s2ne == data._s2neMap.end() ) ? 0 : n2eMap = s2ne->second;
+        n2eMap = ( s2ne == data._s2neMap.end() ) ? 0 : s2ne->second;
         prevBaseId = baseShapeId;
       }
       _LayerEdge* edgeOnSameNode = 0;
+      bool        useExistingPos = false;
       if ( n2eMap && (( n2e = n2eMap->find( edge._nodes[0] )) != n2eMap->end() ))
       {
         edgeOnSameNode = n2e->second;
+        useExistingPos = ( edgeOnSameNode->_len < edge._len );
         const gp_XYZ& otherTgtPos = edgeOnSameNode->_pos.back();
         SMDS_PositionPtr  lastPos = tgtNode->GetPosition();
         if ( isOnEdge )
@@ -6282,12 +8915,12 @@ bool _ViscousBuilder::refine(_SolidData& data)
         // compute an intermediate position
         hi *= f;
         hSum += hi;
-        while ( hSum > segLen[iSeg] && iSeg < segLen.size()-1)
+        while ( hSum > segLen[iSeg] && iSeg < segLen.size()-1 )
           ++iSeg;
         int iPrevSeg = iSeg-1;
         while ( fabs( segLen[iPrevSeg] - segLen[iSeg]) <= zeroLen && iPrevSeg > 0 )
           --iPrevSeg;
-        double r = ( segLen[iSeg] - hSum ) / ( segLen[iSeg] - segLen[iPrevSeg] );
+        double   r = ( segLen[iSeg] - hSum ) / ( segLen[iSeg] - segLen[iPrevSeg] );
         gp_Pnt pos = r * edge._pos[iPrevSeg] + (1-r) * edge._pos[iSeg];
 
         SMDS_MeshNode*& node = const_cast< SMDS_MeshNode*& >( edge._nodes[ iStep ]);
@@ -6300,11 +8933,19 @@ bool _ViscousBuilder::refine(_SolidData& data)
             if ( !node )
               pos = curve->Value( u ).Transformed(loc);
           }
+          else if ( eos._isRegularSWOL )
+          {
+            uv.SetCoord( pos.X(), pos.Y() );
+            if ( !node )
+              pos = surface->Value( pos.X(), pos.Y() );
+          }
           else
           {
             uv.SetCoord( pos.X(), pos.Y() );
+            gp_Pnt p = r * pos3D[ iPrevSeg ] + (1-r) * pos3D[ iSeg ];
+            uv = surface->NextValueOfUV( uv, p, BRep_Tool::Tolerance( geomFace )).XY();
             if ( !node )
-              pos = surface->Value( pos.X(), pos.Y() ).Transformed(loc);
+              pos = surface->Value( uv );
           }
         }
         // create or update the node
@@ -6330,7 +8971,9 @@ bool _ViscousBuilder::refine(_SolidData& data)
             // make average pos from new and current parameters
             if ( isOnEdge )
             {
-              u = 0.5 * ( u + helper.GetNodeU( geomEdge, node ));
+              //u = 0.5 * ( u + helper.GetNodeU( geomEdge, node ));
+              if ( useExistingPos )
+                u = helper.GetNodeU( geomEdge, node );
               pos = curve->Value( u ).Transformed(loc);
 
               SMDS_EdgePosition* epos = static_cast<SMDS_EdgePosition*>( node->GetPosition() );
@@ -6338,8 +8981,10 @@ bool _ViscousBuilder::refine(_SolidData& data)
             }
             else
             {
-              uv = 0.5 * ( uv + helper.GetNodeUV( geomFace, node ));
-              pos = surface->Value( uv.X(), uv.Y()).Transformed(loc);
+              //uv = 0.5 * ( uv + helper.GetNodeUV( geomFace, node ));
+              if ( useExistingPos )
+                uv = helper.GetNodeUV( geomFace, node );
+              pos = surface->Value( uv );
 
               SMDS_FacePosition* fpos = static_cast<SMDS_FacePosition*>( node->GetPosition() );
               fpos->SetUParameter( uv.X() );
@@ -6380,8 +9025,9 @@ bool _ViscousBuilder::refine(_SolidData& data)
 
   vector< vector<const SMDS_MeshNode*>* > nnVec;
   set< vector<const SMDS_MeshNode*>* >    nnSet;
-  set< int > degenEdgeInd;
-  vector<const SMDS_MeshElement*> degenVols;
+  set< int >                       degenEdgeInd;
+  vector<const SMDS_MeshElement*>     degenVols;
+  vector<int>                       isRiskySWOL;
 
   TopExp_Explorer exp( data._solid, TopAbs_FACE );
   for ( ; exp.More(); exp.Next() )
@@ -6399,110 +9045,113 @@ bool _ViscousBuilder::refine(_SolidData& data)
       nnVec.resize( nbNodes );
       nnSet.clear();
       degenEdgeInd.clear();
-      int nbZ = 0;
+      isRiskySWOL.resize( nbNodes );
+      size_t maxZ = 0, minZ = std::numeric_limits<size_t>::max();
       SMDS_NodeIteratorPtr nIt = face->nodeIterator();
       for ( int iN = 0; iN < nbNodes; ++iN )
       {
         const SMDS_MeshNode* n = nIt->next();
+        _LayerEdge*       edge = data._n2eMap[ n ];
         const int i = isReversedFace ? nbNodes-1-iN : iN;
-        nnVec[ i ] = & data._n2eMap[ n ]->_nodes;
-        if ( nnVec[ i ]->size() < 2 )
-          degenEdgeInd.insert( iN );
-        else
-          nbZ = nnVec[ i ]->size();
+        nnVec[ i ] = & edge->_nodes;
+        maxZ = std::max( maxZ, nnVec[ i ]->size() );
+        minZ = std::min( minZ, nnVec[ i ]->size() );
+        //isRiskySWOL[ i ] = edge->Is( _LayerEdge::RISKY_SWOL );
 
         if ( helper.HasDegeneratedEdges() )
           nnSet.insert( nnVec[ i ]);
       }
-      if ( nbZ == 0 )
+
+      if ( maxZ == 0 )
         continue;
       if ( 0 < nnSet.size() && nnSet.size() < 3 )
         continue;
 
       switch ( nbNodes )
       {
-      case 3:
-        switch ( degenEdgeInd.size() )
-        {
-        case 0: // PENTA
-        {
-          for ( int iZ = 1; iZ < nbZ; ++iZ )
-            helper.AddVolume( (*nnVec[0])[iZ-1], (*nnVec[1])[iZ-1], (*nnVec[2])[iZ-1],
-                              (*nnVec[0])[iZ],   (*nnVec[1])[iZ],   (*nnVec[2])[iZ]);
-          break;
-        }
-        case 1: // PYRAM
+      case 3: // TRIA
+      {
+        // PENTA
+        for ( size_t iZ = 1; iZ < minZ; ++iZ )
+          helper.AddVolume( (*nnVec[0])[iZ-1], (*nnVec[1])[iZ-1], (*nnVec[2])[iZ-1],
+                            (*nnVec[0])[iZ],   (*nnVec[1])[iZ],   (*nnVec[2])[iZ]);
+
+        for ( size_t iZ = minZ; iZ < maxZ; ++iZ )
         {
-          int i2 = *degenEdgeInd.begin();
-          int i0 = helper.WrapIndex( i2 - 1, nbNodes );
-          int i1 = helper.WrapIndex( i2 + 1, nbNodes );
-          for ( int iZ = 1; iZ < nbZ; ++iZ )
+          for ( int iN = 0; iN < nbNodes; ++iN )
+            if ( nnVec[ iN ]->size() < iZ+1 )
+              degenEdgeInd.insert( iN );
+
+          if ( degenEdgeInd.size() == 1 )  // PYRAM
+          {
+            int i2 = *degenEdgeInd.begin();
+            int i0 = helper.WrapIndex( i2 - 1, nbNodes );
+            int i1 = helper.WrapIndex( i2 + 1, nbNodes );
             helper.AddVolume( (*nnVec[i0])[iZ-1], (*nnVec[i1])[iZ-1],
-                              (*nnVec[i1])[iZ],   (*nnVec[i0])[iZ],   (*nnVec[i2])[0]);
-          break;
-        }
-        case 2: // TETRA
-        {
-          int i3 = !degenEdgeInd.count(0) ? 0 : !degenEdgeInd.count(1) ? 1 : 2;
-          for ( int iZ = 1; iZ < nbZ; ++iZ )
-            helper.AddVolume( (*nnVec[0])[iZ-1], (*nnVec[1])[iZ-1], (*nnVec[2])[iZ-1],
-                              (*nnVec[i3])[iZ]);
-          break;
-        }
+                              (*nnVec[i1])[iZ  ], (*nnVec[i0])[iZ  ], (*nnVec[i2]).back());
+          }
+          else  // TETRA
+          {
+            int i3 = !degenEdgeInd.count(0) ? 0 : !degenEdgeInd.count(1) ? 1 : 2;
+            helper.AddVolume( (*nnVec[  0 ])[ i3 == 0 ? iZ-1 : nnVec[0]->size()-1 ],
+                              (*nnVec[  1 ])[ i3 == 1 ? iZ-1 : nnVec[1]->size()-1 ],
+                              (*nnVec[  2 ])[ i3 == 2 ? iZ-1 : nnVec[2]->size()-1 ],
+                              (*nnVec[ i3 ])[ iZ ]);
+          }
         }
-        break;
+        break; // TRIA
+      }
+      case 4: // QUAD
+      {
+        // HEX
+        for ( size_t iZ = 1; iZ < minZ; ++iZ )
+          helper.AddVolume( (*nnVec[0])[iZ-1], (*nnVec[1])[iZ-1],
+                            (*nnVec[2])[iZ-1], (*nnVec[3])[iZ-1],
+                            (*nnVec[0])[iZ],   (*nnVec[1])[iZ],
+                            (*nnVec[2])[iZ],   (*nnVec[3])[iZ]);
 
-      case 4:
-        switch ( degenEdgeInd.size() )
-        {
-        case 0: // HEX
+        for ( size_t iZ = minZ; iZ < maxZ; ++iZ )
         {
-          for ( int iZ = 1; iZ < nbZ; ++iZ )
-            helper.AddVolume( (*nnVec[0])[iZ-1], (*nnVec[1])[iZ-1],
-                              (*nnVec[2])[iZ-1], (*nnVec[3])[iZ-1],
-                              (*nnVec[0])[iZ],   (*nnVec[1])[iZ],
-                              (*nnVec[2])[iZ],   (*nnVec[3])[iZ]);
-          break;
-        }
-        case 2: // PENTA?
-        {
-          int i2 = *degenEdgeInd.begin();
-          int i3 = *degenEdgeInd.rbegin();
-          bool ok = ( i3 - i2 == 1 );
-          if ( i2 == 0 && i3 == 3 ) { i2 = 3; i3 = 0; ok = true; }
-          int i0 = helper.WrapIndex( i3 + 1, nbNodes );
-          int i1 = helper.WrapIndex( i0 + 1, nbNodes );
-          for ( int iZ = 1; iZ < nbZ; ++iZ )
+          for ( int iN = 0; iN < nbNodes; ++iN )
+            if ( nnVec[ iN ]->size() < iZ+1 )
+              degenEdgeInd.insert( iN );
+
+          switch ( degenEdgeInd.size() )
           {
+          case 2: // PENTA
+          {
+            int i2 = *degenEdgeInd.begin();
+            int i3 = *degenEdgeInd.rbegin();
+            bool ok = ( i3 - i2 == 1 );
+            if ( i2 == 0 && i3 == 3 ) { i2 = 3; i3 = 0; ok = true; }
+            int i0 = helper.WrapIndex( i3 + 1, nbNodes );
+            int i1 = helper.WrapIndex( i0 + 1, nbNodes );
+
             const SMDS_MeshElement* vol =
-              helper.AddVolume( (*nnVec[i3])[0], (*nnVec[i0])[iZ], (*nnVec[i0])[iZ-1],
-                                (*nnVec[i2])[0], (*nnVec[i1])[iZ], (*nnVec[i1])[iZ-1]);
+              helper.AddVolume( nnVec[i3]->back(), (*nnVec[i0])[iZ], (*nnVec[i0])[iZ-1],
+                                nnVec[i2]->back(), (*nnVec[i1])[iZ], (*nnVec[i1])[iZ-1]);
             if ( !ok && vol )
               degenVols.push_back( vol );
           }
           break;
-        }
-        case 3: // degen HEX
-        {
-          const SMDS_MeshNode* nn[8];
-          for ( int iZ = 1; iZ < nbZ; ++iZ )
+
+          default: // degen HEX
           {
             const SMDS_MeshElement* vol =
-              helper.AddVolume( nnVec[0]->size() > 1 ? (*nnVec[0])[iZ-1] : (*nnVec[0])[0],
-                                nnVec[1]->size() > 1 ? (*nnVec[1])[iZ-1] : (*nnVec[1])[0],
-                                nnVec[2]->size() > 1 ? (*nnVec[2])[iZ-1] : (*nnVec[2])[0],
-                                nnVec[3]->size() > 1 ? (*nnVec[3])[iZ-1] : (*nnVec[3])[0],
-                                nnVec[0]->size() > 1 ? (*nnVec[0])[iZ]   : (*nnVec[0])[0],
-                                nnVec[1]->size() > 1 ? (*nnVec[1])[iZ]   : (*nnVec[1])[0],
-                                nnVec[2]->size() > 1 ? (*nnVec[2])[iZ]   : (*nnVec[2])[0],
-                                nnVec[3]->size() > 1 ? (*nnVec[3])[iZ]   : (*nnVec[3])[0]);
+              helper.AddVolume( nnVec[0]->size() > iZ-1 ? (*nnVec[0])[iZ-1] : nnVec[0]->back(),
+                                nnVec[1]->size() > iZ-1 ? (*nnVec[1])[iZ-1] : nnVec[1]->back(),
+                                nnVec[2]->size() > iZ-1 ? (*nnVec[2])[iZ-1] : nnVec[2]->back(),
+                                nnVec[3]->size() > iZ-1 ? (*nnVec[3])[iZ-1] : nnVec[3]->back(),
+                                nnVec[0]->size() > iZ   ? (*nnVec[0])[iZ]   : nnVec[0]->back(),
+                                nnVec[1]->size() > iZ   ? (*nnVec[1])[iZ]   : nnVec[1]->back(),
+                                nnVec[2]->size() > iZ   ? (*nnVec[2])[iZ]   : nnVec[2]->back(),
+                                nnVec[3]->size() > iZ   ? (*nnVec[3])[iZ]   : nnVec[3]->back());
             degenVols.push_back( vol );
           }
+          }
         }
-        break;
-        }
-        break;
-
+        break; // HEX
+      }
       default:
         return error("Not supported type of element", data._index);
 
@@ -6588,7 +9237,7 @@ bool _ViscousBuilder::shrink()
     // ===========================
 
     // Collect nodes to smooth, as src nodes are not yet replaced by tgt ones
-    // and thus all nodes on a FACE connected to 2d elements are to be smoothed
+    // and hence all nodes on a FACE connected to 2d elements are to be smoothed
     vector < const SMDS_MeshNode* > smoothNodes;
     {
       SMDS_NodeIteratorPtr nIt = smDS->GetNodes();
@@ -6746,6 +9395,7 @@ bool _ViscousBuilder::shrink()
     int badNb, shriStep=0, smooStep=0;
     _SmoothNode::SmoothType smoothType
       = isConcaveFace ? _SmoothNode::ANGULAR : _SmoothNode::LAPLACIAN;
+    SMESH_Comment errMsg;
     while ( shrinked )
     {
       shriStep++;
@@ -6795,10 +9445,14 @@ bool _ViscousBuilder::shrink()
 
         dumpFunctionEnd();
       }
+
+      errMsg.clear();
       if ( badNb > 0 )
-        return error(SMESH_Comment("Can't shrink 2D mesh on face ") << f2sd->first );
+        errMsg << "Can't shrink 2D mesh on face " << f2sd->first;
       if ( shriStep > 200 )
-        return error(SMESH_Comment("Infinite loop at shrinking 2D mesh on face ") << f2sd->first );
+        errMsg << "Infinite loop at shrinking 2D mesh on face " << f2sd->first;
+      if ( !errMsg.empty() )
+        break;
 
       // Fix narrow triangles by swapping diagonals
       // ---------------------------------------
@@ -6844,43 +9498,206 @@ bool _ViscousBuilder::shrink()
       //                              _SmoothNode::LAPLACIAN,/*set3D=*/false);
       //   }
       // }
+
     } // while ( shrinked )
 
-    // No wrongly shaped faces remain; final smooth. Set node XYZ.
-    bool isStructuredFixed = false;
-    if ( SMESH_2D_Algo* algo = dynamic_cast<SMESH_2D_Algo*>( sm->GetAlgo() ))
-      isStructuredFixed = algo->FixInternalNodes( *data._proxyMesh, F );
-    if ( !isStructuredFixed )
+    if ( !errMsg.empty() ) // Try to re-compute the shrink FACE
     {
-      if ( isConcaveFace ) // fix narrow faces by swapping diagonals
-        fixBadFaces( F, helper, /*is2D=*/false, ++shriStep );
+      // remove faces
+      SMESHDS_SubMesh* psm = data._proxyMesh->getFaceSubM( F );
+      {
+        vector< const SMDS_MeshElement* > facesToRm;
+        if ( psm )
+        {
+          facesToRm.reserve( psm->NbElements() );
+          for ( SMDS_ElemIteratorPtr ite = psm->GetElements(); ite->more(); )
+            facesToRm.push_back( ite->next() );
 
-      for ( int st = 3; st; --st )
+          for ( size_t i = 0 ; i < _sdVec.size(); ++i )
+            if (( psm = _sdVec[i]._proxyMesh->getFaceSubM( F )))
+              psm->Clear();
+        }
+        for ( size_t i = 0; i < facesToRm.size(); ++i )
+          getMeshDS()->RemoveFreeElement( facesToRm[i], smDS, /*fromGroups=*/false );
+      }
+      // remove nodes
       {
-        switch( st ) {
-        case 1: smoothType = _SmoothNode::LAPLACIAN; break;
-        case 2: smoothType = _SmoothNode::LAPLACIAN; break;
-        case 3: smoothType = _SmoothNode::ANGULAR; break;
+        TIDSortedNodeSet nodesToKeep; // nodes of _LayerEdge to keep
+        for ( size_t iS = 0; iS < subEOS.size(); ++iS ) {
+          for ( size_t i = 0; i < subEOS[iS]->_edges.size(); ++i )
+            nodesToKeep.insert( ++( subEOS[iS]->_edges[i]->_nodes.begin() ),
+                                subEOS[iS]->_edges[i]->_nodes.end() );
         }
-        dumpFunction(SMESH_Comment("shrinkFace")<<f2sd->first<<"_st"<<++smooStep); // debug
-        for ( size_t i = 0; i < nodesToSmooth.size(); ++i )
+        SMDS_NodeIteratorPtr itn = smDS->GetNodes();
+        while ( itn->more() ) {
+          const SMDS_MeshNode* n = itn->next();
+          if ( !nodesToKeep.count( n ))
+            getMeshDS()->RemoveFreeNode( n, smDS, /*fromGroups=*/false );
+        }
+      }
+      // restore position and UV of target nodes
+      gp_Pnt p;
+      for ( size_t iS = 0; iS < subEOS.size(); ++iS )
+        for ( size_t i = 0; i < subEOS[iS]->_edges.size(); ++i )
+        {
+          _LayerEdge*       edge = subEOS[iS]->_edges[i];
+          SMDS_MeshNode* tgtNode = const_cast< SMDS_MeshNode*& >( edge->_nodes.back() );
+          if ( edge->_pos.empty() ) continue;
+          if ( subEOS[iS]->SWOLType() == TopAbs_FACE )
+          {
+            SMDS_FacePosition* pos = static_cast<SMDS_FacePosition*>( tgtNode->GetPosition() );
+            pos->SetUParameter( edge->_pos[0].X() );
+            pos->SetVParameter( edge->_pos[0].Y() );
+            p = surface->Value( edge->_pos[0].X(), edge->_pos[0].Y() );
+          }
+          else
+          {
+            SMDS_EdgePosition* pos = static_cast<SMDS_EdgePosition*>( tgtNode->GetPosition() );
+            pos->SetUParameter( edge->_pos[0].Coord( U_TGT ));
+            p = BRepAdaptor_Curve( TopoDS::Edge( subEOS[iS]->_sWOL )).Value( pos->GetUParameter() );
+          }
+          tgtNode->setXYZ( p.X(), p.Y(), p.Z() );
+          dumpMove( tgtNode );
+        }
+      // shrink EDGE sub-meshes and set proxy sub-meshes
+      UVPtStructVec uvPtVec;
+      set< _Shrinker1D* >::iterator shrIt = eShri1D.begin();
+      for ( shrIt = eShri1D.begin(); shrIt != eShri1D.end(); ++shrIt )
+      {
+        _Shrinker1D* shr = (*shrIt);
+        shr->Compute( /*set3D=*/true, helper );
+
+        // set proxy mesh of EDGEs w/o layers
+        map< double, const SMDS_MeshNode* > nodes;
+        SMESH_Algo::GetSortedNodesOnEdge( getMeshDS(), shr->GeomEdge(),/*skipMedium=*/true, nodes);
+        // remove refinement nodes
+        const SMDS_MeshNode* sn0 = shr->SrcNode(0), *sn1 = shr->SrcNode(1);
+        const SMDS_MeshNode* tn0 = shr->TgtNode(0), *tn1 = shr->TgtNode(1);
+        map< double, const SMDS_MeshNode* >::iterator u2n = nodes.begin();
+        if ( u2n->second == sn0 || u2n->second == sn1 )
         {
-          nodesToSmooth[i].Smooth( badNb,surface,helper,refSign,
-                                   smoothType,/*set3D=*/st==1 );
+          while ( u2n->second != tn0 && u2n->second != tn1 )
+            ++u2n;
+          nodes.erase( nodes.begin(), u2n );
         }
-        dumpFunctionEnd();
+        u2n = --nodes.end();
+        if ( u2n->second == sn0 || u2n->second == sn1 )
+        {
+          while ( u2n->second != tn0 && u2n->second != tn1 )
+            --u2n;
+          nodes.erase( ++u2n, nodes.end() );
+        }
+        // set proxy sub-mesh
+        uvPtVec.resize( nodes.size() );
+        u2n = nodes.begin();
+        BRepAdaptor_Curve2d curve( shr->GeomEdge(), F );
+        for ( size_t i = 0; i < nodes.size(); ++i, ++u2n )
+        {
+          uvPtVec[ i ].node = u2n->second;
+          uvPtVec[ i ].param = u2n->first;
+          uvPtVec[ i ].SetUV( curve.Value( u2n->first ).XY() );
+        }
+        StdMeshers_FaceSide fSide( uvPtVec, F, shr->GeomEdge(), _mesh );
+        StdMeshers_ViscousLayers2D::SetProxyMeshOfEdge( fSide );
       }
-    }
-    // Set an event listener to clear FACE sub-mesh together with SOLID sub-mesh
-    VISCOUS_3D::ToClearSubWithMain( sm, data._solid );
 
-    if ( !getMeshDS()->IsEmbeddedMode() )
-      // Log node movement
-      for ( size_t i = 0; i < nodesToSmooth.size(); ++i )
+      // set proxy mesh of EDGEs with layers
+      vector< _LayerEdge* > edges;
+      for ( size_t iS = 0; iS < subEOS.size(); ++iS )
+      {
+        _EdgesOnShape& eos = * subEOS[ iS ];
+        if ( eos.ShapeType() != TopAbs_EDGE ) continue;
+
+        const TopoDS_Edge& E = TopoDS::Edge( eos._shape );
+        data.SortOnEdge( E, eos._edges );
+
+        edges.clear();
+        if ( _EdgesOnShape* eov = data.GetShapeEdges( helper.IthVertex( 0, E, /*CumOri=*/false )))
+          if ( !eov->_edges.empty() )
+            edges.push_back( eov->_edges[0] ); // on 1st VERTEX
+
+        edges.insert( edges.end(), eos._edges.begin(), eos._edges.end() );
+
+        if ( _EdgesOnShape* eov = data.GetShapeEdges( helper.IthVertex( 1, E, /*CumOri=*/false )))
+          if ( !eov->_edges.empty() )
+            edges.push_back( eov->_edges[0] ); // on last VERTEX
+
+        uvPtVec.resize( edges.size() );
+        for ( size_t i = 0; i < edges.size(); ++i )
+        {
+          uvPtVec[ i ].node = edges[i]->_nodes.back();
+          uvPtVec[ i ].param = helper.GetNodeU( E, edges[i]->_nodes[0] );
+          uvPtVec[ i ].SetUV( helper.GetNodeUV( F, edges[i]->_nodes.back() ));
+        }
+        BRep_Tool::Range( E, uvPtVec[0].param, uvPtVec.back().param );
+        StdMeshers_FaceSide fSide( uvPtVec, F, E, _mesh );
+        StdMeshers_ViscousLayers2D::SetProxyMeshOfEdge( fSide );
+      }
+      // temporary clear the FACE sub-mesh from faces made by refine()
+      vector< const SMDS_MeshElement* > elems;
+      elems.reserve( smDS->NbElements() + smDS->NbNodes() );
+      for ( SMDS_ElemIteratorPtr ite = smDS->GetElements(); ite->more(); )
+        elems.push_back( ite->next() );
+      for ( SMDS_NodeIteratorPtr ite = smDS->GetNodes(); ite->more(); )
+        elems.push_back( ite->next() );
+      smDS->Clear();
+
+      // compute the mesh on the FACE
+      sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
+      sm->ComputeStateEngine( SMESH_subMesh::COMPUTE_SUBMESH );
+
+      // re-fill proxy sub-meshes of the FACE
+      for ( size_t i = 0 ; i < _sdVec.size(); ++i )
+        if (( psm = _sdVec[i]._proxyMesh->getFaceSubM( F )))
+          for ( SMDS_ElemIteratorPtr ite = smDS->GetElements(); ite->more(); )
+            psm->AddElement( ite->next() );
+
+      // re-fill smDS
+      for ( size_t i = 0; i < elems.size(); ++i )
+        smDS->AddElement( elems[i] );
+
+      if ( sm->GetComputeState() != SMESH_subMesh::COMPUTE_OK )
+        return error( errMsg );
+
+    } // end of re-meshing in case of failed smoothing
+    else
+    {
+      // No wrongly shaped faces remain; final smooth. Set node XYZ.
+      bool isStructuredFixed = false;
+      if ( SMESH_2D_Algo* algo = dynamic_cast<SMESH_2D_Algo*>( sm->GetAlgo() ))
+        isStructuredFixed = algo->FixInternalNodes( *data._proxyMesh, F );
+      if ( !isStructuredFixed )
       {
-        SMESH_TNodeXYZ p ( nodesToSmooth[i]._node );
-        getMeshDS()->MoveNode( nodesToSmooth[i]._node, p.X(), p.Y(), p.Z() );
+        if ( isConcaveFace ) // fix narrow faces by swapping diagonals
+          fixBadFaces( F, helper, /*is2D=*/false, ++shriStep );
+
+        for ( int st = 3; st; --st )
+        {
+          switch( st ) {
+          case 1: smoothType = _SmoothNode::LAPLACIAN; break;
+          case 2: smoothType = _SmoothNode::LAPLACIAN; break;
+          case 3: smoothType = _SmoothNode::ANGULAR; break;
+          }
+          dumpFunction(SMESH_Comment("shrinkFace")<<f2sd->first<<"_st"<<++smooStep); // debug
+          for ( size_t i = 0; i < nodesToSmooth.size(); ++i )
+          {
+            nodesToSmooth[i].Smooth( badNb,surface,helper,refSign,
+                                     smoothType,/*set3D=*/st==1 );
+          }
+          dumpFunctionEnd();
+        }
       }
+      if ( !getMeshDS()->IsEmbeddedMode() )
+        // Log node movement
+        for ( size_t i = 0; i < nodesToSmooth.size(); ++i )
+        {
+          SMESH_TNodeXYZ p ( nodesToSmooth[i]._node );
+          getMeshDS()->MoveNode( nodesToSmooth[i]._node, p.X(), p.Y(), p.Z() );
+        }
+    }
+
+    // Set an event listener to clear FACE sub-mesh together with SOLID sub-mesh
+    VISCOUS_3D::ToClearSubWithMain( sm, data._solid );
 
   } // loop on FACES to srink mesh on
 
@@ -6910,6 +9727,11 @@ bool _ViscousBuilder::prepareEdgeToShrink( _LayerEdge&            edge,
 
   if ( eos.SWOLType() == TopAbs_FACE )
   {
+    if ( tgtNode->GetPosition()->GetDim() != 2 ) // not inflated edge
+    {
+      edge._pos.clear();
+      return srcNode == tgtNode;
+    }
     gp_XY srcUV ( edge._pos[0].X(), edge._pos[0].Y() );          //helper.GetNodeUV( F, srcNode );
     gp_XY tgtUV = edge.LastUV( TopoDS::Face( eos._sWOL ), eos ); //helper.GetNodeUV( F, tgtNode );
     gp_Vec2d uvDir( srcUV, tgtUV );
@@ -6928,6 +9750,11 @@ bool _ViscousBuilder::prepareEdgeToShrink( _LayerEdge&            edge,
   }
   else // _sWOL is TopAbs_EDGE
   {
+    if ( tgtNode->GetPosition()->GetDim() != 1 ) // not inflated edge
+    {
+      edge._pos.clear();
+      return srcNode == tgtNode;
+    }
     const TopoDS_Edge&    E = TopoDS::Edge( eos._sWOL );
     SMESHDS_SubMesh* edgeSM = getMeshDS()->MeshElements( E );
     if ( !edgeSM || edgeSM->NbElements() == 0 )
@@ -7256,6 +10083,7 @@ bool _LayerEdge::SetNewLength2d( Handle(Geom_Surface)& surface,
     dumpMove( tgtNode );
 #endif
   }
+
   return true;
 }
 
@@ -7441,13 +10269,22 @@ _SolidData::~_SolidData()
   for ( ; n2e != _n2eMap.end(); ++n2e )
   {
     _LayerEdge* & e = n2e->second;
-    if ( e && e->_2neibors )
+    if ( e )
+    {
+      delete e->_curvature;
+      if ( e->_2neibors )
+        delete e->_2neibors->_plnNorm;
       delete e->_2neibors;
+    }
     delete e;
-    e = NULL;
+    e = 0;
   }
   _n2eMap.clear();
+
+  delete _helper;
+  _helper = 0;
 }
+
 //================================================================================
 /*!
  * \brief Keep a _LayerEdge inflated along the EDGE
@@ -7481,8 +10318,8 @@ void _Shrinker1D::AddEdge( const _LayerEdge*   e,
 
   // Update _nodes
 
-  const SMDS_MeshNode* tgtNode0 = _edges[0] ? _edges[0]->_nodes.back() : 0;
-  const SMDS_MeshNode* tgtNode1 = _edges[1] ? _edges[1]->_nodes.back() : 0;
+  const SMDS_MeshNode* tgtNode0 = TgtNode( 0 );
+  const SMDS_MeshNode* tgtNode1 = TgtNode( 1 );
 
   if ( _nodes.empty() )
   {
@@ -7514,7 +10351,7 @@ void _Shrinker1D::AddEdge( const _LayerEdge*   e,
   else
   {
     // remove target node of the _LayerEdge from _nodes
-    int nbFound = 0;
+    size_t nbFound = 0;
     for ( size_t i = 0; i < _nodes.size(); ++i )
       if ( !_nodes[i] || _nodes[i] == tgtNode0 || _nodes[i] == tgtNode1 )
         _nodes[i] = 0, nbFound++;
index 585bcaf..111ea47 100644 (file)
@@ -113,6 +113,7 @@ namespace VISCOUS_2D
       //virtual int NbElements() const { return _elements.size()+1; }
       virtual int NbNodes() const { return Max( 0, _uvPtStructVec.size()-2 ); }
       void SetUVPtStructVec(UVPtStructVec& vec) { _uvPtStructVec.swap( vec ); }
+      UVPtStructVec& GetUVPtStructVec() { return _uvPtStructVec; }
     };
     _ProxyMeshOfFace(const SMESH_Mesh& mesh): SMESH_ProxyMesh(mesh) {}
     _EdgeSubMesh* GetEdgeSubMesh(int ID) { return (_EdgeSubMesh*) getProxySubMesh(ID); }
@@ -515,29 +516,53 @@ SMESH_ProxyMesh::Ptr
 StdMeshers_ViscousLayers2D::Compute(SMESH_Mesh&        theMesh,
                                     const TopoDS_Face& theFace)
 {
-  SMESH_ProxyMesh::Ptr pm;
-
+  using namespace VISCOUS_2D;
   vector< const StdMeshers_ViscousLayers2D* > hyps;
   vector< TopoDS_Shape >                      hypShapes;
-  if ( VISCOUS_2D::findHyps( theMesh, theFace, hyps, hypShapes ))
+
+  SMESH_ProxyMesh::Ptr pm = _ProxyMeshHolder::FindProxyMeshOfFace( theFace, theMesh );
+  if ( !pm )
   {
-    VISCOUS_2D::_ViscousBuilder2D builder( theMesh, theFace, hyps, hypShapes );
-    pm = builder.Compute();
-    SMESH_ComputeErrorPtr error = builder.GetError();
-    if ( error && !error->IsOK() )
-      theMesh.GetSubMesh( theFace )->GetComputeError() = error;
-    else if ( !pm )
+    if ( findHyps( theMesh, theFace, hyps, hypShapes ))
+    {
+      VISCOUS_2D::_ViscousBuilder2D builder( theMesh, theFace, hyps, hypShapes );
+      pm = builder.Compute();
+      SMESH_ComputeErrorPtr error = builder.GetError();
+      if ( error && !error->IsOK() )
+        theMesh.GetSubMesh( theFace )->GetComputeError() = error;
+      else if ( !pm )
+        pm.reset( new SMESH_ProxyMesh( theMesh ));
+      if ( getenv("__ONLY__VL2D__"))
+        pm.reset();
+    }
+    else
+    {
       pm.reset( new SMESH_ProxyMesh( theMesh ));
-    if ( getenv("__ONLY__VL2D__"))
-      pm.reset();
-  }
-  else
-  {
-    pm.reset( new SMESH_ProxyMesh( theMesh ));
+    }
   }
   return pm;
 }
 // --------------------------------------------------------------------------------
+void StdMeshers_ViscousLayers2D::SetProxyMeshOfEdge( const StdMeshers_FaceSide& edgeNodes )
+{
+  using namespace VISCOUS_2D;
+  SMESH_ProxyMesh::Ptr pm =
+    _ProxyMeshHolder::FindProxyMeshOfFace( edgeNodes.Face(), *edgeNodes.GetMesh() );
+  if ( !pm ) {
+    _ProxyMeshOfFace* proxyMeshOfFace = new _ProxyMeshOfFace( *edgeNodes.GetMesh() );
+    pm.reset( proxyMeshOfFace );
+    new _ProxyMeshHolder( edgeNodes.Face(), pm );
+  }
+  _ProxyMeshOfFace*  proxyMeshOfFace = static_cast<_ProxyMeshOfFace*>( pm.get() );
+  _ProxyMeshOfFace::_EdgeSubMesh* sm = proxyMeshOfFace->GetEdgeSubMesh( edgeNodes.EdgeID(0) );
+  sm->GetUVPtStructVec() = edgeNodes.GetUVPtStruct();
+}
+// --------------------------------------------------------------------------------
+bool StdMeshers_ViscousLayers2D::HasProxyMesh( const TopoDS_Face& face, SMESH_Mesh& mesh )
+{
+  return VISCOUS_2D::_ProxyMeshHolder::FindProxyMeshOfFace( face, mesh );
+}
+// --------------------------------------------------------------------------------
 SMESH_ComputeErrorPtr
 StdMeshers_ViscousLayers2D::CheckHypothesis(SMESH_Mesh&                          theMesh,
                                             const TopoDS_Shape&                  theShape,
index 4c885e4..cff610b 100644 (file)
@@ -27,6 +27,7 @@
 #include "StdMeshers_ViscousLayers.hxx"
 
 class TopoDS_Face;
+class StdMeshers_FaceSide;
 
 /*!
  * \brief Hypothesis defining parameters of viscous layers
@@ -72,6 +73,9 @@ public:
 
   static const char* GetHypType() { return "ViscousLayers2D"; }
 
+  static void SetProxyMeshOfEdge( const StdMeshers_FaceSide& edgeNodes );
+  static bool HasProxyMesh( const TopoDS_Face& face, SMESH_Mesh& theMesh );
+
  private:
 };
 
index cf98854..ee39c26 100644 (file)
@@ -53,7 +53,6 @@ StdMeshers_ViscousLayers_i::StdMeshers_ViscousLayers_i( PortableServer::POA_ptr
   : SALOME::GenericObj_i( thePOA ), 
     SMESH_Hypothesis_i( thePOA )
 {
-  MESSAGE( "StdMeshers_ViscousLayers_i::StdMeshers_ViscousLayers_i" );
   myBaseImpl = new ::StdMeshers_ViscousLayers( theGenImpl->GetANewId(),
                                                theStudyId,
                                                theGenImpl );
@@ -69,7 +68,6 @@ StdMeshers_ViscousLayers_i::StdMeshers_ViscousLayers_i( PortableServer::POA_ptr
 
 StdMeshers_ViscousLayers_i::~StdMeshers_ViscousLayers_i()
 {
-  MESSAGE( "StdMeshers_ViscousLayers_i::~StdMeshers_ViscousLayers_i" );
 }
 
 //================================================================================
@@ -265,7 +263,6 @@ void StdMeshers_ViscousLayers_i::SetMethod( ::StdMeshers::VLExtrusionMethod how
 
 ::StdMeshers_ViscousLayers* StdMeshers_ViscousLayers_i::GetImpl()
 {
-  MESSAGE( "StdMeshers_ViscousLayers_i::GetImpl" );
   return ( ::StdMeshers_ViscousLayers* )myBaseImpl;
 }