IPAL54529: [CKD]: Hexahedron(ijk) fails on a composite block if Viscous Layers assigned

src/SMESH/SMESH_ProxyMesh.cxx

@@ -32,6 +32,9 @@
 #include <TopExp.hxx>
 #include <TopTools_IndexedMapOfShape.hxx>
 
+#include <boost/container/flat_set.hpp>
+#include <boost/make_shared.hpp>
+
 //================================================================================
 /*!
  * \brief Constructor; mesh must be set by a descendant class
@@ -169,14 +172,24 @@ SMESH_ProxyMesh::SubMesh* SMESH_ProxyMesh::newSubmesh(int index) const
 //================================================================================
 
 const SMESHDS_SubMesh* SMESH_ProxyMesh::GetSubMesh(const TopoDS_Shape& shape) const
+{
+  return GetSubMesh( shapeIndex( shape ));
+}
+
+//================================================================================
+/*!
+ * \brief Return a sub-mesh by a shape ID; it can be a proxy sub-mesh
+ */
+//================================================================================
+
+const SMESHDS_SubMesh* SMESH_ProxyMesh::GetSubMesh(const int shapeID) const
 {
   const SMESHDS_SubMesh* sm = 0;
 
-  size_t i = shapeIndex(shape);
+  if ( 0 < shapeID && shapeID < (int)_subMeshes.size() )
-  if ( i < _subMeshes.size() )
+    sm = _subMeshes[ shapeID ];
-    sm = _subMeshes[i];
   if ( !sm )
-    sm = GetMeshDS()->MeshElements( i );
+    sm = GetMeshDS()->MeshElements( shapeID );
 
   return sm;
 }
@@ -272,6 +285,62 @@ namespace
       return res;
     }
   };
+
+  //================================================================================
+  /*!
+   * \brief Iterator returning unique elements from a vector and another iterator
+   */
+  //================================================================================
+
+  class TUniqueIterator : public SMDS_ElemIterator
+  {
+    typedef boost::container::flat_set< const SMDS_MeshElement* >                 TElemSet;
+    typedef SMDS_SetIterator< const SMDS_MeshElement*, TElemSet::const_iterator > TSetIterator;
+
+    TElemSet      _uniqueElems;
+    TSetIterator* _iterator;
+
+  public:
+    TUniqueIterator( const std::vector< const SMDS_MeshElement* >& elems,
+                     const SMDS_ElemIteratorPtr&                   elemIterator )
+      : _uniqueElems( elems.begin(), elems.end() )
+    {
+      if ( elemIterator )
+        while ( elemIterator->more() )
+          _uniqueElems.insert( elemIterator->next() );
+
+      _iterator = new TSetIterator( _uniqueElems.begin(), _uniqueElems.end() );
+    }
+    ~TUniqueIterator()
+    {
+      delete _iterator;
+    }
+    virtual bool more()
+    {
+      return _iterator->more();
+    }
+    virtual const SMDS_MeshElement* next()
+    {
+      return _iterator->next();
+    }
+  };
+
+  //================================================================================
+  /*!
+   * \brief Return iterator on 2 element iterators
+   */
+  //================================================================================
+
+  SMDS_ElemIteratorPtr iteratorOn2Iterators( SMDS_ElemIteratorPtr it1, SMDS_ElemIteratorPtr it2 )
+  {
+    std::vector< SMDS_ElemIteratorPtr > iters; iters.reserve(2);
+    if ( it1 ) iters.push_back( it1 );
+    if ( it2 ) iters.push_back( it2 );
+
+    typedef std::vector< SMDS_ElemIteratorPtr >                                 TElemIterVector;
+    typedef SMDS_IteratorOnIterators<const SMDS_MeshElement *, TElemIterVector> TItersIter;
+    return SMDS_ElemIteratorPtr( new TItersIter( iters ));
+  }
 }
 
 //================================================================================
@@ -324,13 +393,7 @@ SMDS_ElemIteratorPtr SMESH_ProxyMesh::GetFaces() const
   // ... else elements filtered using allowedTypes are additionally returned
   SMDS_ElemIteratorPtr facesIter = GetMeshDS()->elementsIterator(SMDSAbs_Face);
   SMDS_ElemIteratorPtr filterIter( new TFilteringIterator( _allowedTypes, facesIter ));
-  std::vector< SMDS_ElemIteratorPtr > iters(2);
+  return iteratorOn2Iterators( proxyIter, filterIter );
-  iters[0] = proxyIter;
-  iters[1] = filterIter;
-    
-  typedef std::vector< SMDS_ElemIteratorPtr >                                 TElemIterVector;
-  typedef SMDS_IteratorOnIterators<const SMDS_MeshElement *, TElemIterVector> TItersIter;
-  return SMDS_ElemIteratorPtr( new TItersIter( iters ));
 }
 
 //================================================================================
@@ -476,8 +539,14 @@ void SMESH_ProxyMesh::removeTmpElement( const SMDS_MeshElement* elem )
     std::set< const SMDS_MeshElement* >::iterator i = _elemsInMesh.find( elem );
     if ( i != _elemsInMesh.end() )
     {
+      std::vector< const SMDS_MeshNode* > nodes( elem->begin_nodes(), elem->end_nodes() );
+
       GetMeshDS()->RemoveFreeElement( elem, 0 );
       _elemsInMesh.erase( i );
+
+      for ( size_t i = 0; i < nodes.size(); ++i )
+        if ( nodes[i]->GetID() > 0 && nodes[i]->NbInverseElements() == 0 )
+          GetMeshDS()->RemoveFreeNode( nodes[i], 0, false );
     }
   }
   else
