Salome HOME
IPAL52557: TC7.5.0: default value in Hypothesis is different in new and saved studies
[modules/smesh.git] / src / StdMeshers / StdMeshers_ViscousLayers.cxx
1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 // File      : StdMeshers_ViscousLayers.cxx
21 // Created   : Wed Dec  1 15:15:34 2010
22 // Author    : Edward AGAPOV (eap)
23
24 #include "StdMeshers_ViscousLayers.hxx"
25
26 #include "SMDS_EdgePosition.hxx"
27 #include "SMDS_FaceOfNodes.hxx"
28 #include "SMDS_FacePosition.hxx"
29 #include "SMDS_MeshNode.hxx"
30 #include "SMDS_SetIterator.hxx"
31 #include "SMESHDS_Group.hxx"
32 #include "SMESHDS_Hypothesis.hxx"
33 #include "SMESH_Algo.hxx"
34 #include "SMESH_ComputeError.hxx"
35 #include "SMESH_ControlsDef.hxx"
36 #include "SMESH_Gen.hxx"
37 #include "SMESH_Group.hxx"
38 #include "SMESH_HypoFilter.hxx"
39 #include "SMESH_Mesh.hxx"
40 #include "SMESH_MeshAlgos.hxx"
41 #include "SMESH_MesherHelper.hxx"
42 #include "SMESH_ProxyMesh.hxx"
43 #include "SMESH_subMesh.hxx"
44 #include "SMESH_subMeshEventListener.hxx"
45 #include "StdMeshers_FaceSide.hxx"
46
47 #include <Adaptor3d_HSurface.hxx>
48 #include <BRepAdaptor_Curve2d.hxx>
49 #include <BRepAdaptor_Surface.hxx>
50 #include <BRepLProp_SLProps.hxx>
51 #include <BRep_Tool.hxx>
52 #include <Bnd_B2d.hxx>
53 #include <Bnd_B3d.hxx>
54 #include <ElCLib.hxx>
55 #include <GCPnts_AbscissaPoint.hxx>
56 #include <Geom2d_Circle.hxx>
57 #include <Geom2d_Line.hxx>
58 #include <Geom2d_TrimmedCurve.hxx>
59 #include <GeomAdaptor_Curve.hxx>
60 #include <GeomLib.hxx>
61 #include <Geom_Circle.hxx>
62 #include <Geom_Curve.hxx>
63 #include <Geom_Line.hxx>
64 #include <Geom_TrimmedCurve.hxx>
65 #include <Precision.hxx>
66 #include <Standard_ErrorHandler.hxx>
67 #include <Standard_Failure.hxx>
68 #include <TColStd_Array1OfReal.hxx>
69 #include <TopExp.hxx>
70 #include <TopExp_Explorer.hxx>
71 #include <TopTools_IndexedMapOfShape.hxx>
72 #include <TopTools_ListOfShape.hxx>
73 #include <TopTools_MapOfShape.hxx>
74 #include <TopoDS.hxx>
75 #include <TopoDS_Edge.hxx>
76 #include <TopoDS_Face.hxx>
77 #include <TopoDS_Vertex.hxx>
78 #include <gp_Ax1.hxx>
79 #include <gp_Cone.hxx>
80 #include <gp_Sphere.hxx>
81 #include <gp_Vec.hxx>
82 #include <gp_XY.hxx>
83
84 #include <list>
85 #include <string>
86 #include <cmath>
87 #include <limits>
88
89 #ifdef _DEBUG_
90 //#define __myDEBUG
91 //#define __NOT_INVALIDATE_BAD_SMOOTH
92 #endif
93
94 using namespace std;
95
96 //================================================================================
97 namespace VISCOUS_3D
98 {
99   typedef int TGeomID;
100
101   enum UIndex { U_TGT = 1, U_SRC, LEN_TGT };
102
103   const double theMinSmoothCosin = 0.1;
104   const double theSmoothThickToElemSizeRatio = 0.3;
105
106   // what part of thickness is allowed till intersection
107   // (defined by SALOME_TESTS/Grids/smesh/viscous_layers_00/A5)
108   const double theThickToIntersection = 1.5;
109
110   bool needSmoothing( double cosin, double tgtThick, double elemSize )
111   {
112     return cosin * tgtThick > theSmoothThickToElemSizeRatio * elemSize;
113   }
114
115   /*!
116    * \brief SMESH_ProxyMesh computed by _ViscousBuilder for a SOLID.
117    * It is stored in a SMESH_subMesh of the SOLID as SMESH_subMeshEventListenerData
118    */
119   struct _MeshOfSolid : public SMESH_ProxyMesh,
120                         public SMESH_subMeshEventListenerData
121   {
122     bool                  _n2nMapComputed;
123     SMESH_ComputeErrorPtr _warning;
124
125     _MeshOfSolid( SMESH_Mesh* mesh)
126       :SMESH_subMeshEventListenerData( /*isDeletable=*/true),_n2nMapComputed(false)
127     {
128       SMESH_ProxyMesh::setMesh( *mesh );
129     }
130
131     // returns submesh for a geom face
132     SMESH_ProxyMesh::SubMesh* getFaceSubM(const TopoDS_Face& F, bool create=false)
133     {
134       TGeomID i = SMESH_ProxyMesh::shapeIndex(F);
135       return create ? SMESH_ProxyMesh::getProxySubMesh(i) : findProxySubMesh(i);
136     }
137     void setNode2Node(const SMDS_MeshNode*                 srcNode,
138                       const SMDS_MeshNode*                 proxyNode,
139                       const SMESH_ProxyMesh::SubMesh* subMesh)
140     {
141       SMESH_ProxyMesh::setNode2Node( srcNode,proxyNode,subMesh);
142     }
143   };
144   //--------------------------------------------------------------------------------
145   /*!
146    * \brief Listener of events of 3D sub-meshes computed with viscous layers.
147    * It is used to clear an inferior dim sub-meshes modified by viscous layers
148    */
149   class _ShrinkShapeListener : SMESH_subMeshEventListener
150   {
151     _ShrinkShapeListener()
152       : SMESH_subMeshEventListener(/*isDeletable=*/false,
153                                    "StdMeshers_ViscousLayers::_ShrinkShapeListener") {}
154   public:
155     static SMESH_subMeshEventListener* Get() { static _ShrinkShapeListener l; return &l; }
156     virtual void ProcessEvent(const int                       event,
157                               const int                       eventType,
158                               SMESH_subMesh*                  solidSM,
159                               SMESH_subMeshEventListenerData* data,
160                               const SMESH_Hypothesis*         hyp)
161     {
162       if ( SMESH_subMesh::COMPUTE_EVENT == eventType && solidSM->IsEmpty() && data )
163       {
164         SMESH_subMeshEventListener::ProcessEvent(event,eventType,solidSM,data,hyp);
165       }
166     }
167   };
168   //--------------------------------------------------------------------------------
169   /*!
170    * \brief Listener of events of 3D sub-meshes computed with viscous layers.
171    * It is used to store data computed by _ViscousBuilder for a sub-mesh and to
172    * delete the data as soon as it has been used
173    */
174   class _ViscousListener : SMESH_subMeshEventListener
175   {
176     _ViscousListener():
177       SMESH_subMeshEventListener(/*isDeletable=*/false,
178                                  "StdMeshers_ViscousLayers::_ViscousListener") {}
179     static SMESH_subMeshEventListener* Get() { static _ViscousListener l; return &l; }
180   public:
181     virtual void ProcessEvent(const int                       event,
182                               const int                       eventType,
183                               SMESH_subMesh*                  subMesh,
184                               SMESH_subMeshEventListenerData* data,
185                               const SMESH_Hypothesis*         hyp)
186     {
187       if ( SMESH_subMesh::COMPUTE_EVENT       == eventType &&
188            SMESH_subMesh::CHECK_COMPUTE_STATE != event)
189       {
190         // delete SMESH_ProxyMesh containing temporary faces
191         subMesh->DeleteEventListener( this );
192       }
193     }
194     // Finds or creates proxy mesh of the solid
195     static _MeshOfSolid* GetSolidMesh(SMESH_Mesh*         mesh,
196                                       const TopoDS_Shape& solid,
197                                       bool                toCreate=false)
198     {
199       if ( !mesh ) return 0;
200       SMESH_subMesh* sm = mesh->GetSubMesh(solid);
201       _MeshOfSolid* data = (_MeshOfSolid*) sm->GetEventListenerData( Get() );
202       if ( !data && toCreate )
203       {
204         data = new _MeshOfSolid(mesh);
205         data->mySubMeshes.push_back( sm ); // to find SOLID by _MeshOfSolid
206         sm->SetEventListener( Get(), data, sm );
207       }
208       return data;
209     }
210     // Removes proxy mesh of the solid
211     static void RemoveSolidMesh(SMESH_Mesh* mesh, const TopoDS_Shape& solid)
212     {
213       mesh->GetSubMesh(solid)->DeleteEventListener( _ViscousListener::Get() );
214     }
215   };
216   
217   //================================================================================
218   /*!
219    * \brief sets a sub-mesh event listener to clear sub-meshes of sub-shapes of
220    * the main shape when sub-mesh of the main shape is cleared,
221    * for example to clear sub-meshes of FACEs when sub-mesh of a SOLID
222    * is cleared
223    */
224   //================================================================================
225
226   void ToClearSubWithMain( SMESH_subMesh* sub, const TopoDS_Shape& main)
227   {
228     SMESH_subMesh* mainSM = sub->GetFather()->GetSubMesh( main );
229     SMESH_subMeshEventListenerData* data =
230       mainSM->GetEventListenerData( _ShrinkShapeListener::Get());
231     if ( data )
232     {
233       if ( find( data->mySubMeshes.begin(), data->mySubMeshes.end(), sub ) ==
234            data->mySubMeshes.end())
235         data->mySubMeshes.push_back( sub );
236     }
237     else
238     {
239       data = SMESH_subMeshEventListenerData::MakeData( /*dependent=*/sub );
240       sub->SetEventListener( _ShrinkShapeListener::Get(), data, /*whereToListenTo=*/mainSM );
241     }
242   }
243   struct _SolidData;
244   //--------------------------------------------------------------------------------
245   /*!
246    * \brief Simplex (triangle or tetrahedron) based on 1 (tria) or 2 (tet) nodes of
247    * _LayerEdge and 2 nodes of the mesh surface beening smoothed.
248    * The class is used to check validity of face or volumes around a smoothed node;
249    * it stores only 2 nodes as the other nodes are stored by _LayerEdge.
250    */
251   struct _Simplex
252   {
253     const SMDS_MeshNode *_nPrev, *_nNext; // nodes on a smoothed mesh surface
254     const SMDS_MeshNode *_nOpp; // in 2D case, a node opposite to a smoothed node in QUAD
255     _Simplex(const SMDS_MeshNode* nPrev=0,
256              const SMDS_MeshNode* nNext=0,
257              const SMDS_MeshNode* nOpp=0)
258       : _nPrev(nPrev), _nNext(nNext), _nOpp(nOpp) {}
259     bool IsForward(const SMDS_MeshNode* nSrc, const gp_XYZ* pntTgt, double& vol) const
260     {
261       const double M[3][3] =
262         {{ _nNext->X() - nSrc->X(), _nNext->Y() - nSrc->Y(), _nNext->Z() - nSrc->Z() },
263          { pntTgt->X() - nSrc->X(), pntTgt->Y() - nSrc->Y(), pntTgt->Z() - nSrc->Z() },
264          { _nPrev->X() - nSrc->X(), _nPrev->Y() - nSrc->Y(), _nPrev->Z() - nSrc->Z() }};
265       vol = ( + M[0][0]*M[1][1]*M[2][2]
266               + M[0][1]*M[1][2]*M[2][0]
267               + M[0][2]*M[1][0]*M[2][1]
268               - M[0][0]*M[1][2]*M[2][1]
269               - M[0][1]*M[1][0]*M[2][2]
270               - M[0][2]*M[1][1]*M[2][0]);
271       return vol > 1e-100;
272     }
273     bool IsForward(const gp_XY&         tgtUV,
274                    const SMDS_MeshNode* smoothedNode,
275                    const TopoDS_Face&   face,
276                    SMESH_MesherHelper&  helper,
277                    const double         refSign) const
278     {
279       gp_XY prevUV = helper.GetNodeUV( face, _nPrev, smoothedNode );
280       gp_XY nextUV = helper.GetNodeUV( face, _nNext, smoothedNode );
281       gp_Vec2d v1( tgtUV, prevUV ), v2( tgtUV, nextUV );
282       double d = v1 ^ v2;
283       return d*refSign > 1e-100;
284     }
285     bool IsNeighbour(const _Simplex& other) const
286     {
287       return _nPrev == other._nNext || _nNext == other._nPrev;
288     }
289     static void GetSimplices( const SMDS_MeshNode* node,
290                               vector<_Simplex>&   simplices,
291                               const set<TGeomID>& ingnoreShapes,
292                               const _SolidData*   dataToCheckOri = 0,
293                               const bool          toSort = false);
294     static void SortSimplices(vector<_Simplex>& simplices);
295   };
296   //--------------------------------------------------------------------------------
297   /*!
298    * Structure used to take into account surface curvature while smoothing
299    */
300   struct _Curvature
301   {
302     double _r; // radius
303     double _k; // factor to correct node smoothed position
304     double _h2lenRatio; // avgNormProj / (2*avgDist)
305   public:
306     static _Curvature* New( double avgNormProj, double avgDist )
307     {
308       _Curvature* c = 0;
309       if ( fabs( avgNormProj / avgDist ) > 1./200 )
310       {
311         c = new _Curvature;
312         c->_r = avgDist * avgDist / avgNormProj;
313         c->_k = avgDist * avgDist / c->_r / c->_r;
314         //c->_k = avgNormProj / c->_r;
315         c->_k *= ( c->_r < 0 ? 1/1.1 : 1.1 ); // not to be too restrictive
316         c->_h2lenRatio = avgNormProj / ( avgDist + avgDist );
317       }
318       return c;
319     }
320     double lenDelta(double len) const { return _k * ( _r + len ); }
321     double lenDeltaByDist(double dist) const { return dist * _h2lenRatio; }
322   };
323   //--------------------------------------------------------------------------------
324
325   struct _2NearEdges;
326   struct _LayerEdge;
327   typedef map< const SMDS_MeshNode*, _LayerEdge*, TIDCompare > TNode2Edge;
328
329   //--------------------------------------------------------------------------------
330   /*!
331    * \brief Edge normal to surface, connecting a node on solid surface (_nodes[0])
332    * and a node of the most internal layer (_nodes.back())
333    */
334   struct _LayerEdge
335   {
336     typedef gp_XYZ (_LayerEdge::*PSmooFun)();
337
338     vector< const SMDS_MeshNode*> _nodes;
339
340     gp_XYZ              _normal; // to solid surface
341     vector<gp_XYZ>      _pos; // points computed during inflation
342     double              _len; // length achived with the last inflation step
343     double              _cosin; // of angle (_normal ^ surface)
344     double              _lenFactor; // to compute _len taking _cosin into account
345
346     // face or edge w/o layer along or near which _LayerEdge is inflated
347     TopoDS_Shape        _sWOL;
348     // simplices connected to the source node (_nodes[0]);
349     // used for smoothing and quality check of _LayerEdge's based on the FACE
350     vector<_Simplex>    _simplices;
351     PSmooFun            _smooFunction; // smoothing function
352     // data for smoothing of _LayerEdge's based on the EDGE
353     _2NearEdges*        _2neibors;
354
355     _Curvature*         _curvature;
356     // TODO:: detele _Curvature, _plnNorm
357
358     void SetNewLength( double len, SMESH_MesherHelper& helper );
359     bool SetNewLength2d( Handle(Geom_Surface)& surface,
360                          const TopoDS_Face&    F,
361                          SMESH_MesherHelper&   helper );
362     void SetDataByNeighbors( const SMDS_MeshNode* n1,
363                              const SMDS_MeshNode* n2,
364                              SMESH_MesherHelper&  helper);
365     void InvalidateStep( int curStep, bool restoreLength=false );
366     void ChooseSmooFunction(const set< TGeomID >& concaveVertices,
367                             const TNode2Edge&     n2eMap);
368     int  Smooth(const int step, const bool isConcaveFace, const bool findBest);
369     bool SmoothOnEdge(Handle(Geom_Surface)& surface,
370                       const TopoDS_Face&    F,
371                       SMESH_MesherHelper&   helper);
372     bool FindIntersection( SMESH_ElementSearcher&   searcher,
373                            double &                 distance,
374                            const double&            epsilon,
375                            const SMDS_MeshElement** face = 0);
376     bool SegTriaInter( const gp_Ax1&        lastSegment,
377                        const SMDS_MeshNode* n0,
378                        const SMDS_MeshNode* n1,
379                        const SMDS_MeshNode* n2,
380                        double&              dist,
381                        const double&        epsilon) const;
382     gp_Ax1 LastSegment(double& segLen) const;
383     gp_XY  LastUV( const TopoDS_Face& F ) const;
384     bool   IsOnEdge() const { return _2neibors; }
385     gp_XYZ Copy( _LayerEdge& other, SMESH_MesherHelper& helper );
386     void   SetCosin( double cosin );
387     int    NbSteps() const { return _pos.size() - 1; } // nb inlation steps
388
389     gp_XYZ smoothLaplacian();
390     gp_XYZ smoothAngular();
391     gp_XYZ smoothLengthWeighted();
392     gp_XYZ smoothCentroidal();
393     gp_XYZ smoothNefPolygon();
394
395     enum { FUN_LAPLACIAN, FUN_LENWEIGHTED, FUN_CENTROIDAL, FUN_NEFPOLY, FUN_ANGULAR, FUN_NB };
396     static const int theNbSmooFuns = FUN_NB;
397     static PSmooFun _funs[theNbSmooFuns];
398     static const char* _funNames[theNbSmooFuns+1];
399     int smooFunID( PSmooFun fun=0) const;
400   };
401   _LayerEdge::PSmooFun _LayerEdge::_funs[theNbSmooFuns] = { &_LayerEdge::smoothLaplacian,
402                                                             &_LayerEdge::smoothLengthWeighted,
403                                                             &_LayerEdge::smoothCentroidal,
404                                                             &_LayerEdge::smoothNefPolygon,
405                                                             &_LayerEdge::smoothAngular };
406   const char* _LayerEdge::_funNames[theNbSmooFuns+1] = { "Laplacian",
407                                                          "LengthWeighted",
408                                                          "Centroidal",
409                                                          "NefPolygon",
410                                                          "Angular",
411                                                          "None"};
412   struct _LayerEdgeCmp
413   {
414     bool operator () (const _LayerEdge* e1, const _LayerEdge* e2) const
415     {
416       const bool cmpNodes = ( e1 && e2 && e1->_nodes.size() && e2->_nodes.size() );
417       return cmpNodes ? ( e1->_nodes[0]->GetID() < e2->_nodes[0]->GetID()) : ( e1 < e2 );
418     }
419   };
420   //--------------------------------------------------------------------------------
421   /*!
422    * A 2D half plane used by _LayerEdge::smoothNefPolygon()
423    */
424   struct _halfPlane
425   {
426     gp_XY _pos, _dir, _inNorm;
427     bool IsOut( const gp_XY p, const double tol ) const
428     {
429       return _inNorm * ( p - _pos ) < -tol;
430     }
431     bool FindInterestion( const _halfPlane& hp, gp_XY & intPnt )
432     {
433       const double eps = 1e-10;
434       double D = _dir.Crossed( hp._dir );
435       if ( fabs(D) < std::numeric_limits<double>::min())
436         return false;
437       gp_XY vec21 = _pos - hp._pos; 
438       double u = hp._dir.Crossed( vec21 ) / D; 
439       intPnt = _pos + _dir * u;
440       return true;
441     }
442   };
443   //--------------------------------------------------------------------------------
444   /*!
445    * Structure used to smooth a _LayerEdge based on an EDGE.
446    */
447   struct _2NearEdges
448   {
449     double               _wgt  [2]; // weights of _nodes
450     _LayerEdge*          _edges[2];
451
452      // normal to plane passing through _LayerEdge._normal and tangent of EDGE
453     gp_XYZ*              _plnNorm;
454
455     _2NearEdges() { _edges[0]=_edges[1]=0; _plnNorm = 0; }
456     const SMDS_MeshNode* tgtNode(bool is2nd) {
457       return _edges[is2nd] ? _edges[is2nd]->_nodes.back() : 0;
458     }
459     const SMDS_MeshNode* srcNode(bool is2nd) {
460       return _edges[is2nd] ? _edges[is2nd]->_nodes[0] : 0;
461     }
462     void reverse() {
463       std::swap( _wgt  [0], _wgt  [1] );
464       std::swap( _edges[0], _edges[1] );
465     }
466   };
467   //--------------------------------------------------------------------------------
468   /*!
469    * \brief Convex FACE whose radius of curvature is less than the thickness of 
470    *        layers. It is used to detect distortion of prisms based on a convex
471    *        FACE and to update normals to enable further increasing the thickness
472    */
473   struct _ConvexFace
474   {
475     TopoDS_Face                     _face;
476
477     // edges whose _simplices are used to detect prism destorsion
478     vector< _LayerEdge* >           _simplexTestEdges;
479
480     // map a sub-shape to it's index in _SolidData::_endEdgeOnShape vector
481     map< TGeomID, int >             _subIdToEdgeEnd;
482
483     bool                            _normalsFixed;
484
485     bool GetCenterOfCurvature( _LayerEdge*         ledge,
486                                BRepLProp_SLProps&  surfProp,
487                                SMESH_MesherHelper& helper,
488                                gp_Pnt &            center ) const;
489     bool CheckPrisms() const;
490   };
491
492   //--------------------------------------------------------------------------------
493   /*!
494    * \brief Layers parameters got by averaging several hypotheses
495    */
496   struct AverageHyp
497   {
498     AverageHyp( const StdMeshers_ViscousLayers* hyp = 0 )
499       :_nbLayers(0), _nbHyps(0), _thickness(0), _stretchFactor(0)
500     {
501       Add( hyp );
502     }
503     void Add( const StdMeshers_ViscousLayers* hyp )
504     {
505       if ( hyp )
506       {
507         _nbHyps++;
508         _nbLayers       = hyp->GetNumberLayers();
509         //_thickness     += hyp->GetTotalThickness();
510         _thickness      = Max( _thickness, hyp->GetTotalThickness() );
511         _stretchFactor += hyp->GetStretchFactor();
512       }
513     }
514     double GetTotalThickness() const { return _thickness; /*_nbHyps ? _thickness / _nbHyps : 0;*/ }
515     double GetStretchFactor()  const { return _nbHyps ? _stretchFactor / _nbHyps : 0; }
516     int    GetNumberLayers()   const { return _nbLayers; }
517   private:
518     int     _nbLayers, _nbHyps;
519     double  _thickness, _stretchFactor;
520   };
521
522   //--------------------------------------------------------------------------------
523   /*!
524    * \brief Data of a SOLID
525    */
526   struct _SolidData
527   {
528     typedef const StdMeshers_ViscousLayers* THyp;
529     TopoDS_Shape                    _solid;
530     TGeomID                         _index; // SOLID id
531     _MeshOfSolid*                   _proxyMesh;
532     list< THyp >                    _hyps;
533     list< TopoDS_Shape >            _hypShapes;
534     map< TGeomID, THyp >            _face2hyp; // filled if _hyps.size() > 1
535     set< TGeomID >                  _reversedFaceIds;
536     set< TGeomID >                  _ignoreFaceIds; // WOL FACEs and FACEs of other SOLIDs
537
538     double                          _stepSize, _stepSizeCoeff, _geomSize;
539     const SMDS_MeshNode*            _stepSizeNodes[2];
540
541     TNode2Edge                      _n2eMap; // nodes and _LayerEdge's based on them
542
543     // map to find _n2eMap of another _SolidData by a shrink shape shared by two _SolidData's
544     map< TGeomID, TNode2Edge* >     _s2neMap;
545     // edges of _n2eMap. We keep same data in two containers because
546     // iteration over the map is 5 times longer than over the vector
547     vector< _LayerEdge* >           _edges;
548
549     // key:   an id of shape (EDGE or VERTEX) shared by a FACE with
550     //        layers and a FACE w/o layers
551     // value: the shape (FACE or EDGE) to shrink mesh on.
552     //       _LayerEdge's basing on nodes on key shape are inflated along the value shape
553     map< TGeomID, TopoDS_Shape >     _shrinkShape2Shape;
554
555     // Convex FACEs whose radius of curvature is less than the thickness of layers
556     map< TGeomID, _ConvexFace >      _convexFaces;
557
558     // shapes (EDGEs and VERTEXes) srink from which is forbidden due to collisions with
559     // the adjacent SOLID
560     set< TGeomID >                   _noShrinkShapes;
561
562     // <EDGE to smooth on> to <it's curve> -- for analytic smooth
563     map< TGeomID,Handle(Geom_Curve)> _edge2curve;
564
565     // end indices in _edges of _LayerEdge on each shape, first go shapes to smooth
566     vector< int >                    _endEdgeOnShape;
567     int                              _nbShapesToSmooth;
568     set< TGeomID >                   _concaveFaces;
569
570     // data of averaged StdMeshers_ViscousLayers parameters for each shape with _LayerEdge's
571     vector< AverageHyp >             _hypOnShape;
572     double                           _maxThickness; // of all _hyps
573     double                           _minThickness; // of all _hyps
574
575     double                           _epsilon; // precision for SegTriaInter()
576
577     _SolidData(const TopoDS_Shape& s=TopoDS_Shape(),
578                _MeshOfSolid*       m=0)
579       :_solid(s), _proxyMesh(m) {}
580     ~_SolidData();
581
582     Handle(Geom_Curve) CurveForSmooth( const TopoDS_Edge&    E,
583                                        const int             iFrom,
584                                        const int             iTo,
585                                        const TopoDS_Face&    F,
586                                        SMESH_MesherHelper&   helper,
587                                        vector<_LayerEdge* >* edges=0);
588
589     void SortOnEdge( const TopoDS_Edge&  E,
590                      const int           iFrom,
591                      const int           iTo,
592                      SMESH_MesherHelper& helper);
593
594     void Sort2NeiborsOnEdge( const int iFrom, const int iTo);
595
596     _ConvexFace* GetConvexFace( const TGeomID faceID )
597     {
598       map< TGeomID, _ConvexFace >::iterator id2face = _convexFaces.find( faceID );
599       return id2face == _convexFaces.end() ? 0 : & id2face->second;
600     }
601     void GetEdgesOnShape( size_t end, int &  iBeg, int &  iEnd )
602     {
603       iBeg = end > 0 ? _endEdgeOnShape[ end-1 ] : 0;
604       iEnd = _endEdgeOnShape[ end ];
605     }
606
607     bool GetShapeEdges(const TGeomID shapeID, size_t& iEdgeEnd, int* iBeg=0, int* iEnd=0 ) const;
608
609     void AddShapesToSmooth( const set< TGeomID >& shapeIDs );
610
611     void PrepareEdgesToSmoothOnFace( _LayerEdge**       edgeBeg,
612                                      _LayerEdge**       edgeEnd,
613                                      const TopoDS_Face& face,
614                                      bool               substituteSrcNodes );
615   };
616   //--------------------------------------------------------------------------------
617   /*!
618    * \brief Container of centers of curvature at nodes on an EDGE bounding _ConvexFace
619    */
620   struct _CentralCurveOnEdge
621   {
622     bool                  _isDegenerated;
623     vector< gp_Pnt >      _curvaCenters;
624     vector< _LayerEdge* > _ledges;
625     vector< gp_XYZ >      _normals; // new normal for each of _ledges
626     vector< double >      _segLength2;
627
628     TopoDS_Edge           _edge;
629     TopoDS_Face           _adjFace;
630     bool                  _adjFaceToSmooth;
631
632     void Append( const gp_Pnt& center, _LayerEdge* ledge )
633     {
634       if ( _curvaCenters.size() > 0 )
635         _segLength2.push_back( center.SquareDistance( _curvaCenters.back() ));
636       _curvaCenters.push_back( center );
637       _ledges.push_back( ledge );
638       _normals.push_back( ledge->_normal );
639     }
640     bool FindNewNormal( const gp_Pnt& center, gp_XYZ& newNormal );
641     void SetShapes( const TopoDS_Edge&  edge,
642                     const _ConvexFace&  convFace,
643                     const _SolidData&   data,
644                     SMESH_MesherHelper& helper);
645   };
646   //--------------------------------------------------------------------------------
647   /*!
648    * \brief Data of node on a shrinked FACE
649    */
650   struct _SmoothNode
651   {
652     const SMDS_MeshNode*         _node;
653     vector<_Simplex>             _simplices; // for quality check
654
655     enum SmoothType { LAPLACIAN, CENTROIDAL, ANGULAR, TFI };
656
657     bool Smooth(int&                  badNb,
658                 Handle(Geom_Surface)& surface,
659                 SMESH_MesherHelper&   helper,
660                 const double          refSign,
661                 SmoothType            how,
662                 bool                  set3D);
663
664     gp_XY computeAngularPos(vector<gp_XY>& uv,
665                             const gp_XY&   uvToFix,
666                             const double   refSign );
667   };
668   //--------------------------------------------------------------------------------
669   /*!
670    * \brief Builder of viscous layers
671    */
672   class _ViscousBuilder
673   {
674   public:
675     _ViscousBuilder();
676     // does it's job
677     SMESH_ComputeErrorPtr Compute(SMESH_Mesh&         mesh,
678                                   const TopoDS_Shape& shape);
679     // check validity of hypotheses
680     SMESH_ComputeErrorPtr CheckHypotheses( SMESH_Mesh&         mesh,
681                                            const TopoDS_Shape& shape );
682
683     // restore event listeners used to clear an inferior dim sub-mesh modified by viscous layers
684     void RestoreListeners();
685
686     // computes SMESH_ProxyMesh::SubMesh::_n2n;
687     bool MakeN2NMap( _MeshOfSolid* pm );
688
689   private:
690
691     bool findSolidsWithLayers();
692     bool findFacesWithLayers(const bool onlyWith=false);
693     void getIgnoreFaces(const TopoDS_Shape&             solid,
694                         const StdMeshers_ViscousLayers* hyp,
695                         const TopoDS_Shape&             hypShape,
696                         set<TGeomID>&                   ignoreFaces);
697     bool makeLayer(_SolidData& data);
698     bool setEdgeData(_LayerEdge& edge, const set<TGeomID>& subIds,
699                      SMESH_MesherHelper& helper, _SolidData& data);
700     gp_XYZ getFaceNormal(const SMDS_MeshNode* n,
701                          const TopoDS_Face&   face,
702                          SMESH_MesherHelper&  helper,
703                          bool&                isOK,
704                          bool                 shiftInside=false);
705     bool getFaceNormalAtSingularity(const gp_XY&        uv,
706                                     const TopoDS_Face&  face,
707                                     SMESH_MesherHelper& helper,
708                                     gp_Dir&             normal );
709     gp_XYZ getWeigthedNormal( const SMDS_MeshNode*             n,
710                               std::pair< TopoDS_Face, gp_XYZ > fId2Normal[],
711                               int                              nbFaces );
712     bool findNeiborsOnEdge(const _LayerEdge*     edge,
713                            const SMDS_MeshNode*& n1,
714                            const SMDS_MeshNode*& n2,
715                            _SolidData&           data);
716     void findSimplexTestEdges( _SolidData&                    data,
717                                vector< vector<_LayerEdge*> >& edgesByGeom);
718     void computeGeomSize( _SolidData& data );
719     bool sortEdges( _SolidData&                    data,
720                     vector< vector<_LayerEdge*> >& edgesByGeom);
721     void limitStepSizeByCurvature( _SolidData&  data );
722     void limitStepSize( _SolidData&             data,
723                         const SMDS_MeshElement* face,
724                         const _LayerEdge*       maxCosinEdge );
725     void limitStepSize( _SolidData& data, const double minSize);
726     bool inflate(_SolidData& data);
727     bool smoothAndCheck(_SolidData& data, const int nbSteps, double & distToIntersection);
728     bool smoothAnalyticEdge( _SolidData&           data,
729                              const int             iFrom,
730                              const int             iTo,
731                              Handle(Geom_Surface)& surface,
732                              const TopoDS_Face&    F,
733                              SMESH_MesherHelper&   helper);
734     bool updateNormals( _SolidData& data, SMESH_MesherHelper& helper, int stepNb );
735     bool updateNormalsOfConvexFaces( _SolidData&         data,
736                                      SMESH_MesherHelper& helper,
737                                      int                 stepNb );
738     bool refine(_SolidData& data);
739     bool shrink();
740     bool prepareEdgeToShrink( _LayerEdge& edge, const TopoDS_Face& F,
741                               SMESH_MesherHelper& helper,
742                               const SMESHDS_SubMesh* faceSubMesh );
743     void restoreNoShrink( _LayerEdge& edge ) const;
744     void fixBadFaces(const TopoDS_Face&          F,
745                      SMESH_MesherHelper&         helper,
746                      const bool                  is2D,
747                      const int                   step,
748                      set<const SMDS_MeshNode*> * involvedNodes=NULL);
749     bool addBoundaryElements();
750
751     bool error( const string& text, int solidID=-1 );
752     SMESHDS_Mesh* getMeshDS() const { return _mesh->GetMeshDS(); }
753
754     // debug
755     void makeGroupOfLE();
756
757     SMESH_Mesh*           _mesh;
758     SMESH_ComputeErrorPtr _error;
759
760     vector< _SolidData >  _sdVec;
761     int                   _tmpFaceID;
762   };
763   //--------------------------------------------------------------------------------
764   /*!
765    * \brief Shrinker of nodes on the EDGE
766    */
767   class _Shrinker1D
768   {
769     vector<double>                _initU;
770     vector<double>                _normPar;
771     vector<const SMDS_MeshNode*>  _nodes;
772     const _LayerEdge*             _edges[2];
773     bool                          _done;
774   public:
775     void AddEdge( const _LayerEdge* e, SMESH_MesherHelper& helper );
776     void Compute(bool set3D, SMESH_MesherHelper& helper);
777     void RestoreParams();
778     void SwapSrcTgtNodes(SMESHDS_Mesh* mesh);
779   };
780   //--------------------------------------------------------------------------------
781   /*!
782    * \brief Class of temporary mesh face.
783    * We can't use SMDS_FaceOfNodes since it's impossible to set it's ID which is
784    * needed because SMESH_ElementSearcher internaly uses set of elements sorted by ID
785    */
786   struct _TmpMeshFace : public SMDS_MeshElement
787   {
788     vector<const SMDS_MeshNode* > _nn;
789     _TmpMeshFace( const vector<const SMDS_MeshNode*>& nodes, int id, int faceID=-1):
790       SMDS_MeshElement(id), _nn(nodes) { setShapeId(faceID); }
791     virtual const SMDS_MeshNode* GetNode(const int ind) const { return _nn[ind]; }
792     virtual SMDSAbs_ElementType  GetType() const              { return SMDSAbs_Face; }
793     virtual vtkIdType GetVtkType() const                      { return -1; }
794     virtual SMDSAbs_EntityType   GetEntityType() const        { return SMDSEntity_Last; }
795     virtual SMDSAbs_GeometryType GetGeomType() const
796     { return _nn.size() == 3 ? SMDSGeom_TRIANGLE : SMDSGeom_QUADRANGLE; }
797     virtual SMDS_ElemIteratorPtr elementsIterator(SMDSAbs_ElementType) const
798     { return SMDS_ElemIteratorPtr( new SMDS_NodeVectorElemIterator( _nn.begin(), _nn.end()));}
799   };
800   //--------------------------------------------------------------------------------
801   /*!
802    * \brief Class of temporary mesh face storing _LayerEdge it's based on
803    */
804   struct _TmpMeshFaceOnEdge : public _TmpMeshFace
805   {
806     _LayerEdge *_le1, *_le2;
807     _TmpMeshFaceOnEdge( _LayerEdge* le1, _LayerEdge* le2, int ID ):
808       _TmpMeshFace( vector<const SMDS_MeshNode*>(4), ID ), _le1(le1), _le2(le2)
809     {
810       _nn[0]=_le1->_nodes[0];
811       _nn[1]=_le1->_nodes.back();
812       _nn[2]=_le2->_nodes.back();
813       _nn[3]=_le2->_nodes[0];
814     }
815   };
816   //--------------------------------------------------------------------------------
817   /*!
818    * \brief Retriever of node coordinates either directly of from a surface by node UV.
819    * \warning Location of a surface is ignored
820    */
821   struct _NodeCoordHelper
822   {
823     SMESH_MesherHelper&        _helper;
824     const TopoDS_Face&         _face;
825     Handle(Geom_Surface)       _surface;
826     gp_XYZ (_NodeCoordHelper::* _fun)(const SMDS_MeshNode* n) const;
827
828     _NodeCoordHelper(const TopoDS_Face& F, SMESH_MesherHelper& helper, bool is2D)
829       : _helper( helper ), _face( F )
830     {
831       if ( is2D )
832       {
833         TopLoc_Location loc;
834         _surface = BRep_Tool::Surface( _face, loc );
835       }
836       if ( _surface.IsNull() )
837         _fun = & _NodeCoordHelper::direct;
838       else
839         _fun = & _NodeCoordHelper::byUV;
840     }
841     gp_XYZ operator()(const SMDS_MeshNode* n) const { return (this->*_fun)( n ); }
842
843   private:
844     gp_XYZ direct(const SMDS_MeshNode* n) const
845     {
846       return SMESH_TNodeXYZ( n );
847     }
848     gp_XYZ byUV  (const SMDS_MeshNode* n) const
849     {
850       gp_XY uv = _helper.GetNodeUV( _face, n );
851       return _surface->Value( uv.X(), uv.Y() ).XYZ();
852     }
853   };
854
855 } // namespace VISCOUS_3D
856
857
858
859 //================================================================================
860 // StdMeshers_ViscousLayers hypothesis
861 //
862 StdMeshers_ViscousLayers::StdMeshers_ViscousLayers(int hypId, int studyId, SMESH_Gen* gen)
863   :SMESH_Hypothesis(hypId, studyId, gen),
864    _isToIgnoreShapes(1), _nbLayers(1), _thickness(1), _stretchFactor(1)
865 {
866   _name = StdMeshers_ViscousLayers::GetHypType();
867   _param_algo_dim = -3; // auxiliary hyp used by 3D algos
868 } // --------------------------------------------------------------------------------
869 void StdMeshers_ViscousLayers::SetBndShapes(const std::vector<int>& faceIds, bool toIgnore)
870 {
871   if ( faceIds != _shapeIds )
872     _shapeIds = faceIds, NotifySubMeshesHypothesisModification();
873   if ( _isToIgnoreShapes != toIgnore )
874     _isToIgnoreShapes = toIgnore, NotifySubMeshesHypothesisModification();
875 } // --------------------------------------------------------------------------------
876 void StdMeshers_ViscousLayers::SetTotalThickness(double thickness)
877 {
878   if ( thickness != _thickness )
879     _thickness = thickness, NotifySubMeshesHypothesisModification();
880 } // --------------------------------------------------------------------------------
881 void StdMeshers_ViscousLayers::SetNumberLayers(int nb)
882 {
883   if ( _nbLayers != nb )
884     _nbLayers = nb, NotifySubMeshesHypothesisModification();
885 } // --------------------------------------------------------------------------------
886 void StdMeshers_ViscousLayers::SetStretchFactor(double factor)
887 {
888   if ( _stretchFactor != factor )
889     _stretchFactor = factor, NotifySubMeshesHypothesisModification();
890 } // --------------------------------------------------------------------------------
891 SMESH_ProxyMesh::Ptr
892 StdMeshers_ViscousLayers::Compute(SMESH_Mesh&         theMesh,
893                                   const TopoDS_Shape& theShape,
894                                   const bool          toMakeN2NMap) const
895 {
896   using namespace VISCOUS_3D;
897   _ViscousBuilder bulder;
898   SMESH_ComputeErrorPtr err = bulder.Compute( theMesh, theShape );
899   if ( err && !err->IsOK() )
900     return SMESH_ProxyMesh::Ptr();
901
902   vector<SMESH_ProxyMesh::Ptr> components;
903   TopExp_Explorer exp( theShape, TopAbs_SOLID );
904   for ( ; exp.More(); exp.Next() )
905   {
906     if ( _MeshOfSolid* pm =
907          _ViscousListener::GetSolidMesh( &theMesh, exp.Current(), /*toCreate=*/false))
908     {
909       if ( toMakeN2NMap && !pm->_n2nMapComputed )
910         if ( !bulder.MakeN2NMap( pm ))
911           return SMESH_ProxyMesh::Ptr();
912       components.push_back( SMESH_ProxyMesh::Ptr( pm ));
913       pm->myIsDeletable = false; // it will de deleted by boost::shared_ptr
914
915       if ( pm->_warning && !pm->_warning->IsOK() )
916       {
917         SMESH_subMesh* sm = theMesh.GetSubMesh( exp.Current() );
918         SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
919         if ( !smError || smError->IsOK() )
920           smError = pm->_warning;
921       }
922     }
923     _ViscousListener::RemoveSolidMesh ( &theMesh, exp.Current() );
924   }
925   switch ( components.size() )
926   {
927   case 0: break;
928
929   case 1: return components[0];
930
931   default: return SMESH_ProxyMesh::Ptr( new SMESH_ProxyMesh( components ));
932   }
933   return SMESH_ProxyMesh::Ptr();
934 } // --------------------------------------------------------------------------------
935 std::ostream & StdMeshers_ViscousLayers::SaveTo(std::ostream & save)
936 {
937   save << " " << _nbLayers
938        << " " << _thickness
939        << " " << _stretchFactor
940        << " " << _shapeIds.size();
941   for ( size_t i = 0; i < _shapeIds.size(); ++i )
942     save << " " << _shapeIds[i];
943   save << " " << !_isToIgnoreShapes; // negate to keep the behavior in old studies.
944   return save;
945 } // --------------------------------------------------------------------------------
946 std::istream & StdMeshers_ViscousLayers::LoadFrom(std::istream & load)
947 {
948   int nbFaces, faceID, shapeToTreat;
949   load >> _nbLayers >> _thickness >> _stretchFactor >> nbFaces;
950   while ( _shapeIds.size() < nbFaces && load >> faceID )
951     _shapeIds.push_back( faceID );
952   if ( load >> shapeToTreat )
953     _isToIgnoreShapes = !shapeToTreat;
954   else
955     _isToIgnoreShapes = true; // old behavior
956   return load;
957 } // --------------------------------------------------------------------------------
958 bool StdMeshers_ViscousLayers::SetParametersByMesh(const SMESH_Mesh*   theMesh,
959                                                    const TopoDS_Shape& theShape)
960 {
961   // TODO
962   return false;
963 } // --------------------------------------------------------------------------------
964 SMESH_ComputeErrorPtr
965 StdMeshers_ViscousLayers::CheckHypothesis(SMESH_Mesh&                          theMesh,
966                                           const TopoDS_Shape&                  theShape,
967                                           SMESH_Hypothesis::Hypothesis_Status& theStatus)
968 {
969   VISCOUS_3D::_ViscousBuilder bulder;
970   SMESH_ComputeErrorPtr err = bulder.CheckHypotheses( theMesh, theShape );
971   if ( err && !err->IsOK() )
972     theStatus = SMESH_Hypothesis::HYP_INCOMPAT_HYPS;
973   else
974     theStatus = SMESH_Hypothesis::HYP_OK;
975
976   return err;
977 }
978 // --------------------------------------------------------------------------------
979 bool StdMeshers_ViscousLayers::IsShapeWithLayers(int shapeIndex) const
980 {
981   bool isIn =
982     ( std::find( _shapeIds.begin(), _shapeIds.end(), shapeIndex ) != _shapeIds.end() );
983   return IsToIgnoreShapes() ? !isIn : isIn;
984 }
985 // END StdMeshers_ViscousLayers hypothesis
986 //================================================================================
987
988 namespace VISCOUS_3D
989 {
990   gp_XYZ getEdgeDir( const TopoDS_Edge& E, const TopoDS_Vertex& fromV )
991   {
992     gp_Vec dir;
993     double f,l;
994     Handle(Geom_Curve) c = BRep_Tool::Curve( E, f, l );
995     gp_Pnt p = BRep_Tool::Pnt( fromV );
996     double distF = p.SquareDistance( c->Value( f ));
997     double distL = p.SquareDistance( c->Value( l ));
998     c->D1(( distF < distL ? f : l), p, dir );
999     if ( distL < distF ) dir.Reverse();
1000     return dir.XYZ();
1001   }
1002   //--------------------------------------------------------------------------------
1003   gp_XYZ getEdgeDir( const TopoDS_Edge& E, const SMDS_MeshNode* atNode,
1004                      SMESH_MesherHelper& helper)
1005   {
1006     gp_Vec dir;
1007     double f,l; gp_Pnt p;
1008     Handle(Geom_Curve) c = BRep_Tool::Curve( E, f, l );
1009     if ( c.IsNull() ) return gp_XYZ( 1e100, 1e100, 1e100 );
1010     double u = helper.GetNodeU( E, atNode );
1011     c->D1( u, p, dir );
1012     return dir.XYZ();
1013   }
1014   //--------------------------------------------------------------------------------
1015   gp_XYZ getFaceDir( const TopoDS_Face& F, const TopoDS_Vertex& fromV,
1016                      const SMDS_MeshNode* node, SMESH_MesherHelper& helper, bool& ok,
1017                      double* cosin=0);
1018   //--------------------------------------------------------------------------------
1019   gp_XYZ getFaceDir( const TopoDS_Face& F, const TopoDS_Edge& fromE,
1020                      const SMDS_MeshNode* node, SMESH_MesherHelper& helper, bool& ok)
1021   {
1022     double f,l;
1023     Handle(Geom_Curve) c = BRep_Tool::Curve( fromE, f, l );
1024     if ( c.IsNull() )
1025     {
1026       TopoDS_Vertex v = helper.IthVertex( 0, fromE );
1027       return getFaceDir( F, v, node, helper, ok );
1028     }
1029     gp_XY uv = helper.GetNodeUV( F, node, 0, &ok );
1030     Handle(Geom_Surface) surface = BRep_Tool::Surface( F );
1031     gp_Pnt p; gp_Vec du, dv, norm;
1032     surface->D1( uv.X(),uv.Y(), p, du,dv );
1033     norm = du ^ dv;
1034
1035     double u = helper.GetNodeU( fromE, node, 0, &ok );
1036     c->D1( u, p, du );
1037     TopAbs_Orientation o = helper.GetSubShapeOri( F.Oriented(TopAbs_FORWARD), fromE);
1038     if ( o == TopAbs_REVERSED )
1039       du.Reverse();
1040
1041     gp_Vec dir = norm ^ du;
1042
1043     if ( node->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX &&
1044          helper.IsClosedEdge( fromE ))
1045     {
1046       if ( fabs(u-f) < fabs(u-l)) c->D1( l, p, dv );
1047       else                        c->D1( f, p, dv );
1048       if ( o == TopAbs_REVERSED )
1049         dv.Reverse();
1050       gp_Vec dir2 = norm ^ dv;
1051       dir = dir.Normalized() + dir2.Normalized();
1052     }
1053     return dir.XYZ();
1054   }
1055   //--------------------------------------------------------------------------------
1056   gp_XYZ getFaceDir( const TopoDS_Face& F, const TopoDS_Vertex& fromV,
1057                      const SMDS_MeshNode* node, SMESH_MesherHelper& helper,
1058                      bool& ok, double* cosin)
1059   {
1060     TopoDS_Face faceFrw = F;
1061     faceFrw.Orientation( TopAbs_FORWARD );
1062     double f,l; TopLoc_Location loc;
1063     TopoDS_Edge edges[2]; // sharing a vertex
1064     int nbEdges = 0;
1065     {
1066       TopoDS_Vertex VV[2];
1067       TopExp_Explorer exp( faceFrw, TopAbs_EDGE );
1068       for ( ; exp.More() && nbEdges < 2; exp.Next() )
1069       {
1070         const TopoDS_Edge& e = TopoDS::Edge( exp.Current() );
1071         if ( SMESH_Algo::isDegenerated( e )) continue;
1072         TopExp::Vertices( e, VV[0], VV[1], /*CumOri=*/true );
1073         if ( VV[1].IsSame( fromV )) {
1074           nbEdges += edges[ 0 ].IsNull();
1075           edges[ 0 ] = e;
1076         }
1077         else if ( VV[0].IsSame( fromV )) {
1078           nbEdges += edges[ 1 ].IsNull();
1079           edges[ 1 ] = e;
1080         }
1081       }
1082     }
1083     gp_XYZ dir(0,0,0), edgeDir[2];
1084     if ( nbEdges == 2 )
1085     {
1086       // get dirs of edges going fromV
1087       ok = true;
1088       for ( size_t i = 0; i < nbEdges && ok; ++i )
1089       {
1090         edgeDir[i] = getEdgeDir( edges[i], fromV );
1091         double size2 = edgeDir[i].SquareModulus();
1092         if (( ok = size2 > numeric_limits<double>::min() ))
1093           edgeDir[i] /= sqrt( size2 );
1094       }
1095       if ( !ok ) return dir;
1096
1097       // get angle between the 2 edges
1098       gp_Vec faceNormal;
1099       double angle = helper.GetAngle( edges[0], edges[1], faceFrw, fromV, &faceNormal );
1100       if ( Abs( angle ) < 5 * M_PI/180 )
1101       {
1102         dir = ( faceNormal.XYZ() ^ edgeDir[0].Reversed()) + ( faceNormal.XYZ() ^ edgeDir[1] );
1103       }
1104       else
1105       {
1106         dir = edgeDir[0] + edgeDir[1];
1107         if ( angle < 0 )
1108           dir.Reverse();
1109       }
1110       if ( cosin ) {
1111         double angle = gp_Vec( edgeDir[0] ).Angle( dir );
1112         *cosin = Cos( angle );
1113       }
1114     }
1115     else if ( nbEdges == 1 )
1116     {
1117       dir = getFaceDir( faceFrw, edges[ edges[0].IsNull() ], node, helper, ok );
1118       if ( cosin ) *cosin = 1.;
1119     }
1120     else
1121     {
1122       ok = false;
1123     }
1124
1125     return dir;
1126   }
1127
1128   //================================================================================
1129   /*!
1130    * \brief Finds concave VERTEXes of a FACE
1131    */
1132   //================================================================================
1133
1134   bool getConcaveVertices( const TopoDS_Face&  F,
1135                            SMESH_MesherHelper& helper,
1136                            set< TGeomID >*     vertices = 0)
1137   {
1138     // check angles at VERTEXes
1139     TError error;
1140     TSideVector wires = StdMeshers_FaceSide::GetFaceWires( F, *helper.GetMesh(), 0, error );
1141     for ( size_t iW = 0; iW < wires.size(); ++iW )
1142     {
1143       const int nbEdges = wires[iW]->NbEdges();
1144       if ( nbEdges < 2 && SMESH_Algo::isDegenerated( wires[iW]->Edge(0)))
1145         continue;
1146       for ( int iE1 = 0; iE1 < nbEdges; ++iE1 )
1147       {
1148         if ( SMESH_Algo::isDegenerated( wires[iW]->Edge( iE1 ))) continue;
1149         int iE2 = ( iE1 + 1 ) % nbEdges;
1150         while ( SMESH_Algo::isDegenerated( wires[iW]->Edge( iE2 )))
1151           iE2 = ( iE2 + 1 ) % nbEdges;
1152         TopoDS_Vertex V = wires[iW]->FirstVertex( iE2 );
1153         double angle = helper.GetAngle( wires[iW]->Edge( iE1 ),
1154                                         wires[iW]->Edge( iE2 ), F, V );
1155         if ( angle < -5. * M_PI / 180. )
1156         {
1157           if ( !vertices )
1158             return true;
1159           vertices->insert( helper.GetMeshDS()->ShapeToIndex( V ));
1160         }
1161       }
1162     }
1163     return vertices ? !vertices->empty() : false;
1164   }
1165
1166   //================================================================================
1167   /*!
1168    * \brief Returns true if a FACE is bound by a concave EDGE
1169    */
1170   //================================================================================
1171
1172   bool isConcave( const TopoDS_Face&  F,
1173                   SMESH_MesherHelper& helper,
1174                   set< TGeomID >*     vertices = 0 )
1175   {
1176     bool isConcv = false;
1177     // if ( helper.Count( F, TopAbs_WIRE, /*useMap=*/false) > 1 )
1178     //   return true;
1179     gp_Vec2d drv1, drv2;
1180     gp_Pnt2d p;
1181     TopExp_Explorer eExp( F.Oriented( TopAbs_FORWARD ), TopAbs_EDGE );
1182     for ( ; eExp.More(); eExp.Next() )
1183     {
1184       const TopoDS_Edge& E = TopoDS::Edge( eExp.Current() );
1185       if ( SMESH_Algo::isDegenerated( E )) continue;
1186       // check if 2D curve is concave
1187       BRepAdaptor_Curve2d curve( E, F );
1188       const int nbIntervals = curve.NbIntervals( GeomAbs_C2 );
1189       TColStd_Array1OfReal intervals(1, nbIntervals + 1 );
1190       curve.Intervals( intervals, GeomAbs_C2 );
1191       bool isConvex = true;
1192       for ( int i = 1; i <= nbIntervals && isConvex; ++i )
1193       {
1194         double u1 = intervals( i );
1195         double u2 = intervals( i+1 );
1196         curve.D2( 0.5*( u1+u2 ), p, drv1, drv2 );
1197         double cross = drv2 ^ drv1;
1198         if ( E.Orientation() == TopAbs_REVERSED )
1199           cross = -cross;
1200         isConvex = ( cross > 0.1 ); //-1e-9 );
1201       }
1202       if ( !isConvex )
1203       {
1204         //cout << "Concave FACE " << helper.GetMeshDS()->ShapeToIndex( F ) << endl;
1205         isConcv = true;
1206         if ( vertices )
1207           break;
1208         else
1209           return true;
1210       }
1211     }
1212
1213     // check angles at VERTEXes
1214     if ( getConcaveVertices( F, helper, vertices ))
1215       isConcv = true;
1216
1217     return isConcv;
1218   }
1219
1220   //================================================================================
1221   /*!
1222    * \brief Computes mimimal distance of face in-FACE nodes from an EDGE
1223    *  \param [in] face - the mesh face to treat
1224    *  \param [in] nodeOnEdge - a node on the EDGE
1225    *  \param [out] faceSize - the computed distance
1226    *  \return bool - true if faceSize computed
1227    */
1228   //================================================================================
1229
1230   bool getDistFromEdge( const SMDS_MeshElement* face,
1231                         const SMDS_MeshNode*    nodeOnEdge,
1232                         double &                faceSize )
1233   {
1234     faceSize = Precision::Infinite();
1235     bool done = false;
1236
1237     int nbN  = face->NbCornerNodes();
1238     int iOnE = face->GetNodeIndex( nodeOnEdge );
1239     int iNext[2] = { SMESH_MesherHelper::WrapIndex( iOnE+1, nbN ),
1240                      SMESH_MesherHelper::WrapIndex( iOnE-1, nbN ) };
1241     const SMDS_MeshNode* nNext[2] = { face->GetNode( iNext[0] ),
1242                                       face->GetNode( iNext[1] ) };
1243     gp_XYZ segVec, segEnd = SMESH_TNodeXYZ( nodeOnEdge ); // segment on EDGE
1244     double segLen = -1.;
1245     // look for two neighbor not in-FACE nodes of face
1246     for ( int i = 0; i < 2; ++i )
1247     {
1248       if ( nNext[i]->GetPosition()->GetDim() != 2 &&
1249            nNext[i]->GetID() < nodeOnEdge->GetID() )
1250       {
1251         // look for an in-FACE node
1252         for ( int iN = 0; iN < nbN; ++iN )
1253         {
1254           if ( iN == iOnE || iN == iNext[i] )
1255             continue;
1256           SMESH_TNodeXYZ pInFace = face->GetNode( iN );
1257           gp_XYZ v = pInFace - segEnd;
1258           if ( segLen < 0 )
1259           {
1260             segVec = SMESH_TNodeXYZ( nNext[i] ) - segEnd;
1261             segLen = segVec.Modulus();
1262           }
1263           double distToSeg = v.Crossed( segVec ).Modulus() / segLen;
1264           faceSize = Min( faceSize, distToSeg );
1265           done = true;
1266         }
1267         segLen = -1;
1268       }
1269     }
1270     return done;
1271   }
1272   //================================================================================
1273   /*!
1274    * \brief Return direction of axis or revolution of a surface
1275    */
1276   //================================================================================
1277
1278   bool getRovolutionAxis( const Adaptor3d_Surface& surface,
1279                           gp_Dir &                 axis )
1280   {
1281     switch ( surface.GetType() ) {
1282     case GeomAbs_Cone:
1283     {
1284       gp_Cone cone = surface.Cone();
1285       axis = cone.Axis().Direction();
1286       break;
1287     }
1288     case GeomAbs_Sphere:
1289     {
1290       gp_Sphere sphere = surface.Sphere();
1291       axis = sphere.Position().Direction();
1292       break;
1293     }
1294     case GeomAbs_SurfaceOfRevolution:
1295     {
1296       axis = surface.AxeOfRevolution().Direction();
1297       break;
1298     }
1299     //case GeomAbs_SurfaceOfExtrusion:
1300     case GeomAbs_OffsetSurface:
1301     {
1302       Handle(Adaptor3d_HSurface) base = surface.BasisSurface();
1303       return getRovolutionAxis( base->Surface(), axis );
1304     }
1305     default: return false;
1306     }
1307     return true;
1308   }
1309
1310   //--------------------------------------------------------------------------------
1311   // DEBUG. Dump intermediate node positions into a python script
1312   // HOWTO use: run python commands written in a console to see
1313   //  construction steps of viscous layers
1314 #ifdef __myDEBUG
1315   ofstream* py;
1316   int       theNbPyFunc;
1317   struct PyDump {
1318     PyDump(SMESH_Mesh& m) {
1319       int tag = 3 + m.GetId();
1320       const char* fname = "/tmp/viscous.py";
1321       cout << "execfile('"<<fname<<"')"<<endl;
1322       py = new ofstream(fname);
1323       *py << "import SMESH" << endl
1324           << "from salome.smesh import smeshBuilder" << endl
1325           << "smesh  = smeshBuilder.New(salome.myStudy)" << endl
1326           << "meshSO = smesh.GetCurrentStudy().FindObjectID('0:1:2:" << tag <<"')" << endl
1327           << "mesh   = smesh.Mesh( meshSO.GetObject() )"<<endl;
1328       theNbPyFunc = 0;
1329     }
1330     void Finish() {
1331       if (py) {
1332         *py << "mesh.GroupOnFilter(SMESH.VOLUME,'Viscous Prisms',"
1333           "smesh.GetFilter(SMESH.VOLUME,SMESH.FT_ElemGeomType,'=',SMESH.Geom_PENTA))"<<endl;
1334         *py << "mesh.GroupOnFilter(SMESH.VOLUME,'Neg Volumes',"
1335           "smesh.GetFilter(SMESH.VOLUME,SMESH.FT_Volume3D,'<',0))"<<endl;
1336       }
1337       delete py; py=0;
1338     }
1339     ~PyDump() { Finish(); cout << "NB FUNCTIONS: " << theNbPyFunc << endl; }
1340   };
1341 #define dumpFunction(f) { _dumpFunction(f, __LINE__);}
1342 #define dumpMove(n)     { _dumpMove(n, __LINE__);}
1343 #define dumpMoveComm(n,txt) { _dumpMove(n, __LINE__, txt);}
1344 #define dumpCmd(txt)    { _dumpCmd(txt, __LINE__);}
1345   void _dumpFunction(const string& fun, int ln)
1346   { if (py) *py<< "def "<<fun<<"(): # "<< ln <<endl; cout<<fun<<"()"<<endl; ++theNbPyFunc; }
1347   void _dumpMove(const SMDS_MeshNode* n, int ln, const char* txt="")
1348   { if (py) *py<< "  mesh.MoveNode( "<<n->GetID()<< ", "<< n->X()
1349                << ", "<<n->Y()<<", "<< n->Z()<< ")\t\t # "<< ln <<" "<< txt << endl; }
1350   void _dumpCmd(const string& txt, int ln)
1351   { if (py) *py<< "  "<<txt<<" # "<< ln <<endl; }
1352   void dumpFunctionEnd()
1353   { if (py) *py<< "  return"<< endl; }
1354   void dumpChangeNodes( const SMDS_MeshElement* f )
1355   { if (py) { *py<< "  mesh.ChangeElemNodes( " << f->GetID()<<", [";
1356       for ( int i=1; i < f->NbNodes(); ++i ) *py << f->GetNode(i-1)->GetID()<<", ";
1357       *py << f->GetNode( f->NbNodes()-1 )->GetID() << " ])"<< endl; }}
1358 #define debugMsg( txt ) { cout << txt << " (line: " << __LINE__ << ")" << endl; }
1359 #else
1360   struct PyDump { PyDump(SMESH_Mesh&) {} void Finish() {} };
1361 #define dumpFunction(f) f
1362 #define dumpMove(n)
1363 #define dumpMoveComm(n,txt)
1364 #define dumpCmd(txt)
1365 #define dumpFunctionEnd()
1366 #define dumpChangeNodes(f)
1367 #define debugMsg( txt ) {}
1368 #endif
1369 }
1370
1371 using namespace VISCOUS_3D;
1372
1373 //================================================================================
1374 /*!
1375  * \brief Constructor of _ViscousBuilder
1376  */
1377 //================================================================================
1378
1379 _ViscousBuilder::_ViscousBuilder()
1380 {
1381   _error = SMESH_ComputeError::New(COMPERR_OK);
1382   _tmpFaceID = 0;
1383 }
1384
1385 //================================================================================
1386 /*!
1387  * \brief Stores error description and returns false
1388  */
1389 //================================================================================
1390
1391 bool _ViscousBuilder::error(const string& text, int solidId )
1392 {
1393   const string prefix = string("Viscous layers builder: ");
1394   _error->myName    = COMPERR_ALGO_FAILED;
1395   _error->myComment = prefix + text;
1396   if ( _mesh )
1397   {
1398     SMESH_subMesh* sm = _mesh->GetSubMeshContaining( solidId );
1399     if ( !sm && !_sdVec.empty() )
1400       sm = _mesh->GetSubMeshContaining( solidId = _sdVec[0]._index );
1401     if ( sm && sm->GetSubShape().ShapeType() == TopAbs_SOLID )
1402     {
1403       SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
1404       if ( smError && smError->myAlgo )
1405         _error->myAlgo = smError->myAlgo;
1406       smError = _error;
1407       sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
1408     }
1409     // set KO to all solids
1410     for ( size_t i = 0; i < _sdVec.size(); ++i )
1411     {
1412       if ( _sdVec[i]._index == solidId )
1413         continue;
1414       sm = _mesh->GetSubMesh( _sdVec[i]._solid );
1415       if ( !sm->IsEmpty() )
1416         continue;
1417       SMESH_ComputeErrorPtr& smError = sm->GetComputeError();
1418       if ( !smError || smError->IsOK() )
1419       {
1420         smError = SMESH_ComputeError::New( COMPERR_ALGO_FAILED, prefix + "failed");
1421         sm->ComputeStateEngine( SMESH_subMesh::CHECK_COMPUTE_STATE );
1422       }
1423     }
1424   }
1425   makeGroupOfLE(); // debug
1426
1427   return false;
1428 }
1429
1430 //================================================================================
1431 /*!
1432  * \brief At study restoration, restore event listeners used to clear an inferior
1433  *  dim sub-mesh modified by viscous layers
1434  */
1435 //================================================================================
1436
1437 void _ViscousBuilder::RestoreListeners()
1438 {
1439   // TODO
1440 }
1441
1442 //================================================================================
1443 /*!
1444  * \brief computes SMESH_ProxyMesh::SubMesh::_n2n
1445  */
1446 //================================================================================
1447
1448 bool _ViscousBuilder::MakeN2NMap( _MeshOfSolid* pm )
1449 {
1450   SMESH_subMesh* solidSM = pm->mySubMeshes.front();
1451   TopExp_Explorer fExp( solidSM->GetSubShape(), TopAbs_FACE );
1452   for ( ; fExp.More(); fExp.Next() )
1453   {
1454     SMESHDS_SubMesh* srcSmDS = pm->GetMeshDS()->MeshElements( fExp.Current() );
1455     const SMESH_ProxyMesh::SubMesh* prxSmDS = pm->GetProxySubMesh( fExp.Current() );
1456
1457     if ( !srcSmDS || !prxSmDS || !srcSmDS->NbElements() || !prxSmDS->NbElements() )
1458       continue;
1459     if ( srcSmDS->GetElements()->next() == prxSmDS->GetElements()->next())
1460       continue;
1461
1462     if ( srcSmDS->NbElements() != prxSmDS->NbElements() )
1463       return error( "Different nb elements in a source and a proxy sub-mesh", solidSM->GetId());
1464
1465     SMDS_ElemIteratorPtr srcIt = srcSmDS->GetElements();
1466     SMDS_ElemIteratorPtr prxIt = prxSmDS->GetElements();
1467     while( prxIt->more() )
1468     {
1469       const SMDS_MeshElement* fSrc = srcIt->next();
1470       const SMDS_MeshElement* fPrx = prxIt->next();
1471       if ( fSrc->NbNodes() != fPrx->NbNodes())
1472         return error( "Different elements in a source and a proxy sub-mesh", solidSM->GetId());
1473       for ( int i = 0 ; i < fPrx->NbNodes(); ++i )
1474         pm->setNode2Node( fSrc->GetNode(i), fPrx->GetNode(i), prxSmDS );
1475     }
1476   }
1477   pm->_n2nMapComputed = true;
1478   return true;
1479 }
1480
1481 //================================================================================
1482 /*!
1483  * \brief Does its job
1484  */
1485 //================================================================================
1486
1487 SMESH_ComputeErrorPtr _ViscousBuilder::Compute(SMESH_Mesh&         theMesh,
1488                                                const TopoDS_Shape& theShape)
1489 {
1490   // TODO: set priority of solids during Gen::Compute()
1491
1492   _mesh = & theMesh;
1493
1494   // check if proxy mesh already computed
1495   TopExp_Explorer exp( theShape, TopAbs_SOLID );
1496   if ( !exp.More() )
1497     return error("No SOLID's in theShape"), _error;
1498
1499   if ( _ViscousListener::GetSolidMesh( _mesh, exp.Current(), /*toCreate=*/false))
1500     return SMESH_ComputeErrorPtr(); // everything already computed
1501
1502   PyDump debugDump( theMesh );
1503
1504   // TODO: ignore already computed SOLIDs 
1505   if ( !findSolidsWithLayers())
1506     return _error;
1507
1508   if ( !findFacesWithLayers() )
1509     return _error;
1510
1511   for ( size_t i = 0; i < _sdVec.size(); ++i )
1512   {
1513     if ( ! makeLayer(_sdVec[i]) )
1514       return _error;
1515
1516     if ( _sdVec[i]._edges.size() == 0 )
1517       continue;
1518     
1519     if ( ! inflate(_sdVec[i]) )
1520       return _error;
1521
1522     if ( ! refine(_sdVec[i]) )
1523       return _error;
1524   }
1525   if ( !shrink() )
1526     return _error;
1527
1528   addBoundaryElements();
1529
1530   makeGroupOfLE(); // debug
1531   debugDump.Finish();
1532
1533   return _error;
1534 }
1535
1536 //================================================================================
1537 /*!
1538  * \brief Check validity of hypotheses
1539  */
1540 //================================================================================
1541
1542 SMESH_ComputeErrorPtr _ViscousBuilder::CheckHypotheses( SMESH_Mesh&         mesh,
1543                                                         const TopoDS_Shape& shape )
1544 {
1545   _mesh = & mesh;
1546
1547   if ( _ViscousListener::GetSolidMesh( _mesh, shape, /*toCreate=*/false))
1548     return SMESH_ComputeErrorPtr(); // everything already computed
1549
1550
1551   findSolidsWithLayers();
1552   bool ok = findFacesWithLayers();
1553
1554   // remove _MeshOfSolid's of _SolidData's
1555   for ( size_t i = 0; i < _sdVec.size(); ++i )
1556     _ViscousListener::RemoveSolidMesh( _mesh, _sdVec[i]._solid );
1557
1558   if ( !ok )
1559     return _error;
1560
1561   return SMESH_ComputeErrorPtr();
1562 }
1563
1564 //================================================================================
1565 /*!
1566  * \brief Finds SOLIDs to compute using viscous layers. Fills _sdVec
1567  */
1568 //================================================================================
1569
1570 bool _ViscousBuilder::findSolidsWithLayers()
1571 {
1572   // get all solids
1573   TopTools_IndexedMapOfShape allSolids;
1574   TopExp::MapShapes( _mesh->GetShapeToMesh(), TopAbs_SOLID, allSolids );
1575   _sdVec.reserve( allSolids.Extent());
1576
1577   SMESH_Gen* gen = _mesh->GetGen();
1578   SMESH_HypoFilter filter;
1579   for ( int i = 1; i <= allSolids.Extent(); ++i )
1580   {
1581     // find StdMeshers_ViscousLayers hyp assigned to the i-th solid
1582     SMESH_Algo* algo = gen->GetAlgo( *_mesh, allSolids(i) );
1583     if ( !algo ) continue;
1584     // TODO: check if algo is hidden
1585     const list <const SMESHDS_Hypothesis *> & allHyps =
1586       algo->GetUsedHypothesis(*_mesh, allSolids(i), /*ignoreAuxiliary=*/false);
1587     _SolidData* soData = 0;
1588     list< const SMESHDS_Hypothesis *>::const_iterator hyp = allHyps.begin();
1589     const StdMeshers_ViscousLayers* viscHyp = 0;
1590     for ( ; hyp != allHyps.end(); ++hyp )
1591       if ( viscHyp = dynamic_cast<const StdMeshers_ViscousLayers*>( *hyp ))
1592       {
1593         TopoDS_Shape hypShape;
1594         filter.Init( filter.Is( viscHyp ));
1595         _mesh->GetHypothesis( allSolids(i), filter, true, &hypShape );
1596
1597         if ( !soData )
1598         {
1599           _MeshOfSolid* proxyMesh = _ViscousListener::GetSolidMesh( _mesh,
1600                                                                     allSolids(i),
1601                                                                     /*toCreate=*/true);
1602           _sdVec.push_back( _SolidData( allSolids(i), proxyMesh ));
1603           soData = & _sdVec.back();
1604           soData->_index = getMeshDS()->ShapeToIndex( allSolids(i));
1605         }
1606         soData->_hyps.push_back( viscHyp );
1607         soData->_hypShapes.push_back( hypShape );
1608       }
1609   }
1610   if ( _sdVec.empty() )
1611     return error
1612       ( SMESH_Comment(StdMeshers_ViscousLayers::GetHypType()) << " hypothesis not found",0);
1613
1614   return true;
1615 }
1616
1617 //================================================================================
1618 /*!
1619  * \brief 
1620  */
1621 //================================================================================
1622
1623 bool _ViscousBuilder::findFacesWithLayers(const bool onlyWith)
1624 {
1625   SMESH_MesherHelper helper( *_mesh );
1626   TopExp_Explorer exp;
1627   TopTools_IndexedMapOfShape solids;
1628
1629   // collect all faces to ignore defined by hyp
1630   for ( size_t i = 0; i < _sdVec.size(); ++i )
1631   {
1632     solids.Add( _sdVec[i]._solid );
1633
1634     // get faces to ignore defined by each hyp
1635     typedef const StdMeshers_ViscousLayers* THyp;
1636     typedef std::pair< set<TGeomID>, THyp > TFacesOfHyp;
1637     list< TFacesOfHyp > ignoreFacesOfHyps;
1638     list< THyp >::iterator              hyp = _sdVec[i]._hyps.begin();
1639     list< TopoDS_Shape >::iterator hypShape = _sdVec[i]._hypShapes.begin();
1640     for ( ; hyp != _sdVec[i]._hyps.end(); ++hyp, ++hypShape )
1641     {
1642       ignoreFacesOfHyps.push_back( TFacesOfHyp( set<TGeomID>(), *hyp ));
1643       getIgnoreFaces( _sdVec[i]._solid, *hyp, *hypShape, ignoreFacesOfHyps.back().first );
1644     }
1645
1646     // fill _SolidData::_face2hyp and check compatibility of hypotheses
1647     const int nbHyps = _sdVec[i]._hyps.size();
1648     if ( nbHyps > 1 )
1649     {
1650       // check if two hypotheses define different parameters for the same FACE
1651       list< TFacesOfHyp >::iterator igFacesOfHyp;
1652       for ( exp.Init( _sdVec[i]._solid, TopAbs_FACE ); exp.More(); exp.Next() )
1653       {
1654         const TGeomID faceID = getMeshDS()->ShapeToIndex( exp.Current() );
1655         THyp hyp = 0;
1656         igFacesOfHyp = ignoreFacesOfHyps.begin();
1657         for ( ; igFacesOfHyp != ignoreFacesOfHyps.end(); ++igFacesOfHyp )
1658           if ( ! igFacesOfHyp->first.count( faceID ))
1659           {
1660             if ( hyp )
1661               return error(SMESH_Comment("Several hypotheses define "
1662                                          "Viscous Layers on the face #") << faceID );
1663             hyp = igFacesOfHyp->second;
1664           }
1665         if ( hyp )
1666           _sdVec[i]._face2hyp.insert( make_pair( faceID, hyp ));
1667         else
1668           _sdVec[i]._ignoreFaceIds.insert( faceID );
1669       }
1670
1671       // check if two hypotheses define different number of viscous layers for
1672       // adjacent faces of a solid
1673       set< int > nbLayersSet;
1674       igFacesOfHyp = ignoreFacesOfHyps.begin();
1675       for ( ; igFacesOfHyp != ignoreFacesOfHyps.end(); ++igFacesOfHyp )
1676       {
1677         nbLayersSet.insert( igFacesOfHyp->second->GetNumberLayers() );
1678       }
1679       if ( nbLayersSet.size() > 1 )
1680       {
1681         for ( exp.Init( _sdVec[i]._solid, TopAbs_EDGE ); exp.More(); exp.Next() )
1682         {
1683           PShapeIteratorPtr fIt = helper.GetAncestors( exp.Current(), *_mesh, TopAbs_FACE );
1684           THyp hyp1 = 0, hyp2 = 0;
1685           while( const TopoDS_Shape* face = fIt->next() )
1686           {
1687             const TGeomID faceID = getMeshDS()->ShapeToIndex( *face );
1688             map< TGeomID, THyp >::iterator f2h = _sdVec[i]._face2hyp.find( faceID );
1689             if ( f2h != _sdVec[i]._face2hyp.end() )
1690             {
1691               ( hyp1 ? hyp2 : hyp1 ) = f2h->second;
1692             }
1693           }
1694           if ( hyp1 && hyp2 &&
1695                hyp1->GetNumberLayers() != hyp2->GetNumberLayers() )
1696           {
1697             return error("Two hypotheses define different number of "
1698                          "viscous layers on adjacent faces");
1699           }
1700         }
1701       }
1702     } // if ( nbHyps > 1 )
1703     else
1704     {
1705       _sdVec[i]._ignoreFaceIds.swap( ignoreFacesOfHyps.back().first );
1706     }
1707   } // loop on _sdVec
1708
1709   if ( onlyWith ) // is called to check hypotheses compatibility only
1710     return true;
1711
1712   // fill _SolidData::_reversedFaceIds
1713   for ( size_t i = 0; i < _sdVec.size(); ++i )
1714   {
1715     exp.Init( _sdVec[i]._solid.Oriented( TopAbs_FORWARD ), TopAbs_FACE );
1716     for ( ; exp.More(); exp.Next() )
1717     {
1718       const TopoDS_Face& face = TopoDS::Face( exp.Current() );
1719       const TGeomID faceID = getMeshDS()->ShapeToIndex( face );
1720       if ( //!sdVec[i]._ignoreFaceIds.count( faceID ) &&
1721           helper.NbAncestors( face, *_mesh, TopAbs_SOLID ) > 1 &&
1722           helper.IsReversedSubMesh( face ))
1723       {
1724         _sdVec[i]._reversedFaceIds.insert( faceID );
1725       }
1726     }
1727   }
1728
1729   // Find faces to shrink mesh on (solution 2 in issue 0020832);
1730   TopTools_IndexedMapOfShape shapes;
1731   for ( size_t i = 0; i < _sdVec.size(); ++i )
1732   {
1733     shapes.Clear();
1734     TopExp::MapShapes(_sdVec[i]._solid, TopAbs_EDGE, shapes);
1735     for ( int iE = 1; iE <= shapes.Extent(); ++iE )
1736     {
1737       const TopoDS_Shape& edge = shapes(iE);
1738       // find 2 faces sharing an edge
1739       TopoDS_Shape FF[2];
1740       PShapeIteratorPtr fIt = helper.GetAncestors(edge, *_mesh, TopAbs_FACE);
1741       while ( fIt->more())
1742       {
1743         const TopoDS_Shape* f = fIt->next();
1744         if ( helper.IsSubShape( *f, _sdVec[i]._solid))
1745           FF[ int( !FF[0].IsNull()) ] = *f;
1746       }
1747       if( FF[1].IsNull() ) continue; // seam edge can be shared by 1 FACE only
1748       // check presence of layers on them
1749       int ignore[2];
1750       for ( int j = 0; j < 2; ++j )
1751         ignore[j] = _sdVec[i]._ignoreFaceIds.count ( getMeshDS()->ShapeToIndex( FF[j] ));
1752       if ( ignore[0] == ignore[1] )
1753         continue; // nothing interesting
1754       TopoDS_Shape fWOL = FF[ ignore[0] ? 0 : 1 ];
1755       // check presence of layers on fWOL within an adjacent SOLID
1756       bool collision = false;
1757       PShapeIteratorPtr sIt = helper.GetAncestors( fWOL, *_mesh, TopAbs_SOLID );
1758       while ( const TopoDS_Shape* solid = sIt->next() )
1759         if ( !solid->IsSame( _sdVec[i]._solid ))
1760         {
1761           int iSolid = solids.FindIndex( *solid );
1762           int  iFace = getMeshDS()->ShapeToIndex( fWOL );
1763           if ( iSolid > 0 && !_sdVec[ iSolid-1 ]._ignoreFaceIds.count( iFace ))
1764           {
1765             //_sdVec[i]._noShrinkShapes.insert( iFace );
1766             //fWOL.Nullify();
1767             collision = true;
1768           }
1769         }
1770       // add edge to maps
1771       if ( !fWOL.IsNull())
1772       {
1773         TGeomID edgeInd = getMeshDS()->ShapeToIndex( edge );
1774         _sdVec[i]._shrinkShape2Shape.insert( make_pair( edgeInd, fWOL ));
1775         if ( collision )
1776         {
1777           // _shrinkShape2Shape will be used to temporary inflate _LayerEdge's based
1778           // on the edge but shrink won't be performed
1779           _sdVec[i]._noShrinkShapes.insert( edgeInd );
1780         }
1781       }
1782     }
1783   }
1784   // Exclude from _shrinkShape2Shape FACE's that can't be shrinked since
1785   // the algo of the SOLID sharing the FACE does not support it
1786   set< string > notSupportAlgos; notSupportAlgos.insert("Hexa_3D");
1787   for ( size_t i = 0; i < _sdVec.size(); ++i )
1788   {
1789     map< TGeomID, TopoDS_Shape >::iterator e2f = _sdVec[i]._shrinkShape2Shape.begin();
1790     for ( ; e2f != _sdVec[i]._shrinkShape2Shape.end(); ++e2f )
1791     {
1792       const TopoDS_Shape& fWOL = e2f->second;
1793       const TGeomID     edgeID = e2f->first;
1794       bool notShrinkFace = false;
1795       PShapeIteratorPtr soIt = helper.GetAncestors(fWOL, *_mesh, TopAbs_SOLID);
1796       while ( soIt->more() )
1797       {
1798         const TopoDS_Shape* solid = soIt->next();
1799         if ( _sdVec[i]._solid.IsSame( *solid )) continue;
1800         SMESH_Algo* algo = _mesh->GetGen()->GetAlgo( *_mesh, *solid );
1801         if ( !algo || !notSupportAlgos.count( algo->GetName() )) continue;
1802         notShrinkFace = true;
1803         size_t iSolid = 0;
1804         for ( ; iSolid < _sdVec.size(); ++iSolid )
1805         {
1806           if ( _sdVec[iSolid]._solid.IsSame( *solid ) ) {
1807             if ( _sdVec[iSolid]._shrinkShape2Shape.count( edgeID ))
1808               notShrinkFace = false;
1809             break;
1810           }
1811         }
1812         if ( notShrinkFace )
1813         {
1814           _sdVec[i]._noShrinkShapes.insert( edgeID );
1815
1816           // add VERTEXes of the edge in _noShrinkShapes
1817           TopoDS_Shape edge = getMeshDS()->IndexToShape( edgeID );
1818           for ( TopoDS_Iterator vIt( edge ); vIt.More(); vIt.Next() )
1819             _sdVec[i]._noShrinkShapes.insert( getMeshDS()->ShapeToIndex( vIt.Value() ));
1820
1821           // check if there is a collision with to-shrink-from EDGEs in iSolid
1822           if ( iSolid == _sdVec.size() )
1823             continue; // no VL in the solid
1824           shapes.Clear();
1825           TopExp::MapShapes( fWOL, TopAbs_EDGE, shapes);
1826           for ( int iE = 1; iE <= shapes.Extent(); ++iE )
1827           {
1828             const TopoDS_Edge& E = TopoDS::Edge( shapes( iE ));
1829             const TGeomID    eID = getMeshDS()->ShapeToIndex( E );
1830             if ( eID == edgeID ||
1831                  !_sdVec[iSolid]._shrinkShape2Shape.count( eID ) ||
1832                  _sdVec[i]._noShrinkShapes.count( eID ))
1833               continue;
1834             for ( int is1st = 0; is1st < 2; ++is1st )
1835             {
1836               TopoDS_Vertex V = helper.IthVertex( is1st, E );
1837               if ( _sdVec[i]._noShrinkShapes.count( getMeshDS()->ShapeToIndex( V ) ))
1838               {
1839                 // _sdVec[i]._noShrinkShapes.insert( eID );
1840                 // V = helper.IthVertex( !is1st, E );
1841                 // _sdVec[i]._noShrinkShapes.insert( getMeshDS()->ShapeToIndex( V ));
1842                 //iE = 0; // re-start the loop on EDGEs of fWOL
1843                 return error("No way to make a conformal mesh with "
1844                              "the given set of faces with layers", _sdVec[i]._index);
1845               }
1846             }
1847           }
1848         }
1849
1850       } // while ( soIt->more() )
1851     } // loop on _sdVec[i]._shrinkShape2Shape
1852   } // loop on _sdVec to fill in _SolidData::_noShrinkShapes
1853
1854   // Find the SHAPE along which to inflate _LayerEdge based on VERTEX
1855
1856   for ( size_t i = 0; i < _sdVec.size(); ++i )
1857   {
1858     shapes.Clear();
1859     TopExp::MapShapes(_sdVec[i]._solid, TopAbs_VERTEX, shapes);
1860     for ( int iV = 1; iV <= shapes.Extent(); ++iV )
1861     {
1862       const TopoDS_Shape& vertex = shapes(iV);
1863       // find faces WOL sharing the vertex
1864       vector< TopoDS_Shape > facesWOL;
1865       int totalNbFaces = 0;
1866       PShapeIteratorPtr fIt = helper.GetAncestors(vertex, *_mesh, TopAbs_FACE);
1867       while ( fIt->more())
1868       {
1869         const TopoDS_Shape* f = fIt->next();
1870         if ( helper.IsSubShape( *f, _sdVec[i]._solid ) )
1871         {
1872           totalNbFaces++;
1873           const int fID = getMeshDS()->ShapeToIndex( *f );
1874           if ( _sdVec[i]._ignoreFaceIds.count ( fID ) /*&&
1875                !_sdVec[i]._noShrinkShapes.count( fID )*/)
1876             facesWOL.push_back( *f );
1877         }
1878       }
1879       if ( facesWOL.size() == totalNbFaces || facesWOL.empty() )
1880         continue; // no layers at this vertex or no WOL
1881       TGeomID vInd = getMeshDS()->ShapeToIndex( vertex );
1882       switch ( facesWOL.size() )
1883       {
1884       case 1:
1885       {
1886         helper.SetSubShape( facesWOL[0] );
1887         if ( helper.IsRealSeam( vInd )) // inflate along a seam edge?
1888         {
1889           TopoDS_Shape seamEdge;
1890           PShapeIteratorPtr eIt = helper.GetAncestors(vertex, *_mesh, TopAbs_EDGE);
1891           while ( eIt->more() && seamEdge.IsNull() )
1892           {
1893             const TopoDS_Shape* e = eIt->next();
1894             if ( helper.IsRealSeam( *e ) )
1895               seamEdge = *e;
1896           }
1897           if ( !seamEdge.IsNull() )
1898           {
1899             _sdVec[i]._shrinkShape2Shape.insert( make_pair( vInd, seamEdge ));
1900             break;
1901           }
1902         }
1903         _sdVec[i]._shrinkShape2Shape.insert( make_pair( vInd, facesWOL[0] ));
1904         break;
1905       }
1906       case 2:
1907       {
1908         // find an edge shared by 2 faces
1909         PShapeIteratorPtr eIt = helper.GetAncestors(vertex, *_mesh, TopAbs_EDGE);
1910         while ( eIt->more())
1911         {
1912           const TopoDS_Shape* e = eIt->next();
1913           if ( helper.IsSubShape( *e, facesWOL[0]) &&
1914                helper.IsSubShape( *e, facesWOL[1]))
1915           {
1916             _sdVec[i]._shrinkShape2Shape.insert( make_pair( vInd, *e )); break;
1917           }
1918         }
1919         break;
1920       }
1921       default:
1922         return error("Not yet supported case", _sdVec[i]._index);
1923       }
1924     }
1925   }
1926
1927   // add FACEs of other SOLIDs to _ignoreFaceIds
1928   for ( size_t i = 0; i < _sdVec.size(); ++i )
1929   {
1930     shapes.Clear();
1931     TopExp::MapShapes(_sdVec[i]._solid, TopAbs_FACE, shapes);
1932
1933     for ( exp.Init( _mesh->GetShapeToMesh(), TopAbs_FACE ); exp.More(); exp.Next() )
1934     {
1935       if ( !shapes.Contains( exp.Current() ))
1936         _sdVec[i]._ignoreFaceIds.insert( getMeshDS()->ShapeToIndex( exp.Current() ));
1937     }
1938   }
1939
1940   return true;
1941 }
1942
1943 //================================================================================
1944 /*!
1945  * \brief Finds FACEs w/o layers for a given SOLID by an hypothesis
1946  */
1947 //================================================================================
1948
1949 void _ViscousBuilder::getIgnoreFaces(const TopoDS_Shape&             solid,
1950                                      const StdMeshers_ViscousLayers* hyp,
1951                                      const TopoDS_Shape&             hypShape,
1952                                      set<TGeomID>&                   ignoreFaceIds)
1953 {
1954   TopExp_Explorer exp;
1955
1956   vector<TGeomID> ids = hyp->GetBndShapes();
1957   if ( hyp->IsToIgnoreShapes() ) // FACEs to ignore are given
1958   {
1959     for ( size_t ii = 0; ii < ids.size(); ++ii )
1960     {
1961       const TopoDS_Shape& s = getMeshDS()->IndexToShape( ids[ii] );
1962       if ( !s.IsNull() && s.ShapeType() == TopAbs_FACE )
1963         ignoreFaceIds.insert( ids[ii] );
1964     }
1965   }
1966   else // FACEs with layers are given
1967   {
1968     exp.Init( solid, TopAbs_FACE );
1969     for ( ; exp.More(); exp.Next() )
1970     {
1971       TGeomID faceInd = getMeshDS()->ShapeToIndex( exp.Current() );
1972       if ( find( ids.begin(), ids.end(), faceInd ) == ids.end() )
1973         ignoreFaceIds.insert( faceInd );
1974     }
1975   }
1976
1977   // ignore internal FACEs if inlets and outlets are specified
1978   if ( hyp->IsToIgnoreShapes() )
1979   {
1980     TopTools_IndexedDataMapOfShapeListOfShape solidsOfFace;
1981     TopExp::MapShapesAndAncestors( hypShape,
1982                                    TopAbs_FACE, TopAbs_SOLID, solidsOfFace);
1983
1984     for ( exp.Init( solid, TopAbs_FACE ); exp.More(); exp.Next() )
1985     {
1986       const TopoDS_Face& face = TopoDS::Face( exp.Current() );
1987       if ( SMESH_MesherHelper::NbAncestors( face, *_mesh, TopAbs_SOLID ) < 2 )
1988         continue;
1989
1990       int nbSolids = solidsOfFace.FindFromKey( face ).Extent();
1991       if ( nbSolids > 1 )
1992         ignoreFaceIds.insert( getMeshDS()->ShapeToIndex( face ));
1993     }
1994   }
1995 }
1996
1997 //================================================================================
1998 /*!
1999  * \brief Create the inner surface of the viscous layer and prepare data for infation
2000  */
2001 //================================================================================
2002
2003 bool _ViscousBuilder::makeLayer(_SolidData& data)
2004 {
2005   // get all sub-shapes to make layers on
2006   set<TGeomID> subIds, faceIds;
2007   subIds = data._noShrinkShapes;
2008   TopExp_Explorer exp( data._solid, TopAbs_FACE );
2009   for ( ; exp.More(); exp.Next() )
2010   {
2011     SMESH_subMesh* fSubM = _mesh->GetSubMesh( exp.Current() );
2012     if ( ! data._ignoreFaceIds.count( fSubM->GetId() ))
2013     {
2014       faceIds.insert( fSubM->GetId() );
2015       SMESH_subMeshIteratorPtr subIt = fSubM->getDependsOnIterator(/*includeSelf=*/true);
2016       while ( subIt->more() )
2017         subIds.insert( subIt->next()->GetId() );
2018     }
2019   }
2020
2021   // make a map to find new nodes on sub-shapes shared with other SOLID
2022   map< TGeomID, TNode2Edge* >::iterator s2ne;
2023   map< TGeomID, TopoDS_Shape >::iterator s2s = data._shrinkShape2Shape.begin();
2024   for (; s2s != data._shrinkShape2Shape.end(); ++s2s )
2025   {
2026     TGeomID shapeInd = s2s->first;
2027     for ( size_t i = 0; i < _sdVec.size(); ++i )
2028     {
2029       if ( _sdVec[i]._index == data._index ) continue;
2030       map< TGeomID, TopoDS_Shape >::iterator s2s2 = _sdVec[i]._shrinkShape2Shape.find( shapeInd );
2031       if ( s2s2 != _sdVec[i]._shrinkShape2Shape.end() &&
2032            *s2s == *s2s2 && !_sdVec[i]._n2eMap.empty() )
2033       {
2034         data._s2neMap.insert( make_pair( shapeInd, &_sdVec[i]._n2eMap ));
2035         break;
2036       }
2037     }
2038   }
2039
2040   // Create temporary faces and _LayerEdge's
2041
2042   dumpFunction(SMESH_Comment("makeLayers_")<<data._index);
2043
2044   data._stepSize = Precision::Infinite();
2045   data._stepSizeNodes[0] = 0;
2046
2047   SMESH_MesherHelper helper( *_mesh );
2048   helper.SetSubShape( data._solid );
2049   helper.SetElementsOnShape( true );
2050
2051   vector< const SMDS_MeshNode*> newNodes; // of a mesh face
2052   TNode2Edge::iterator n2e2;
2053
2054   // collect _LayerEdge's of shapes they are based on
2055   const int nbShapes = getMeshDS()->MaxShapeIndex();
2056   vector< vector<_LayerEdge*> > edgesByGeom( nbShapes+1 );
2057
2058   for ( set<TGeomID>::iterator id = faceIds.begin(); id != faceIds.end(); ++id )
2059   {
2060     SMESHDS_SubMesh* smDS = getMeshDS()->MeshElements( *id );
2061     if ( !smDS ) return error(SMESH_Comment("Not meshed face ") << *id, data._index );
2062
2063     const TopoDS_Face& F = TopoDS::Face( getMeshDS()->IndexToShape( *id ));
2064     SMESH_ProxyMesh::SubMesh* proxySub =
2065       data._proxyMesh->getFaceSubM( F, /*create=*/true);
2066
2067     SMDS_ElemIteratorPtr eIt = smDS->GetElements();
2068     while ( eIt->more() )
2069     {
2070       const SMDS_MeshElement* face = eIt->next();
2071       double          faceMaxCosin = -1;
2072       _LayerEdge*     maxCosinEdge = 0;
2073       int             nbDegenNodes = 0;
2074
2075       newNodes.resize( face->NbCornerNodes() );
2076       for ( size_t i = 0 ; i < newNodes.size(); ++i )
2077       {
2078         const SMDS_MeshNode* n = face->GetNode( i );
2079         const int      shapeID = n->getshapeId();
2080         const bool onDegenShap = helper.IsDegenShape( shapeID );
2081         const bool onDegenEdge = ( onDegenShap && n->GetPosition()->GetDim() == 1 );
2082         if ( onDegenShap )
2083         {
2084           if ( onDegenEdge )
2085           {
2086             // substitute n on a degenerated EDGE with a node on a corresponding VERTEX
2087             const TopoDS_Shape& E = getMeshDS()->IndexToShape( shapeID );
2088             TopoDS_Vertex       V = helper.IthVertex( 0, TopoDS::Edge( E ));
2089             if ( const SMDS_MeshNode* vN = SMESH_Algo::VertexNode( V, getMeshDS() )) {
2090               n = vN;
2091               nbDegenNodes++;
2092             }
2093           }
2094           else
2095           {
2096             nbDegenNodes++;
2097           }
2098         }
2099         TNode2Edge::iterator n2e = data._n2eMap.insert( make_pair( n, (_LayerEdge*)0 )).first;
2100         if ( !(*n2e).second )
2101         {
2102           // add a _LayerEdge
2103           _LayerEdge* edge = new _LayerEdge();
2104           edge->_nodes.push_back( n );
2105           n2e->second = edge;
2106           edgesByGeom[ shapeID ].push_back( edge );
2107           const bool noShrink = data._noShrinkShapes.count( shapeID );
2108
2109           SMESH_TNodeXYZ xyz( n );
2110
2111           // set edge data or find already refined _LayerEdge and get data from it
2112           if (( !noShrink                                                     ) &&
2113               ( n->GetPosition()->GetTypeOfPosition() != SMDS_TOP_FACE        ) &&
2114               (( s2ne = data._s2neMap.find( shapeID )) != data._s2neMap.end() ) &&
2115               (( n2e2 = (*s2ne).second->find( n )) != s2ne->second->end()     ))
2116           {
2117             _LayerEdge* foundEdge = (*n2e2).second;
2118             gp_XYZ        lastPos = edge->Copy( *foundEdge, helper );
2119             foundEdge->_pos.push_back( lastPos );
2120             // location of the last node is modified and we restore it by foundEdge->_pos.back()
2121             const_cast< SMDS_MeshNode* >
2122               ( edge->_nodes.back() )->setXYZ( xyz.X(), xyz.Y(), xyz.Z() );
2123           }
2124           else
2125           {
2126             if ( !noShrink )
2127             {
2128               edge->_nodes.push_back( helper.AddNode( xyz.X(), xyz.Y(), xyz.Z() ));
2129             }
2130             if ( !setEdgeData( *edge, subIds, helper, data ))
2131               return false;
2132           }
2133           dumpMove(edge->_nodes.back());
2134
2135           if ( edge->_cosin > faceMaxCosin )
2136           {
2137             faceMaxCosin = edge->_cosin;
2138             maxCosinEdge = edge;
2139           }
2140         }
2141         newNodes[ i ] = n2e->second->_nodes.back();
2142
2143         if ( onDegenEdge )
2144           data._n2eMap.insert( make_pair( face->GetNode( i ), n2e->second ));
2145       }
2146       if ( newNodes.size() - nbDegenNodes < 2 )
2147         continue;
2148
2149       // create a temporary face
2150       const SMDS_MeshElement* newFace =
2151         new _TmpMeshFace( newNodes, --_tmpFaceID, face->getshapeId() );
2152       proxySub->AddElement( newFace );
2153
2154       // compute inflation step size by min size of element on a convex surface
2155       if ( faceMaxCosin > theMinSmoothCosin )
2156         limitStepSize( data, face, maxCosinEdge );
2157
2158     } // loop on 2D elements on a FACE
2159   } // loop on FACEs of a SOLID
2160
2161   data._epsilon = 1e-7;
2162   if ( data._stepSize < 1. )
2163     data._epsilon *= data._stepSize;
2164
2165   // Put _LayerEdge's into the vector data._edges
2166   if ( !sortEdges( data, edgesByGeom ))
2167     return false;
2168
2169   // limit data._stepSize depending on surface curvature and fill data._convexFaces
2170   limitStepSizeByCurvature( data ); // !!! it must be before node substitution in _Simplex
2171
2172   // Set target nodes into _Simplex and _LayerEdge's to _2NearEdges
2173   TNode2Edge::iterator n2e;
2174   const SMDS_MeshNode* nn[2];
2175   for ( size_t i = 0; i < data._edges.size(); ++i )
2176   {
2177     _LayerEdge* edge = data._edges[i];
2178     if ( edge->IsOnEdge() )
2179     {
2180       // get neighbor nodes
2181       bool hasData = ( edge->_2neibors->_edges[0] );
2182       if ( hasData ) // _LayerEdge is a copy of another one
2183       {
2184         nn[0] = edge->_2neibors->srcNode(0);
2185         nn[1] = edge->_2neibors->srcNode(1);
2186       }
2187       else if ( !findNeiborsOnEdge( edge, nn[0],nn[1], data ))
2188       {
2189         return false;
2190       }
2191       // set neighbor _LayerEdge's
2192       for ( int j = 0; j < 2; ++j )
2193       {
2194         if (( n2e = data._n2eMap.find( nn[j] )) == data._n2eMap.end() )
2195           return error("_LayerEdge not found by src node", data._index);
2196         edge->_2neibors->_edges[j] = n2e->second;
2197       }
2198       if ( !hasData )
2199         edge->SetDataByNeighbors( nn[0], nn[1], helper);
2200     }
2201
2202     for ( size_t j = 0; j < edge->_simplices.size(); ++j )
2203     {
2204       _Simplex& s = edge->_simplices[j];
2205       s._nNext = data._n2eMap[ s._nNext ]->_nodes.back();
2206       s._nPrev = data._n2eMap[ s._nPrev ]->_nodes.back();
2207     }
2208
2209     // For an _LayerEdge on a degenerated EDGE, copy some data from
2210     // a corresponding _LayerEdge on a VERTEX
2211     // (issue 52453, pb on a downloaded SampleCase2-Tet-netgen-mephisto.hdf)
2212     if ( helper.IsDegenShape( edge->_nodes[0]->getshapeId() ))
2213     {
2214       // Generally we should not get here
2215       const TopoDS_Shape& E = getMeshDS()->IndexToShape( edge->_nodes[0]->getshapeId() );
2216       if ( E.ShapeType() != TopAbs_EDGE )
2217         continue;
2218       TopoDS_Vertex V = helper.IthVertex( 0, TopoDS::Edge( E ));
2219       const SMDS_MeshNode* vN = SMESH_Algo::VertexNode( V, getMeshDS() );
2220       if (( n2e = data._n2eMap.find( vN )) == data._n2eMap.end() )
2221         continue;
2222       const _LayerEdge* vEdge = n2e->second;
2223       edge->_normal    = vEdge->_normal;
2224       edge->_lenFactor = vEdge->_lenFactor;
2225       edge->_cosin     = vEdge->_cosin;
2226     }
2227   }
2228
2229   // fix _LayerEdge::_2neibors on EDGEs to smooth
2230   map< TGeomID,Handle(Geom_Curve)>::iterator e2c = data._edge2curve.begin();
2231   for ( ; e2c != data._edge2curve.end(); ++e2c )
2232     if ( !e2c->second.IsNull() )
2233     {
2234       size_t iEdgeEnd; int iBeg, iEnd;
2235       if ( data.GetShapeEdges( e2c->first, iEdgeEnd, &iBeg, &iEnd ))
2236         data.Sort2NeiborsOnEdge( iBeg, iEnd );
2237     }
2238
2239   dumpFunctionEnd();
2240   return true;
2241 }
2242
2243 //================================================================================
2244 /*!
2245  * \brief Compute inflation step size by min size of element on a convex surface
2246  */
2247 //================================================================================
2248
2249 void _ViscousBuilder::limitStepSize( _SolidData&             data,
2250                                      const SMDS_MeshElement* face,
2251                                      const _LayerEdge*       maxCosinEdge )
2252 {
2253   int iN = 0;
2254   double minSize = 10 * data._stepSize;
2255   const int nbNodes = face->NbCornerNodes();
2256   for ( int i = 0; i < nbNodes; ++i )
2257   {
2258     const SMDS_MeshNode* nextN = face->GetNode( SMESH_MesherHelper::WrapIndex( i+1, nbNodes ));
2259     const SMDS_MeshNode*  curN = face->GetNode( i );
2260     if ( nextN->GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE ||
2261          curN-> GetPosition()->GetTypeOfPosition() == SMDS_TOP_FACE )
2262     {
2263       double dist = SMESH_TNodeXYZ( curN ).Distance( nextN );
2264       if ( dist < minSize )
2265         minSize = dist, iN = i;
2266     }
2267   }
2268   double newStep = 0.8 * minSize / maxCosinEdge->_lenFactor;
2269   if ( newStep < data._stepSize )
2270   {
2271     data._stepSize = newStep;
2272     data._stepSizeCoeff = 0.8 / maxCosinEdge->_lenFactor;
2273     data._stepSizeNodes[0] = face->GetNode( iN );
2274     data._stepSizeNodes[1] = face->GetNode( SMESH_MesherHelper::WrapIndex( iN+1, nbNodes ));
2275   }
2276 }
2277
2278 //================================================================================
2279 /*!
2280  * \brief Compute inflation step size by min size of element on a convex surface
2281  */
2282 //================================================================================
2283
2284 void _ViscousBuilder::limitStepSize( _SolidData& data, const double minSize )
2285 {
2286   if ( minSize < data._stepSize )
2287   {
2288     data._stepSize = minSize;
2289     if ( data._stepSizeNodes[0] )
2290     {
2291       double dist =
2292         SMESH_TNodeXYZ(data._stepSizeNodes[0]).Distance(data._stepSizeNodes[1]);
2293       data._stepSizeCoeff = data._stepSize / dist;
2294     }
2295   }
2296 }
2297
2298 //================================================================================
2299 /*!
2300  * \brief Limit data._stepSize by evaluating curvature of shapes and fill data._convexFaces
2301  */
2302 //================================================================================
2303
2304 void _ViscousBuilder::limitStepSizeByCurvature( _SolidData& data )
2305 {
2306   const int nbTestPnt = 5; // on a FACE sub-shape
2307
2308   BRepLProp_SLProps surfProp( 2, 1e-6 );
2309   SMESH_MesherHelper helper( *_mesh );
2310
2311   data._convexFaces.clear();
2312
2313   TopExp_Explorer face( data._solid, TopAbs_FACE );
2314   for ( ; face.More(); face.Next() )
2315   {
2316     const TopoDS_Face& F = TopoDS::Face( face.Current() );
2317     SMESH_subMesh *   sm = _mesh->GetSubMesh( F );
2318     const TGeomID faceID = sm->GetId();
2319     if ( data._ignoreFaceIds.count( faceID )) continue;
2320
2321     BRepAdaptor_Surface surface( F, false );
2322     surfProp.SetSurface( surface );
2323
2324     bool isTooCurved = false;
2325     int iBeg, iEnd;
2326
2327     _ConvexFace cnvFace;
2328     const double        oriFactor = ( F.Orientation() == TopAbs_REVERSED ? +1. : -1. );
2329     SMESH_subMeshIteratorPtr smIt = sm->getDependsOnIterator(/*includeSelf=*/true);
2330     while ( smIt->more() )
2331     {
2332       sm = smIt->next();
2333       const TGeomID subID = sm->GetId();
2334       // find _LayerEdge's of a sub-shape
2335       size_t edgesEnd;
2336       if ( data.GetShapeEdges( subID, edgesEnd, &iBeg, &iEnd ))
2337         cnvFace._subIdToEdgeEnd.insert( make_pair( subID, edgesEnd ));
2338       else
2339         continue;
2340       // check concavity and curvature and limit data._stepSize
2341       const double minCurvature =
2342         1. / ( data._hypOnShape[ edgesEnd ].GetTotalThickness() * ( 1+theThickToIntersection ));
2343       int nbLEdges = iEnd - iBeg;
2344       int iStep    = Max( 1, nbLEdges / nbTestPnt );
2345       for ( ; iBeg < iEnd; iBeg += iStep )
2346       {
2347         gp_XY uv = helper.GetNodeUV( F, data._edges[ iBeg ]->_nodes[0] );
2348         surfProp.SetParameters( uv.X(), uv.Y() );
2349         if ( !surfProp.IsCurvatureDefined() )
2350           continue;
2351         if ( surfProp.MaxCurvature() * oriFactor > minCurvature )
2352         {
2353           limitStepSize( data, 0.9 / surfProp.MaxCurvature() * oriFactor );
2354           isTooCurved = true;
2355         }
2356         if ( surfProp.MinCurvature() * oriFactor > minCurvature )
2357         {
2358           limitStepSize( data, 0.9 / surfProp.MinCurvature() * oriFactor );
2359           isTooCurved = true;
2360         }
2361       }
2362     } // loop on sub-shapes of the FACE
2363
2364     if ( !isTooCurved ) continue;
2365
2366     _ConvexFace & convFace =
2367       data._convexFaces.insert( make_pair( faceID, cnvFace )).first->second;
2368
2369     convFace._face = F;
2370     convFace._normalsFixed = false;
2371
2372     // Fill _ConvexFace::_simplexTestEdges. These _LayerEdge's are used to detect
2373     // prism distortion.
2374     map< TGeomID, int >::iterator id2end = convFace._subIdToEdgeEnd.find( faceID );
2375     if ( id2end != convFace._subIdToEdgeEnd.end() )
2376     {
2377       // there are _LayerEdge's on the FACE it-self;
2378       // select _LayerEdge's near EDGEs
2379       data.GetEdgesOnShape( id2end->second, iBeg, iEnd );
2380       for ( ; iBeg < iEnd; ++iBeg )
2381       {
2382         _LayerEdge* ledge = data._edges[ iBeg ];
2383         for ( size_t j = 0; j < ledge->_simplices.size(); ++j )
2384           if ( ledge->_simplices[j]._nNext->GetPosition()->GetDim() < 2 )
2385           {
2386             convFace._simplexTestEdges.push_back( ledge );
2387             break;
2388           }
2389       }
2390     }
2391     else
2392     {
2393       // where there are no _LayerEdge's on a _ConvexFace,
2394       // as e.g. on a fillet surface with no internal nodes - issue 22580,
2395       // so that collision of viscous internal faces is not detected by check of
2396       // intersection of _LayerEdge's with the viscous internal faces.
2397
2398       set< const SMDS_MeshNode* > usedNodes;
2399
2400       // look for _LayerEdge's with null _sWOL
2401       map< TGeomID, int >::iterator id2end = convFace._subIdToEdgeEnd.begin();
2402       for ( ; id2end != convFace._subIdToEdgeEnd.end(); ++id2end )
2403       {
2404         data.GetEdgesOnShape( id2end->second, iBeg, iEnd );
2405         if ( iBeg >= iEnd || !data._edges[ iBeg ]->_sWOL.IsNull() )
2406           continue;
2407         for ( ; iBeg < iEnd; ++iBeg )
2408         {
2409           _LayerEdge* ledge = data._edges[ iBeg ];
2410           const SMDS_MeshNode* srcNode = ledge->_nodes[0];
2411           if ( !usedNodes.insert( srcNode ).second ) continue;
2412
2413           _Simplex::GetSimplices( srcNode, ledge->_simplices, data._ignoreFaceIds, &data );
2414           for ( size_t i = 0; i < ledge->_simplices.size(); ++i )
2415           {
2416             usedNodes.insert( ledge->_simplices[i]._nPrev );
2417             usedNodes.insert( ledge->_simplices[i]._nNext );
2418           }
2419           convFace._simplexTestEdges.push_back( ledge );
2420         }
2421       }
2422     }
2423   } // loop on FACEs of data._solid
2424 }
2425
2426 //================================================================================
2427 /*!
2428  * \brief Separate shapes (and _LayerEdge's on them) to smooth from the rest ones
2429  */
2430 //================================================================================
2431
2432 bool _ViscousBuilder::sortEdges( _SolidData&                    data,
2433                                  vector< vector<_LayerEdge*> >& edgesByGeom)
2434 {
2435   // define allowed thickness
2436   computeGeomSize( data ); // compute data._geomSize
2437
2438   data._maxThickness = 0;
2439   data._minThickness = 1e100;
2440   list< const StdMeshers_ViscousLayers* >::iterator hyp = data._hyps.begin();
2441   for ( ; hyp != data._hyps.end(); ++hyp )
2442   {
2443     data._maxThickness = Max( data._maxThickness, (*hyp)->GetTotalThickness() );
2444     data._minThickness = Min( data._minThickness, (*hyp)->GetTotalThickness() );
2445   }
2446   const double tgtThick = /*Min( 0.5 * data._geomSize, */data._maxThickness;
2447
2448   // Find shapes needing smoothing; such a shape has _LayerEdge._normal on it's
2449   // boundry inclined to the shape at a sharp angle
2450
2451   list< TGeomID > shapesToSmooth;
2452   TopTools_MapOfShape edgesOfSmooFaces;
2453
2454   SMESH_MesherHelper helper( *_mesh );
2455   bool ok = true;
2456
2457   for ( int isEdge = 0; isEdge < 2; ++isEdge ) // loop on [ FACEs, EDGEs ]
2458   {
2459     const int dim = isEdge ? 1 : 2;
2460
2461     for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS )
2462     {
2463       vector<_LayerEdge*>& eS = edgesByGeom[iS];
2464       if ( eS.empty() ) continue;
2465       if ( eS[0]->_nodes[0]->GetPosition()->GetDim() != dim ) continue;
2466
2467       const TopoDS_Shape& S = getMeshDS()->IndexToShape( iS );
2468       bool needSmooth = false;
2469       switch ( S.ShapeType() )
2470       {
2471       case TopAbs_EDGE: {
2472
2473         const TopoDS_Edge& E = TopoDS::Edge( S );
2474         if ( SMESH_Algo::isDegenerated( E ) || !edgesOfSmooFaces.Contains( E ))
2475           break;
2476
2477         TopoDS_Face F;
2478         if ( !eS[0]->_sWOL.IsNull() && eS[0]->_sWOL.ShapeType() == TopAbs_FACE )
2479           F = TopoDS::Face( eS[0]->_sWOL );
2480
2481         for ( TopoDS_Iterator vIt( S ); vIt.More() && !needSmooth; vIt.Next() )
2482         {
2483           TGeomID iV = getMeshDS()->ShapeToIndex( vIt.Value() );
2484           vector<_LayerEdge*>& eV = edgesByGeom[ iV ];
2485           if ( eV.empty() ) continue;
2486           gp_Vec  eDir = getEdgeDir( TopoDS::Edge( S ), TopoDS::Vertex( vIt.Value() ));
2487           double angle = eDir.Angle( eV[0]->_normal );
2488           double cosin = Cos( angle );
2489           double cosinAbs = Abs( cosin );
2490           if ( cosinAbs > theMinSmoothCosin )
2491           {
2492             // always smooth analytic EDGEs
2493             needSmooth = ! data.CurveForSmooth( E, 0, eS.size(), F, helper, &eS ).IsNull();
2494
2495             // compare tgtThick with the length of an end segment
2496             SMDS_ElemIteratorPtr eIt = eV[0]->_nodes[0]->GetInverseElementIterator(SMDSAbs_Edge);
2497             while ( eIt->more() && !needSmooth )
2498             {
2499               const SMDS_MeshElement* endSeg = eIt->next();
2500               if ( endSeg->getshapeId() == iS )
2501               {
2502                 double segLen =
2503                   SMESH_TNodeXYZ( endSeg->GetNode(0) ).Distance( endSeg->GetNode(1 ));
2504                 needSmooth = needSmoothing( cosinAbs, tgtThick, segLen );
2505               }
2506             }
2507           }
2508         }
2509         break;
2510       }
2511       case TopAbs_FACE: {
2512
2513         for ( TopExp_Explorer eExp( S, TopAbs_EDGE ); eExp.More() && !needSmooth; eExp.Next() )
2514         {
2515           TGeomID iE = getMeshDS()->ShapeToIndex( eExp.Current() );
2516           vector<_LayerEdge*>& eE = edgesByGeom[ iE ];
2517           if ( eE.empty() ) continue;
2518           // TopLoc_Location loc;
2519           // Handle(Geom_Surface) surface = BRep_Tool::Surface( TopoDS::Face( S ), loc );
2520           // bool isPlane = GeomLib_IsPlanarSurface( surface ).IsPlanar();
2521           //if ( eE[0]->_sWOL.IsNull() )
2522           {
2523             double faceSize;
2524             for ( size_t i = 0; i < eE.size() && !needSmooth; ++i )
2525               if ( eE[i]->_cosin > theMinSmoothCosin )
2526               {
2527                 SMDS_ElemIteratorPtr fIt = eE[i]->_nodes[0]->GetInverseElementIterator(SMDSAbs_Face);
2528                 while ( fIt->more() && !needSmooth )
2529                 {
2530                   const SMDS_MeshElement* face = fIt->next();
2531                   if ( getDistFromEdge( face, eE[i]->_nodes[0], faceSize ))
2532                     needSmooth = needSmoothing( eE[i]->_cosin, tgtThick, faceSize );
2533                 }
2534               }
2535           }
2536           // else
2537           // {
2538           //   const TopoDS_Face& F1 = TopoDS::Face( S );
2539           //   const TopoDS_Face& F2 = TopoDS::Face( eE[0]->_sWOL );
2540           //   const TopoDS_Edge& E  = TopoDS::Edge( eExp.Current() );
2541           //   for ( size_t i = 0; i < eE.size() && !needSmooth; ++i )
2542           //   {
2543           //     gp_Vec dir1 = getFaceDir( F1, E, eE[i]->_nodes[0], helper, ok );
2544           //     gp_Vec dir2 = getFaceDir( F2, E, eE[i]->_nodes[0], helper, ok );
2545           //     double angle = dir1.Angle(  );
2546           //     double cosin = cos( angle );
2547           //     needSmooth = ( cosin > theMinSmoothCosin );
2548           //   }
2549           // }
2550         }
2551         if ( needSmooth )
2552           for ( TopExp_Explorer eExp( S, TopAbs_EDGE ); eExp.More(); eExp.Next() )
2553             edgesOfSmooFaces.Add( eExp.Current() );
2554
2555         break;
2556       }
2557       case TopAbs_VERTEX:
2558         continue;
2559       default:;
2560       }
2561
2562       if ( needSmooth )
2563       {
2564         if ( S.ShapeType() == TopAbs_EDGE ) shapesToSmooth.push_front( iS );
2565         else                                shapesToSmooth.push_back ( iS );
2566
2567         // preparation for smoothing
2568         if ( S.ShapeType() == TopAbs_FACE )
2569         {
2570           data.PrepareEdgesToSmoothOnFace( & eS[0],
2571                                            & eS[0] + eS.size(),
2572                                            TopoDS::Face( S ),
2573                                            /*substituteSrcNodes=*/false);
2574         }
2575       }
2576
2577     } // loop on edgesByGeom
2578   } //  // loop on [ FACEs, EDGEs ]
2579
2580   data._edges.reserve( data._n2eMap.size() );
2581   data._endEdgeOnShape.clear();
2582
2583   // first we put _LayerEdge's on shapes to smooth
2584   data._nbShapesToSmooth = 0;
2585   list< TGeomID >::iterator gIt = shapesToSmooth.begin();
2586   for ( ; gIt != shapesToSmooth.end(); ++gIt )
2587   {
2588     vector<_LayerEdge*>& eVec = edgesByGeom[ *gIt ];
2589     if ( eVec.empty() ) continue;
2590     data._edges.insert( data._edges.end(), eVec.begin(), eVec.end() );
2591     data._endEdgeOnShape.push_back( data._edges.size() );
2592     data._nbShapesToSmooth++;
2593     eVec.clear();
2594   }
2595
2596   // then the rest _LayerEdge's
2597   for ( size_t iS = 0; iS < edgesByGeom.size(); ++iS )
2598   {
2599     vector<_LayerEdge*>& eVec = edgesByGeom[iS];
2600     if ( eVec.empty() ) continue;
2601     data._edges.insert( data._edges.end(), eVec.begin(), eVec.end() );
2602     data._endEdgeOnShape.push_back( data._edges.size() );
2603     //eVec.clear();
2604   }
2605
2606   // compute average StdMeshers_ViscousLayers parameters for each shape
2607
2608   data._hypOnShape.clear();
2609   if ( data._hyps.size() == 1 )
2610   {
2611     data._hypOnShape.resize( data._endEdgeOnShape.size(), AverageHyp( data._hyps.back() ));
2612   }
2613   else
2614   {
2615     data._hypOnShape.resize( data._endEdgeOnShape.size() );
2616     map< TGeomID, const StdMeshers_ViscousLayers* >::iterator f2hyp;
2617     for ( size_t i = 0; i < data._endEdgeOnShape.size(); ++i )
2618     {
2619       int       iEnd = data._endEdgeOnShape[i];
2620       _LayerEdge* LE = data._edges[ iEnd-1 ];
2621       TGeomID iShape = LE->_nodes[0]->getshapeId();
2622       const TopoDS_Shape& S = getMeshDS()->IndexToShape( iShape );
2623       if ( S.ShapeType() == TopAbs_FACE )
2624       {
2625         if (( f2hyp = data._face2hyp.find( iShape )) != data._face2hyp.end() )
2626         {
2627           data._hypOnShape[ i ].Add( f2hyp->second );
2628         }
2629       }
2630       else
2631       {
2632         PShapeIteratorPtr fIt = SMESH_MesherHelper::GetAncestors( S, *_mesh, TopAbs_FACE );
2633         while ( const TopoDS_Shape* face = fIt->next() )
2634         {
2635           TGeomID faceID = getMeshDS()->ShapeToIndex( *face );
2636           if (( f2hyp = data._face2hyp.find( faceID )) != data._face2hyp.end() )
2637           {
2638             data._hypOnShape[ i ].Add( f2hyp->second );
2639           }
2640         }
2641       }
2642     }
2643   }
2644
2645   return ok;
2646 }
2647
2648 //================================================================================
2649 /*!
2650  * \brief Set data of _LayerEdge needed for smoothing
2651  *  \param subIds - ids of sub-shapes of a SOLID to take into account faces from
2652  */
2653 //================================================================================
2654
2655 bool _ViscousBuilder::setEdgeData(_LayerEdge&         edge,
2656                                   const set<TGeomID>& subIds,
2657                                   SMESH_MesherHelper& helper,
2658                                   _SolidData&         data)
2659 {
2660   SMESH_MeshEditor editor(_mesh);
2661
2662   const SMDS_MeshNode* node = edge._nodes[0]; // source node
2663   const SMDS_TypeOfPosition posType = node->GetPosition()->GetTypeOfPosition();
2664
2665   edge._len       = 0;
2666   edge._2neibors  = 0;
2667   edge._curvature = 0;
2668
2669   // --------------------------
2670   // Compute _normal and _cosin
2671   // --------------------------
2672
2673   edge._cosin = 0;
2674   edge._normal.SetCoord(0,0,0);
2675
2676   int totalNbFaces = 0;
2677   TopoDS_Face F;
2678   std::pair< TopoDS_Face, gp_XYZ > face2Norm[20];
2679   gp_Vec geomNorm;
2680   bool normOK = true;
2681
2682   // get geom FACEs the node lies on
2683   {
2684     set<TGeomID> faceIds;
2685     if  ( posType == SMDS_TOP_FACE )
2686     {
2687       faceIds.insert( node->getshapeId() );
2688     }
2689     else
2690     {
2691       SMDS_ElemIteratorPtr fIt = node->GetInverseElementIterator(SMDSAbs_Face);
2692       while ( fIt->more() )
2693         faceIds.insert( editor.FindShape(fIt->next()));
2694     }
2695     set<TGeomID>::iterator id = faceIds.begin();
2696     for ( ; id != faceIds.end(); ++id )
2697     {
2698       const TopoDS_Shape& s = getMeshDS()->IndexToShape( *id );
2699       if ( s.IsNull() || s.ShapeType() != TopAbs_FACE || !subIds.count( *id ))
2700         continue;
2701       F = TopoDS::Face( s );
2702       face2Norm[ totalNbFaces ].first = F;
2703       totalNbFaces++;
2704     }
2705   }
2706
2707   const TGeomID shapeInd = node->getshapeId();
2708   map< TGeomID, TopoDS_Shape >::const_iterator s2s = data._shrinkShape2Shape.find( shapeInd );
2709   const bool onShrinkShape ( s2s != data._shrinkShape2Shape.end() );
2710
2711   // find _normal
2712   if ( onShrinkShape ) // one of faces the node is on has no layers
2713   {
2714     TopoDS_Shape vertEdge = getMeshDS()->IndexToShape( s2s->first ); // vertex or edge
2715     if ( s2s->second.ShapeType() == TopAbs_EDGE )
2716     {
2717       // inflate from VERTEX along EDGE
2718       edge._normal = getEdgeDir( TopoDS::Edge( s2s->second ), TopoDS::Vertex( vertEdge ));
2719     }
2720     else if ( vertEdge.ShapeType() == TopAbs_VERTEX )
2721     {
2722       // inflate from VERTEX along FACE
2723       edge._normal = getFaceDir( TopoDS::Face( s2s->second ), TopoDS::Vertex( vertEdge ),
2724                                  node, helper, normOK, &edge._cosin);
2725     }
2726     else
2727     {
2728       // inflate from EDGE along FACE
2729       edge._normal = getFaceDir( TopoDS::Face( s2s->second ), TopoDS::Edge( vertEdge ),
2730                                  node, helper, normOK);
2731     }
2732   }
2733   else // layers are on all faces of SOLID the node is on
2734   {
2735     int nbOkNorms = 0;
2736     for ( int iF = 0; iF < totalNbFaces; ++iF )
2737     {
2738       F = TopoDS::Face( face2Norm[ iF ].first );
2739       geomNorm = getFaceNormal( node, F, helper, normOK );
2740       if ( !normOK ) continue;
2741       nbOkNorms++;
2742
2743       if ( helper.GetSubShapeOri( data._solid, F ) != TopAbs_REVERSED )
2744         geomNorm.Reverse();
2745       face2Norm[ iF ].second = geomNorm.XYZ();
2746       edge._normal += geomNorm.XYZ();
2747     }
2748     if ( nbOkNorms == 0 )
2749       return error(SMESH_Comment("Can't get normal to node ") << node->GetID(), data._index);
2750
2751     if ( edge._normal.Modulus() < 1e-3 && nbOkNorms > 1 )
2752     {
2753       // opposite normals, re-get normals at shifted positions (IPAL 52426)
2754       edge._normal.SetCoord( 0,0,0 );
2755       for ( int iF = 0; iF < totalNbFaces; ++iF )
2756       {
2757         const TopoDS_Face& F = face2Norm[iF].first;
2758         geomNorm = getFaceNormal( node, F, helper, normOK, /*shiftInside=*/true );
2759         if ( helper.GetSubShapeOri( data._solid, F ) != TopAbs_REVERSED )
2760           geomNorm.Reverse();
2761         if ( normOK )
2762           face2Norm[ iF ].second = geomNorm.XYZ();
2763         edge._normal += face2Norm[ iF ].second;
2764       }
2765     }
2766
2767     if ( totalNbFaces < 3 )
2768     {
2769       //edge._normal /= totalNbFaces;
2770     }
2771     else
2772     {
2773       edge._normal = getWeigthedNormal( node, face2Norm, totalNbFaces );
2774     }
2775   }
2776
2777   // set _cosin
2778   switch ( posType )
2779   {
2780   case SMDS_TOP_FACE: {
2781     edge._cosin = 0;
2782     break;
2783   }
2784   case SMDS_TOP_EDGE: {
2785     TopoDS_Edge E    = TopoDS::Edge( helper.GetSubShapeByNode( node, getMeshDS()));
2786     gp_Vec inFaceDir = getFaceDir( F, E, node, helper, normOK );
2787     double angle     = inFaceDir.Angle( edge._normal ); // [0,PI]
2788     edge._cosin      = Cos( angle );
2789     //cout << "Cosin on EDGE " << edge._cosin << " node " << node->GetID() << endl;
2790     break;
2791   }
2792   case SMDS_TOP_VERTEX: {
2793     TopoDS_Vertex V  = TopoDS::Vertex( helper.GetSubShapeByNode( node, getMeshDS()));
2794     gp_Vec inFaceDir = getFaceDir( F, V, node, helper, normOK );
2795     double angle     = inFaceDir.Angle( edge._normal ); // [0,PI]
2796     edge._cosin      = Cos( angle );
2797     if ( totalNbFaces > 2 || helper.IsSeamShape( node->getshapeId() ))
2798       for ( int iF = totalNbFaces-2; iF >=0; --iF )
2799       {
2800         F = face2Norm[ iF ].first;
2801         inFaceDir = getFaceDir( F, V, node, helper, normOK );
2802         if ( normOK ) {
2803           double angle = inFaceDir.Angle( edge._normal );
2804           edge._cosin = Max( edge._cosin, Cos( angle ));
2805         }
2806       }
2807     //cout << "Cosin on VERTEX " << edge._cosin << " node " << node->GetID() << endl;
2808     break;
2809   }
2810   default:
2811     return error(SMESH_Comment("Invalid shape position of node ")<<node, data._index);
2812   }
2813
2814   double normSize = edge._normal.SquareModulus();
2815   if ( normSize < numeric_limits<double>::min() )
2816     return error(SMESH_Comment("Bad normal at node ")<< node->GetID(), data._index );
2817
2818   edge._normal /= sqrt( normSize );
2819
2820   // TODO: if ( !normOK ) then get normal by mesh faces
2821
2822   // Set the rest data
2823   // --------------------
2824   if ( onShrinkShape )
2825   {
2826     edge._sWOL = (*s2s).second;
2827
2828     SMDS_MeshNode* tgtNode = const_cast<SMDS_MeshNode*>( edge._nodes.back() );
2829     if ( SMESHDS_SubMesh* sm = getMeshDS()->MeshElements( data._solid ))
2830       sm->RemoveNode( tgtNode , /*isNodeDeleted=*/false );
2831
2832     // set initial position which is parameters on _sWOL in this case
2833     if ( edge._sWOL.ShapeType() == TopAbs_EDGE )
2834     {
2835       double u = helper.GetNodeU( TopoDS::Edge( edge._sWOL ), node, 0, &normOK );
2836       edge._pos.push_back( gp_XYZ( u, 0, 0 ));
2837       if ( edge._nodes.size() > 1 )
2838         getMeshDS()->SetNodeOnEdge( tgtNode, TopoDS::Edge( edge._sWOL ), u );
2839     }
2840     else // TopAbs_FACE
2841     {
2842       gp_XY uv = helper.GetNodeUV( TopoDS::Face( edge._sWOL ), node, 0, &normOK );
2843       edge._pos.push_back( gp_XYZ( uv.X(), uv.Y(), 0));
2844       if ( edge._nodes.size() > 1 )
2845         getMeshDS()->SetNodeOnFace( tgtNode, TopoDS::Face( edge._sWOL ), uv.X(), uv.Y() );
2846     }
2847   }
2848   else
2849   {
2850     edge._pos.push_back( SMESH_TNodeXYZ( node ));
2851
2852     if ( posType == SMDS_TOP_FACE )
2853     {
2854       _Simplex::GetSimplices( node, edge._simplices, data._ignoreFaceIds, &data );
2855     }
2856   }
2857
2858   // Set neighbour nodes for a _LayerEdge based on EDGE
2859
2860   if ( posType == SMDS_TOP_EDGE /*||
2861        ( onShrinkShape && posType == SMDS_TOP_VERTEX && fabs( edge._cosin ) < 1e-10 )*/)
2862   {
2863     edge._2neibors = new _2NearEdges;
2864     // target node instead of source ones will be set later
2865     // if ( ! findNeiborsOnEdge( &edge,
2866     //                           edge._2neibors->_nodes[0],
2867     //                           edge._2neibors->_nodes[1],
2868     //                           data))
2869     //   return false;
2870     // edge.SetDataByNeighbors( edge._2neibors->_nodes[0],
2871     //                          edge._2neibors->_nodes[1],
2872     //                          helper);
2873   }
2874
2875   edge.SetCosin( edge._cosin ); // to update edge._lenFactor
2876
2877   return true;
2878 }
2879
2880 //================================================================================
2881 /*!
2882  * \brief Return normal to a FACE at a node
2883  *  \param [in] n - node
2884  *  \param [in] face - FACE
2885  *  \param [in] helper - helper
2886  *  \param [out] isOK - true or false
2887  *  \param [in] shiftInside - to find normal at a position shifted inside the face
2888  *  \return gp_XYZ - normal
2889  */
2890 //================================================================================
2891
2892 gp_XYZ _ViscousBuilder::getFaceNormal(const SMDS_MeshNode* node,
2893                                       const TopoDS_Face&   face,
2894                                       SMESH_MesherHelper&  helper,
2895                                    &nbs