From: eap Date: Thu, 18 Apr 2019 17:33:45 +0000 (+0300) Subject: IPAL54529: [CKD]: Hexahedron(ijk) fails on a composite block if Viscous Layers assigned X-Git-Tag: V9_4_0a1~41 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=0743fa8f5f572825041c1cee5b1b585d84f37270;p=modules%2Fsmesh.git IPAL54529: [CKD]: Hexahedron(ijk) fails on a composite block if Viscous Layers assigned --- diff --git a/src/SMESH/SMESH_ProxyMesh.cxx b/src/SMESH/SMESH_ProxyMesh.cxx index 2a12b362b..36d745f65 100644 --- a/src/SMESH/SMESH_ProxyMesh.cxx +++ b/src/SMESH/SMESH_ProxyMesh.cxx @@ -32,6 +32,9 @@ #include #include +#include +#include + //================================================================================ /*! * \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 ( i < _subMeshes.size() ) - sm = _subMeshes[i]; + if ( 0 < shapeID && shapeID < (int)_subMeshes.size() ) + sm = _subMeshes[ shapeID ]; 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 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); - iters[0] = proxyIter; - iters[1] = filterIter; - - typedef std::vector< SMDS_ElemIteratorPtr > TElemIterVector; - typedef SMDS_IteratorOnIterators TItersIter; - return SMDS_ElemIteratorPtr( new TItersIter( iters )); + return iteratorOn2Iterators( proxyIter, filterIter ); } //================================================================================ @@ -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 diff --git a/src/SMESH/SMESH_ProxyMesh.hxx b/src/SMESH/SMESH_ProxyMesh.hxx index aa692414a..4df1d9bb0 100644 --- a/src/SMESH/SMESH_ProxyMesh.hxx +++ b/src/SMESH/SMESH_ProxyMesh.hxx @@ -31,6 +31,7 @@ #include "SMESH_TypeDefs.hxx" #include +#include #include #include @@ -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( _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; }; diff --git a/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx b/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx index 310d135dd..b0f10f8d0 100644 --- a/src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx +++ b/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 #include @@ -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; - bool StoreNodes(SMESH_Mesh& mesh, vector& myGrid, bool reverse ); + int GetNbSegments(SMESH_ProxyMesh& mesh, const SMESHDS_SubMesh* smToCheckEdges=0) const; + bool StoreNodes(SMESH_ProxyMesh& mesh, vector& 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 & 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 & theGrid, const _Indexer& theIndexer, int theX, @@ -298,10 +301,10 @@ namespace */ //================================================================================ - bool isContinuousMesh(TopoDS_Edge E1, - TopoDS_Edge E2, - const TopoDS_Face& F, - const SMESH_Mesh& mesh) + bool isContinuousMesh(TopoDS_Edge E1, + TopoDS_Edge E2, + const TopoDS_Face& F, + 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 faceIDs; // ids of FACEs in the shape + std::set 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 ( !fBack ->LoadGrid( theMesh )) return error( fBack ->GetError() ); - if ( !fLeft ->LoadGrid( theMesh )) return error( fLeft ->GetError() ); - if ( !fFront ->LoadGrid( theMesh )) return error( fFront ->GetError() ); - if ( !fRight ->LoadGrid( theMesh )) return error( fRight ->GetError() ); - if ( !fTop ->LoadGrid( theMesh )) return error( fTop ->GetError() ); + if ( !fBottom->LoadGrid( *proxyMesh )) return error( fBottom->GetError() ); + if ( !fBack ->LoadGrid( *proxyMesh )) return error( fBack ->GetError() ); + if ( !fLeft ->LoadGrid( *proxyMesh )) return error( fLeft ->GetError() ); + if ( !fFront ->LoadGrid( *proxyMesh )) return error( fFront ->GetError() ); + if ( !fRight ->LoadGrid( *proxyMesh )) return error( fRight ->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 y, ySize = fBottom->GetNbVertSegments(theMesh) + 1, Y = ySize - 1; - int z, zSize = fFront ->GetNbVertSegments(theMesh) + 1, Z = zSize - 1; + int x, xSize = fBottom->GetNbHoriSegments(*proxyMesh) + 1, X = xSize - 1; + int y, ySize = fBottom->GetNbVertSegments(*proxyMesh) + 1, Y = ySize - 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 ); - myIndexer._ySize = 1 + mySides.GetSide( Q_LEFT )->GetNbSegments( mesh ); + + bool isProxy, isTmpElem; + 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._ySize = 1 + myLeftBottomChild->GetNbVertSegments(mesh, /*withBrothers=*/true); + myIndexer._xSize = 1 + myLeftBottomChild->GetNbHoriSegments( 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 & 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& 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; } diff --git a/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx b/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx index e0528fa20..a7986de3b 100644 --- a/src/StdMeshers/StdMeshers_CompositeHexa_3D.hxx +++ b/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,