@@ -524,6 +593,52 @@ bool SMESH_ProxyMesh::IsTemporary(const SMDS_MeshElement* elem ) const
   return ( elem->GetID() < 1 ) || _elemsInMesh.count( elem );
 }
 
+//================================================================================
+/*!
+ * \brief Return iterator on inverse elements of a node that may be a proxy one
+ */
+//================================================================================
+
+SMDS_ElemIteratorPtr SMESH_ProxyMesh::GetInverseElementIterator(const SMDS_MeshNode* node,
+                                                                SMDSAbs_ElementType  type) const
+{
+  typedef std::vector< const SMDS_MeshElement* > TElemVec;
+  TElemVec *elemVecPtr;
+
+  TNodeElemVecMap& inverseElements = const_cast< TNodeElemVecMap& >( _inverseElements );
+  if ( inverseElements.IsEmpty() && NbProxySubMeshes() > 0 )
+  {
+    TElemVec elemVec;
+    for ( size_t i = 0; i < _subMeshes.size(); ++i )
+      if ( _subMeshes[i] )
+        for ( size_t j = 0; j < _subMeshes[i]->_elements.size(); ++j )
+        {
+          const SMDS_MeshElement* e = _subMeshes[i]->_elements[j];
+          for ( SMDS_NodeIteratorPtr nIt = e->nodeIterator(); nIt->more(); )
+          {
+            const SMDS_MeshNode* n = nIt->next();
+            elemVecPtr = inverseElements.ChangeSeek( n );
+            if ( !elemVecPtr )
+              elemVecPtr = inverseElements.Bound( n, elemVec );
+            elemVecPtr->push_back( e );
+          }
+        }
+  }
+
+  SMDS_ElemIteratorPtr iter = node->GetInverseElementIterator( type );
+
+  if (( elemVecPtr = inverseElements.ChangeSeek( node )))
+  {
+    if ( iter->more() )
+      iter = boost::make_shared< TUniqueIterator >( *elemVecPtr, iter );
+    else
+      iter = boost::make_shared< SMDS_ElementVectorIterator> ( elemVecPtr->begin(),
+                                                               elemVecPtr->end() );
+  }
+
+  return iter;
+}
+
 //================================================================================
 /*!
  * \brief SubMesh Constructor

src/SMESH/SMESH_ProxyMesh.hxx

@@ -31,6 +31,7 @@
 #include "SMESH_TypeDefs.hxx"
 
 #include <TopoDS_Shape.hxx>
+#include <NCollection_DataMap.hxx>
 
 #include <map>
 #include <vector>
@@ -103,23 +104,26 @@ public:
   SMESH_ProxyMesh(const SMESH_Mesh& mesh);
   virtual ~SMESH_ProxyMesh();
 
-  // Returns the submesh of a shape; it can be a proxy sub-mesh
+  // Returns a sub-mesh of a shape; it can be a proxy sub-mesh
   const SMESHDS_SubMesh* GetSubMesh(const TopoDS_Shape& shape) const;
 
-  // Returns the proxy sub-mesh of a shape; it can be NULL
+  // Return a sub-mesh by a shape ID; it can be a proxy sub-mesh
+  const SMESHDS_SubMesh* GetSubMesh(const int shapeID) const;
+
+  // Return a proxy sub-mesh of a shape; it can be NULL
   const SubMesh*         GetProxySubMesh(const TopoDS_Shape& shape) const;
 
-  // Returns the proxy node of a node; the input node is returned if no proxy exists
+  // Return a proxy node of a node; the input node is returned if no proxy exists
   const SMDS_MeshNode*   GetProxyNode( const SMDS_MeshNode* node ) const;
 
-  // Returns number of proxy sub-meshes
+  // Return number of proxy sub-meshes
   int                    NbProxySubMeshes() const;
 
-  // Returns iterator on all faces of the mesh taking into account substitutions.
+  // Return iterator on all faces of the mesh taking into account substitutions.
   // To be used in case of mesh without shape
   SMDS_ElemIteratorPtr   GetFaces() const;
 
-  // Returns iterator on all faces on the face taking into account substitutions
+  // Return iterator on all faces on the face taking into account substitutions
   SMDS_ElemIteratorPtr   GetFaces(const TopoDS_Shape& face) const;
 
   // Return total nb of faces taking into account substitutions
@@ -127,6 +131,10 @@ public:
 
   bool                   IsTemporary(const SMDS_MeshElement* elem ) const;
 
+  // Return iterator on inverse elements of a node that may be a proxy one
+  SMDS_ElemIteratorPtr   GetInverseElementIterator(const SMDS_MeshNode* node,
+                                                   SMDSAbs_ElementType  type) const;
+
 
 
   SMESH_Mesh*            GetMesh() const { return const_cast<SMESH_Mesh*>( _mesh ); }
@@ -143,13 +151,13 @@ public:
 
   virtual SubMesh* newSubmesh(int index=0) const;
 
-  // returns a proxy sub-mesh; zero index is for the case of mesh w/o shape
+  // Return a proxy sub-mesh; zero index is for the case of mesh w/o shape
   SubMesh* findProxySubMesh(int shapeIndex=0) const;
 
-  // returns a proxy sub-mesh; it is created if not yet exists
+  // Return a proxy sub-mesh; it is created if not yet exists
   SubMesh* getProxySubMesh(int shapeIndex);
 
-  // returns a proxy sub-mesh; it is created if not yet exists
+  // Return a proxy sub-mesh; it is created if not yet exists
   SubMesh* getProxySubMesh(const TopoDS_Shape& shape=TopoDS_Shape());
 
   // move proxy sub-mesh from other proxy mesh to this, returns true if sub-mesh found
@@ -184,6 +192,12 @@ public:
   // tmp elements residing the _mesh, to be deleted at destruction
   std::set< const SMDS_MeshElement* > _elemsInMesh;
 
+  // inverse elements of proxy nodes
+  typedef NCollection_DataMap< const SMDS_MeshNode*,
+                               std::vector< const SMDS_MeshElement* >,
+                               SMESH_Hasher                         > TNodeElemVecMap;
+  TNodeElemVecMap  _inverseElements;
+
   // Complex submesh used to iterate over elements in other sub-meshes
   mutable SubMesh* _subContainer;
 };

src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx

@@ -33,10 +33,12 @@
 #include "SMESH_Block.hxx"
 #include "SMESH_Comment.hxx"
 #include "SMESH_ComputeError.hxx"
+#include "SMESH_HypoFilter.hxx"
 #include "SMESH_Mesh.hxx"
 #include "SMESH_MeshAlgos.hxx"
 #include "SMESH_MesherHelper.hxx"
 #include "SMESH_subMesh.hxx"
+#include "StdMeshers_ViscousLayers.hxx"
 
 #include <BRepAdaptor_Surface.hxx>
 #include <BRep_Tool.hxx>
@@ -118,8 +120,9 @@ public:
   bool Contain( const TopoDS_Vertex& vertex ) const;
   void AppendSide( const _FaceSide& side );
   void SetBottomSide( int i );
-  int GetNbSegments(SMESH_Mesh& mesh) const;
+  int GetNbSegments(SMESH_ProxyMesh& mesh, const SMESHDS_SubMesh* smToCheckEdges=0) const;
-  bool StoreNodes(SMESH_Mesh& mesh, vector<const SMDS_MeshNode*>& myGrid, bool reverse );
+  bool StoreNodes(SMESH_ProxyMesh& mesh, vector<const SMDS_MeshNode*>& myGrid,
+                  bool reverse, bool isProxy, const SMESHDS_SubMesh* smToCheckEdges=0 );
   void SetID(EQuadSides id) { myID = id; }
   static inline const TopoDS_TShape* ptr(const TopoDS_Shape& theShape)
   { return theShape.TShape().operator->(); }
@@ -150,7 +153,7 @@ public:
 public: //** Methods to find and orient faces of 6 sides of the box **//
   
   //!< initialization
