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