-  bool Init(const TopoDS_Face& f, SMESH_Mesh& mesh );
+  bool Init(const TopoDS_Face& f, SMESH_ProxyMesh& mesh );
 
   //!< try to unite self with other face
   bool AddContinuousFace( const _QuadFaceGrid& f, const TopTools_MapOfShape& internalEdges );
@@ -180,16 +183,16 @@ public: //** Methods to find and orient faces of 6 sides of the box **//
 public: //** Loading and access to mesh **//
 
   //!< Load nodes of a mesh
-  bool LoadGrid( SMESH_Mesh& mesh );
+  bool LoadGrid( SMESH_ProxyMesh& mesh );
 
   //!< Computes normalized parameters of nodes of myGrid
   void ComputeIJK( int i1, int i2, double v3 );
 
   //!< Return number of segments on the hirizontal sides
-  int GetNbHoriSegments(SMESH_Mesh& mesh, bool withBrothers=false) const;
+  int GetNbHoriSegments(SMESH_ProxyMesh& mesh, bool withBrothers=false) const;
 
   //!< Return number of segments on the vertical sides
-  int GetNbVertSegments(SMESH_Mesh& mesh, bool withBrothers=false) const;
+  int GetNbVertSegments(SMESH_ProxyMesh& mesh, bool withBrothers=false) const;
 
   //!< Return edge on the hirizontal bottom sides
   int GetHoriEdges(vector<TopoDS_Edge> & edges) const;
@@ -230,9 +233,9 @@ private:
   bool error(const SMESH_ComputeErrorPtr& err)
   { myError = err; return ( !myError || myError->IsOK() ); }
 
-  bool loadCompositeGrid(SMESH_Mesh& mesh);
+  bool loadCompositeGrid(SMESH_ProxyMesh& mesh);
 
-  bool fillGrid(SMESH_Mesh&                    theMesh,
+  bool fillGrid(SMESH_ProxyMesh&               theMesh,
                 vector<const SMDS_MeshNode*> & theGrid,
                 const _Indexer&                theIndexer,
                 int                            theX,
@@ -298,10 +301,10 @@ namespace
    */
   //================================================================================
 
-  bool isContinuousMesh(TopoDS_Edge        E1,
+  bool isContinuousMesh(TopoDS_Edge            E1,
-                        TopoDS_Edge        E2,
+                        TopoDS_Edge            E2,
-                        const TopoDS_Face& F,
+                        const TopoDS_Face&     F,
-                        const SMESH_Mesh&  mesh)
+                        const SMESH_ProxyMesh& mesh)
   {
     if (E1.Orientation() > TopAbs_REVERSED) // INTERNAL
       E1.Orientation( TopAbs_FORWARD );
@@ -314,11 +317,13 @@ namespace
     const SMDS_MeshNode* n = SMESH_Algo::VertexNode( V, mesh.GetMeshDS() );
     if ( !n ) return SMESH_Algo::IsContinuous( E1, E2 ); // meshed by "composite segment"
 
-    SMESHDS_SubMesh* sm = mesh.GetSubMeshContaining( F )->GetSubMeshDS();
+    n = mesh.GetProxyNode( n );
+
+    const SMESHDS_SubMesh* sm = mesh.GetSubMesh( F );
     if ( !sm ) return false;
 
     int nbQuads = 0;
-    SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face);
+    SMDS_ElemIteratorPtr fIt = mesh.GetInverseElementIterator( n, SMDSAbs_Face );
     if ( !fIt->more() )
       return SMESH_Algo::IsContinuous( E1, E2 ); // meshed by "composite segment"
     while ( fIt->more() )
@@ -362,11 +367,11 @@ namespace
    */
   //================================================================================
 
-  void getBlockCorners( SMESH_Mesh&          mesh,
+  void getBlockCorners( SMESH_ProxyMesh&     mesh,
                         const TopoDS_Shape&  shape,
                         TopTools_MapOfShape& cornerVV)
   {
-    set<int> faceIDs; // ids of FACEs in the shape
+    std::set<int> faceIDs; // ids of FACEs in the shape
     TopExp_Explorer exp;
     for ( exp.Init( shape, TopAbs_FACE ); exp.More(); exp.Next() )
       faceIDs.insert( mesh.GetMeshDS()->ShapeToIndex( exp.Current() ));
@@ -380,13 +385,20 @@ namespace
       const SMDS_MeshNode* n = SMESH_Algo::VertexNode( V, mesh.GetMeshDS() );
       if ( !n ) continue;
 
+      const SMDS_MeshNode* nProxy = mesh.GetProxyNode( n );
+      bool isProxy = ( nProxy != n );
+      n = nProxy;
+
       int nbQuads = 0;
-      SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator(SMDSAbs_Face);
+      SMDS_ElemIteratorPtr fIt = mesh.GetInverseElementIterator( n, SMDSAbs_Face );
       while ( fIt->more() )
       {
         const SMDS_MeshElement* f = fIt->next();
         if ( !faceIDs.count( f->getshapeId() )) continue;
 
+        if ( isProxy && !mesh.GetSubMesh( f->getshapeId() )->Contains( f ))
+          continue;
+
         if ( f->NbCornerNodes() == 4 )
           ++nbQuads;
         else
@@ -486,6 +498,51 @@ namespace
 
     return true;
   } // getInternalEdges()
+
+  //================================================================================
+  /*!
+   * \brief Find a face including two given nodes
+   */
+  //================================================================================
+
+  const SMDS_MeshElement* FindFaceByNodes( const SMDS_MeshNode* n1,
+                                           const SMDS_MeshNode* n2,
+                                           TIDSortedElemSet     avoidSet,
+                                           SMESH_ProxyMesh&     mesh)
+  {
+    SMDS_ElemIteratorPtr faceIt = mesh.GetInverseElementIterator( n1, SMDSAbs_Face );
+    while ( faceIt->more() )
+    {
+      const SMDS_MeshElement* f = faceIt->next();
+      if ( !avoidSet.count( f ) && f->GetNodeIndex( n2 ) >= 0 )
+        return f;
+    }
+    return 0;
+  }
+
+  //================================================================================
+  /*!
+   * \brief Check that a segment bounds a face belonging to smOfFaces
+   */
+  //================================================================================
+
+  bool IsSegmentOnSubMeshBoundary( const SMDS_MeshNode*   n1,
+                                   const SMDS_MeshNode*   n2,
+                                   const SMESHDS_SubMesh* smOfFaces,
+                                   SMESH_ProxyMesh&       mesh)
+  {
+    TIDSortedElemSet avoidSet;
+    bool faceFound = false;
+
+    while ( const SMDS_MeshElement* f = FindFaceByNodes( n1, n2, avoidSet, mesh ))
+    {
+      if (( faceFound = smOfFaces->Contains( f )))
+        break;
+      avoidSet.insert( f );
+    }
+    return faceFound;
+  }
+
 } // namespace
 
 //================================================================================
@@ -497,6 +554,7 @@ namespace
 bool StdMeshers_CompositeHexa_3D::findBoxFaces( const TopoDS_Shape&    shape,
                                                 list< _QuadFaceGrid >& boxFaces,
                                                 SMESH_Mesh&            mesh,
+                                                SMESH_ProxyMesh&       proxyMesh,
                                                 _QuadFaceGrid * &      fBottom,
                                                 _QuadFaceGrid * &      fTop,
                                                 _QuadFaceGrid * &      fFront,
@@ -505,7 +563,7 @@ bool StdMeshers_CompositeHexa_3D::findBoxFaces( const TopoDS_Shape&    shape,
                                                 _QuadFaceGrid * &      fRight)
 {
   TopTools_MapOfShape cornerVertices;
-  getBlockCorners( mesh, shape, cornerVertices );
+  getBlockCorners( proxyMesh, shape, cornerVertices );
   if ( cornerVertices.Extent() != 8 )
     return error( COMPERR_BAD_INPUT_MESH, "Can't find 8 corners of a block by 2D mesh" );
   TopTools_MapOfShape internalEdges;
@@ -518,7 +576,7 @@ bool StdMeshers_CompositeHexa_3D::findBoxFaces( const TopoDS_Shape&    shape,
   for ( exp.Init( shape, TopAbs_FACE ); exp.More(); exp.Next(), ++nbFaces )
   {
     _QuadFaceGrid f;
-    if ( !f.Init( TopoDS::Face( exp.Current() ), mesh ))
+    if ( !f.Init( TopoDS::Face( exp.Current() ), proxyMesh ))
       return error (COMPERR_BAD_SHAPE);
 
     _QuadFaceGrid* prevContinuous = 0;
@@ -547,7 +605,7 @@ bool StdMeshers_CompositeHexa_3D::findBoxFaces( const TopoDS_Shape&    shape,
     boxFaces.resize( 6 );
     boxFace = boxFaces.begin();
     for ( exp.Init( shape, TopAbs_FACE); exp.More(); exp.Next(), ++boxFace )
-      boxFace->Init( TopoDS::Face( exp.Current() ), mesh );
+      boxFace->Init( TopoDS::Face( exp.Current() ), proxyMesh );
   }
   // ----------------------------------------
   // Find out position of faces within a box
@@ -612,12 +670,22 @@ bool StdMeshers_CompositeHexa_3D::Compute(SMESH_Mesh&         theMesh,
   _quadraticMesh = helper.IsQuadraticSubMesh( theShape );
   helper.SetElementsOnShape( true );
 
+  // get Viscous Mesh
+  SMESH_ProxyMesh::Ptr proxyMesh;
+  SMESH_HypoFilter vlFilter( SMESH_HypoFilter::HasName( StdMeshers_ViscousLayers::GetHypType() ));
+  const SMESH_Hypothesis *          hyp = theMesh.GetHypothesis( theShape, vlFilter, true );
+  const StdMeshers_ViscousLayers* vlHyp = static_cast< const StdMeshers_ViscousLayers* >( hyp );
+  if ( vlHyp )
+    proxyMesh = vlHyp->Compute( theMesh, theShape, /*toMakeN2NMap=*/true );
+  else
+    proxyMesh.reset( new SMESH_ProxyMesh( theMesh ));
+
   // -------------------------
   // Try to find 6 side faces
   // -------------------------
   list< _QuadFaceGrid > boxFaceContainer;
   _QuadFaceGrid *fBottom, *fTop, *fFront, *fBack, *fLeft, *fRight;
-  if ( ! findBoxFaces( theShape, boxFaceContainer, theMesh,
+  if ( ! findBoxFaces( theShape, boxFaceContainer, theMesh, *proxyMesh,
                        fBottom, fTop, fFront, fBack, fLeft, fRight))
     return false;
 
@@ -626,12 +694,12 @@ bool StdMeshers_CompositeHexa_3D::Compute(SMESH_Mesh&         theMesh,
   // ------------------------------------------
 
   // let faces load their grids
-  if ( !fBottom->LoadGrid( theMesh )) return error( fBottom->GetError() );
+  if ( !fBottom->LoadGrid( *proxyMesh )) return error( fBottom->GetError() );
-  if ( !fBack  ->LoadGrid( theMesh )) return error( fBack  ->GetError() );
+  if ( !fBack  ->LoadGrid( *proxyMesh )) return error( fBack  ->GetError() );
-  if ( !fLeft  ->LoadGrid( theMesh )) return error( fLeft  ->GetError() );
+  if ( !fLeft  ->LoadGrid( *proxyMesh )) return error( fLeft  ->GetError() );
-  if ( !fFront ->LoadGrid( theMesh )) return error( fFront ->GetError() );
+  if ( !fFront ->LoadGrid( *proxyMesh )) return error( fFront ->GetError() );
-  if ( !fRight ->LoadGrid( theMesh )) return error( fRight ->GetError() );
+  if ( !fRight ->LoadGrid( *proxyMesh )) return error( fRight ->GetError() );
-  if ( !fTop   ->LoadGrid( theMesh )) return error( fTop   ->GetError() );
+  if ( !fTop   ->LoadGrid( *proxyMesh )) return error( fTop   ->GetError() );
 
   // compute normalized parameters of nodes on sides (PAL23189)
   fBottom->ComputeIJK( COO_X, COO_Y, /*z=*/0. );
@@ -641,9 +709,9 @@ bool StdMeshers_CompositeHexa_3D::Compute(SMESH_Mesh&         theMesh,
   fRight ->ComputeIJK( COO_Y, COO_Z, /*x=*/1. );
   fTop   ->ComputeIJK( COO_X, COO_Y, /*z=*/1. );
 
-  int x, xSize = fBottom->GetNbHoriSegments(theMesh) + 1, X = xSize - 1;
+  int x, xSize = fBottom->GetNbHoriSegments(*proxyMesh) + 1, X = xSize - 1;
-  int y, ySize = fBottom->GetNbVertSegments(theMesh) + 1, Y = ySize - 1;
+  int y, ySize = fBottom->GetNbVertSegments(*proxyMesh) + 1, Y = ySize - 1;
-  int z, zSize = fFront ->GetNbVertSegments(theMesh) + 1, Z = zSize - 1;
+  int z, zSize = fFront ->GetNbVertSegments(*proxyMesh) + 1, Z = zSize - 1;
   _Indexer colIndex( xSize, ySize );
   vector< vector< const SMDS_MeshNode* > > columns( colIndex.size() );
 
@@ -798,12 +866,14 @@ bool StdMeshers_CompositeHexa_3D::Evaluate(SMESH_Mesh&         theMesh,
                                            const TopoDS_Shape& theShape,
                                            MapShapeNbElems&    aResMap)
 {
+  SMESH_ProxyMesh::Ptr proxyMesh( new SMESH_ProxyMesh( theMesh ));
+
   // -------------------------
   // Try to find 6 side faces
   // -------------------------
   list< _QuadFaceGrid > boxFaceContainer;
   _QuadFaceGrid *fBottom, *fTop, *fFront, *fBack, *fLeft, *fRight;
-  if ( ! findBoxFaces( theShape, boxFaceContainer, theMesh,
+  if ( ! findBoxFaces( theShape, boxFaceContainer, theMesh, *proxyMesh,
                        fBottom, fTop, fFront, fBack, fLeft, fRight))
     return false;
 
@@ -889,7 +959,7 @@ _QuadFaceGrid::_QuadFaceGrid():
  */
 //================================================================================
 
-bool _QuadFaceGrid::Init(const TopoDS_Face& f, SMESH_Mesh& mesh)
+bool _QuadFaceGrid::Init(const TopoDS_Face& f, SMESH_ProxyMesh& mesh)
 {
   myFace         = f;
   mySides        = _FaceSide();
@@ -1144,7 +1214,7 @@ void _QuadFaceGrid::ReverseEdges()
  */
 //================================================================================
 
-bool _QuadFaceGrid::LoadGrid( SMESH_Mesh& mesh )
+bool _QuadFaceGrid::LoadGrid( SMESH_ProxyMesh& mesh )
 {
   if ( !myChildren.empty() )
   {
@@ -1166,24 +1236,33 @@ bool _QuadFaceGrid::LoadGrid( SMESH_Mesh& mesh )
   if ( !myGrid.empty() )
     return true;
 
-  SMESHDS_SubMesh* faceSubMesh = mesh.GetSubMesh( myFace )->GetSubMeshDS();
+  const SMESHDS_SubMesh* faceSubMesh = mesh.GetSubMesh( myFace );
+
   // check that all faces are quadrangular
   SMDS_ElemIteratorPtr fIt = faceSubMesh->GetElements();
   while ( fIt->more() )
     if ( fIt->next()->NbNodes() % 4 > 0 )
       return error("Non-quadrangular mesh faces are not allowed on sides of a composite block");
-  
+
-  myIndexer._xSize = 1 + mySides.GetSide( Q_BOTTOM )->GetNbSegments( mesh );
+  bool isProxy, isTmpElem;
-  myIndexer._ySize = 1 + mySides.GetSide( Q_LEFT   )->GetNbSegments( mesh );
+  if ( faceSubMesh && faceSubMesh->NbElements() > 0 )
+  {
+    isProxy   = dynamic_cast< const SMESH_ProxyMesh::SubMesh* >( faceSubMesh );
+    isTmpElem = mesh.IsTemporary( faceSubMesh->GetElements()->next() );
+  }
+  const SMESHDS_SubMesh* smToCheckEdges = ( isProxy && !isTmpElem ) ? faceSubMesh : 0;
+
+  myIndexer._xSize = 1 + mySides.GetSide( Q_BOTTOM )->GetNbSegments( mesh, smToCheckEdges );
+  myIndexer._ySize = 1 + mySides.GetSide( Q_LEFT   )->GetNbSegments( mesh, smToCheckEdges );
 
   myGrid.resize( myIndexer.size() );
 
   // store nodes bound to the bottom edge
-  mySides.GetSide( Q_BOTTOM )->StoreNodes( mesh, myGrid, myReverse );
+  mySides.GetSide( Q_BOTTOM )->StoreNodes( mesh, myGrid, myReverse, isProxy, smToCheckEdges );
 
   // store the rest nodes row by row
 
-  TIDSortedElemSet emptySet, avoidSet;
+  TIDSortedElemSet avoidSet;
   const SMDS_MeshElement* firstQuad = 0; // most left face above the last row of found nodes
 
   size_t nbFoundNodes = myIndexer._xSize;
@@ -1202,10 +1281,10 @@ bool _QuadFaceGrid::LoadGrid( SMESH_Mesh& mesh )
     //     o---o  o  o  o  o
     //n1down    n2down
     //
-    firstQuad = SMESH_MeshAlgos::FindFaceInSet( n1down, n2down, emptySet, avoidSet);
+    firstQuad = FindFaceByNodes( n1down, n2down, avoidSet, mesh );
     while ( firstQuad && !faceSubMesh->Contains( firstQuad )) {
       avoidSet.insert( firstQuad );
-      firstQuad = SMESH_MeshAlgos::FindFaceInSet( n1down, n2down, emptySet, avoidSet);
+      firstQuad = FindFaceByNodes( n1down, n2down, avoidSet, mesh);
     }
     if ( !firstQuad || !faceSubMesh->Contains( firstQuad ))
       return error(ERR_LI("Error in _QuadFaceGrid::LoadGrid()"));
@@ -1235,7 +1314,7 @@ bool _QuadFaceGrid::LoadGrid( SMESH_Mesh& mesh )
     {
       // next face
       avoidSet.clear(); avoidSet.insert( quad );
-      quad = SMESH_MeshAlgos::FindFaceInSet( n1down, n1up, emptySet, avoidSet );
+      quad = FindFaceByNodes( n1down, n1up, avoidSet, mesh );
       if ( !quad || quad->NbNodes() % 4 > 0)
         return error(ERR_LI("Error in _QuadFaceGrid::LoadGrid()"));
 
@@ -1352,7 +1431,7 @@ bool _QuadFaceGrid::locateChildren()
  */
 //================================================================================
 
-bool _QuadFaceGrid::loadCompositeGrid(SMESH_Mesh& mesh)
+bool _QuadFaceGrid::loadCompositeGrid(SMESH_ProxyMesh& mesh)
 {
   // Find out mutual location of children: find their right and up brothers
   if ( !locateChildren() )
@@ -1361,13 +1440,13 @@ bool _QuadFaceGrid::loadCompositeGrid(SMESH_Mesh& mesh)
   // Load nodes according to mutual location of children
 
   // grid size
-  myIndexer._xSize = 1 + myLeftBottomChild->GetNbHoriSegments(mesh, /*withBrothers=*/true);
+  myIndexer._xSize = 1 + myLeftBottomChild->GetNbHoriSegments( mesh, /*withBrothers=*/true );
-  myIndexer._ySize = 1 + myLeftBottomChild->GetNbVertSegments(mesh, /*withBrothers=*/true);
+  myIndexer._ySize = 1 + myLeftBottomChild->GetNbVertSegments( mesh, /*withBrothers=*/true );
 
   myGrid.resize( myIndexer.size() );
 
   int fromX = myReverse ? myIndexer._xSize : 0;
-  if (!myLeftBottomChild->fillGrid( mesh, myGrid, myIndexer, fromX, 0 ))
+  if ( !myLeftBottomChild->fillGrid( mesh, myGrid, myIndexer, fromX, 0 ))
     return error( myLeftBottomChild->GetError() );
 
   DumpGrid();
@@ -1429,7 +1508,7 @@ void _QuadFaceGrid::setBrothers( set< _QuadFaceGrid* >& notLocatedBrothers )
  */
 //================================================================================
 
-bool _QuadFaceGrid::fillGrid(SMESH_Mesh&                    theMesh,
+bool _QuadFaceGrid::fillGrid(SMESH_ProxyMesh&               theMesh,
                              vector<const SMDS_MeshNode*> & theGrid,
                              const _Indexer&                theIndexer,
                              int                            theX,
@@ -1472,7 +1551,7 @@ bool _QuadFaceGrid::fillGrid(SMESH_Mesh&                    theMesh,
  */
 //================================================================================
 
-int _QuadFaceGrid::GetNbHoriSegments(SMESH_Mesh& mesh, bool withBrothers) const
+int _QuadFaceGrid::GetNbHoriSegments(SMESH_ProxyMesh& mesh, bool withBrothers) const
 {
   int nbSegs = 0;
   if ( myLeftBottomChild )
@@ -1481,7 +1560,7 @@ int _QuadFaceGrid::GetNbHoriSegments(SMESH_Mesh& mesh, bool withBrothers) const
   }
   else
   {
-    nbSegs = mySides.GetSide( Q_BOTTOM )->GetNbSegments(mesh);
+    nbSegs = mySides.GetSide( Q_BOTTOM )->GetNbSegments( mesh );
     if ( withBrothers && myRightBrother )
       nbSegs += myRightBrother->GetNbHoriSegments( mesh, withBrothers );
   }
@@ -1494,7 +1573,7 @@ int _QuadFaceGrid::GetNbHoriSegments(SMESH_Mesh& mesh, bool withBrothers) const
  */
 //================================================================================
 
-int _QuadFaceGrid::GetNbVertSegments(SMESH_Mesh& mesh, bool withBrothers) const
+int _QuadFaceGrid::GetNbVertSegments(SMESH_ProxyMesh& mesh, bool withBrothers) const
 {
   int nbSegs = 0;
   if ( myLeftBottomChild )
@@ -1503,7 +1582,7 @@ int _QuadFaceGrid::GetNbVertSegments(SMESH_Mesh& mesh, bool withBrothers) const
   }
   else
   {
-    nbSegs = mySides.GetSide( Q_LEFT )->GetNbSegments(mesh);
+    nbSegs = mySides.GetSide( Q_LEFT )->GetNbSegments(mesh,0);
     if ( withBrothers && myUpBrother )
       nbSegs += myUpBrother->GetNbVertSegments( mesh, withBrothers );
   }
@@ -1914,30 +1993,46 @@ void _FaceSide::SetBottomSide( int i )
 //purpose  : 
 //=======================================================================
 
-int _FaceSide::GetNbSegments(SMESH_Mesh& mesh) const
+int _FaceSide::GetNbSegments(SMESH_ProxyMesh& mesh, const SMESHDS_SubMesh* smToCheckEdges) const
 {
   int nb = 0;
   if ( myChildren.empty() )
   {
-    nb = mesh.GetSubMesh(myEdge)->GetSubMeshDS()->NbElements();
+    nb = mesh.GetSubMesh(myEdge)->NbElements();
+
+    if ( smToCheckEdges )
+    {
+      // check that segments bound faces belonging to smToCheckEdges
+      SMDS_ElemIteratorPtr segIt = mesh.GetSubMesh(myEdge)->GetElements();
+      while ( segIt->more() )
+      {
+        const SMDS_MeshElement* seg = segIt->next();
+        if ( !IsSegmentOnSubMeshBoundary( mesh.GetProxyNode( seg->GetNode(0) ),
+                                          mesh.GetProxyNode( seg->GetNode(1) ),
+                                          smToCheckEdges, mesh ))
+          --nb;
+      }
+    }
   }
   else
   {
     list< _FaceSide >::const_iterator side = myChildren.begin(), sideEnd = myChildren.end();
     for ( ; side != sideEnd; ++side )
-      nb += side->GetNbSegments(mesh);
+      nb += side->GetNbSegments( mesh, smToCheckEdges );
   }
   return nb;
 }
 
 //=======================================================================
 //function : StoreNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-bool _FaceSide::StoreNodes(SMESH_Mesh&                   mesh,
+bool _FaceSide::StoreNodes(SMESH_ProxyMesh&              mesh,
                            vector<const SMDS_MeshNode*>& myGrid,
-                           bool                          reverse )
+                           bool                          reverse,
+                           bool                          isProxy,
+                           const SMESHDS_SubMesh*        smToCheckEdges)
 {
   list< TopoDS_Edge > edges;
   if ( myChildren.empty() )
@@ -1957,7 +2052,8 @@ bool _FaceSide::StoreNodes(SMESH_Mesh&                   mesh,
   list< TopoDS_Edge >::iterator edge = edges.begin(), eEnd = edges.end();
   for ( ; edge != eEnd; ++edge )
   {
-    map< double, const SMDS_MeshNode* > nodes;
+    typedef map< double, const SMDS_MeshNode* > TParamNodeMap;
+    TParamNodeMap nodes;
     bool ok = SMESH_Algo::GetSortedNodesOnEdge( mesh.GetMeshDS(),
                                                 *edge,
                                                 /*ignoreMediumNodes=*/true,
@@ -1971,17 +2067,46 @@ bool _FaceSide::StoreNodes(SMESH_Mesh&                   mesh,
          !nodes.rbegin()->second->GetInverseElementIterator(SMDSAbs_Face)->more() )
       nodes.erase( --nodes.end() );
 
+    if ( isProxy )
+    {
+      TParamNodeMap::iterator u_node, nEnd = nodes.end();
+      for ( u_node = nodes.begin(); u_node != nEnd; ++u_node )
+        u_node->second = mesh.GetProxyNode( u_node->second );
+    }
+
+    if ( smToCheckEdges ) // erase nodes of segments not bounding faces of smToCheckEdges
+    {
+      {
+        TParamNodeMap::iterator u_node1, u_node2 = nodes.begin(), nEnd = nodes.end();
+        for ( u_node1 = u_node2++; u_node2 != nEnd; u_node1 = u_node2++ )
+          if ( IsSegmentOnSubMeshBoundary( u_node1->second, u_node2->second,
+                                           smToCheckEdges, mesh ))
+            break;
+          else
+            nodes.erase( u_node1 );
+      }
+      {
+        TParamNodeMap::reverse_iterator u_node1, u_node2 = nodes.rbegin(), nEnd = nodes.rend();
+        for ( u_node1 = u_node2++; u_node2 != nEnd; u_node1 = u_node2++ )
+          if ( IsSegmentOnSubMeshBoundary( u_node1->second, u_node2->second,
+                                           smToCheckEdges, mesh ))
+            break;
+          else
+            nodes.erase( --( u_node1.base() ));
+      }
+    }
+
     bool forward = ( edge->Orientation() == TopAbs_FORWARD );
     if ( reverse ) forward = !forward;
     if ( forward )
     {
-      map< double, const SMDS_MeshNode* >::iterator u_node, nEnd = nodes.end();
+      TParamNodeMap::iterator u_node, nEnd = nodes.end();
       for ( u_node = nodes.begin(); u_node != nEnd; ++u_node )
         myGrid[ nbNodes++ ] = u_node->second;
     }
-    else 
+    else
     {
-      map< double, const SMDS_MeshNode* >::reverse_iterator u_node, nEnd = nodes.rend();
+      TParamNodeMap::reverse_iterator u_node, nEnd = nodes.rend();
       for ( u_node = nodes.rbegin(); u_node != nEnd; ++u_node )
         myGrid[ nbNodes++ ] = u_node->second;
     }

src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx

@@ -28,6 +28,7 @@
 #include "SMESH_Algo.hxx"
 
 class SMESH_Mesh;
+class SMESH_ProxyMesh;
 class StdMeshers_FaceSide;
 class TopoDS_Edge;
 class TopoDS_Face;
@@ -60,6 +61,7 @@ private:
   bool findBoxFaces( const TopoDS_Shape&         shape,
                      std::list< _QuadFaceGrid >& boxFaceContainer,
                      SMESH_Mesh&                 mesh,
+                     SMESH_ProxyMesh&            proxyMesh,
                      _QuadFaceGrid * &           fBottom,
                      _QuadFaceGrid * &           fTop,
                      _QuadFaceGrid * &           fFront,