From 066f625a46b60642f228a0c10fc6c2dcdc20d304 Mon Sep 17 00:00:00 2001 From: eap Date: Fri, 27 Feb 2015 20:38:00 +0300 Subject: [PATCH] 52618: Import_1D2D fails to import from a mesh group onto a group of geom faces + fix StdMeshers_ViscousLayers.cxx for http://www.salome-platform.org/forum/forum_14/777944993 --- .../SMESH/input/constructing_submeshes.doc | 7 +- idl/SMESH_BasicHypothesis.idl | 6 +- src/SMESH/SMESH_Hypothesis.hxx | 14 +- src/SMESH/SMESH_Mesh.cxx | 3 +- src/SMESH_SWIG/StdMeshersBuilder.py | 6 +- src/StdMeshers/StdMeshers_ImportSource.hxx | 1 + src/StdMeshers/StdMeshers_Import_1D2D.cxx | 159 ++++++++++++++---- src/StdMeshers/StdMeshers_ViscousLayers.cxx | 2 +- 8 files changed, 150 insertions(+), 48 deletions(-) diff --git a/doc/salome/gui/SMESH/input/constructing_submeshes.doc b/doc/salome/gui/SMESH/input/constructing_submeshes.doc index cf276a57b..8e750f6a2 100644 --- a/doc/salome/gui/SMESH/input/constructing_submeshes.doc +++ b/doc/salome/gui/SMESH/input/constructing_submeshes.doc @@ -58,10 +58,9 @@ same priority. If meshing parameters are defined on sub-meshes of the same priority, for example different 1D hypotheses are assigned to two faces sharing -an edge, an arbitrary algorithm/hypothesis will be used for -meshing. This indeterminacy can be fixed by -\ref submesh_order_anchor "Changing" mutual priority of such -concurrent sub-meshes. +an edge, the hypothesis assigned to a sub-shape with a lower ID will +be used for meshing. You can \ref submesh_order_anchor "change" mutual +priority of such concurrent sub-meshes. \n Construction of a sub-mesh consists of: diff --git a/idl/SMESH_BasicHypothesis.idl b/idl/SMESH_BasicHypothesis.idl index 6bef50d0b..274365bf2 100644 --- a/idl/SMESH_BasicHypothesis.idl +++ b/idl/SMESH_BasicHypothesis.idl @@ -876,7 +876,7 @@ module StdMeshers * interface of "Viscous Layers" hypothesis. * This hypothesis specifies parameters of layers of prisms to build * near mesh boundary. This hypothesis can be used by several 3D algorithms: - * NETGEN 3D, GHS3D, Hexahedron(i,j,k) + * NETGEN 3D, Hexahedron(i,j,k), MG_Tetra */ interface StdMeshers_ViscousLayers : SMESH::SMESH_Hypothesis { @@ -907,7 +907,7 @@ module StdMeshers short GetNumberLayers(); /*! - * Set factor (>1.0) of growth of layer thickness towards inside of mesh + * Set factor (>=1.0) of growth of layer thickness towards inside of mesh */ void SetStretchFactor(in double factor) raises (SALOME::SALOME_Exception); double GetStretchFactor(); @@ -951,7 +951,7 @@ module StdMeshers short GetNumberLayers(); /*! - * Set factor (>1.0) of growth of layer thickness towards inside of mesh + * Set factor (>=1.0) of growth of layer thickness towards inside of mesh */ void SetStretchFactor(in double factor) raises (SALOME::SALOME_Exception); double GetStretchFactor(); diff --git a/src/SMESH/SMESH_Hypothesis.hxx b/src/SMESH/SMESH_Hypothesis.hxx index e13abadb7..0ff9df96f 100644 --- a/src/SMESH/SMESH_Hypothesis.hxx +++ b/src/SMESH/SMESH_Hypothesis.hxx @@ -79,13 +79,15 @@ public: virtual void NotifySubMeshesHypothesisModification(); void SetLibName(const char* theLibName); - //void SetParameters(const char *theParameters); - //char* GetParameters() const; + /*! + * \brief The returned value is used by NotifySubMeshesHypothesisModification() + * to decide to call subMesh->AlgoStateEngine( MODIF_HYP, hyp ) or not + * if subMesh is ready to be computed (algo+hyp==OK) but not yet computed. + * True result is reasonable for example if EventListeners depend on + * parameters of hypothesis. + */ + virtual bool DataDependOnParams() const { return false; } - // void SetLastParameters(const char* theParameters); - // char* GetLastParameters() const; - // void ClearParameters(); - /*! * \brief Initialize my parameter values by the mesh built on the geometry * \param theMesh - the built mesh diff --git a/src/SMESH/SMESH_Mesh.cxx b/src/SMESH/SMESH_Mesh.cxx index 7c70d5f71..20deb04a6 100644 --- a/src/SMESH/SMESH_Mesh.cxx +++ b/src/SMESH/SMESH_Mesh.cxx @@ -1215,7 +1215,8 @@ void SMESH_Mesh::NotifySubMeshesHypothesisModification(const SMESH_Hypothesis* h // other possible changes are not interesting. (IPAL0052457 - assigning hyp performance pb) if ( aSubMesh->GetComputeState() != SMESH_subMesh::COMPUTE_OK && aSubMesh->GetComputeState() != SMESH_subMesh::FAILED_TO_COMPUTE && - aSubMesh->GetAlgoState() != SMESH_subMesh::MISSING_HYP ) + aSubMesh->GetAlgoState() != SMESH_subMesh::MISSING_HYP && + !hyp->DataDependOnParams() ) continue; const TopoDS_Shape & aSubShape = aSubMesh->GetSubShape(); diff --git a/src/SMESH_SWIG/StdMeshersBuilder.py b/src/SMESH_SWIG/StdMeshersBuilder.py index fcb3d2d3f..41e0c2269 100644 --- a/src/SMESH_SWIG/StdMeshersBuilder.py +++ b/src/SMESH_SWIG/StdMeshersBuilder.py @@ -1345,15 +1345,13 @@ class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm): # @param UseExisting if ==true - searches for the existing hypothesis created with # the same parameters, else (default) - creates a new one def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False): - for group in groups: - from salome.smesh.smeshBuilder import AssureGeomPublished - AssureGeomPublished( self.mesh, group ) compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \ hyp.GetCopySourceMesh() == args[1], args[2] ) hyp = self.Hypothesis("ImportSource2D", [groups, toCopyMesh, toCopyGroups], - UseExisting=UseExisting, CompareMethod=compFun) + UseExisting=UseExisting, CompareMethod=compFun, toAdd=False) hyp.SetSourceFaces(groups) hyp.SetCopySourceMesh(toCopyMesh, toCopyGroups) + self.mesh.AddHypothesis(hyp, self.geom) return hyp pass # end of StdMeshersBuilder_UseExistingElements_1D2D class diff --git a/src/StdMeshers/StdMeshers_ImportSource.hxx b/src/StdMeshers/StdMeshers_ImportSource.hxx index c3e8260d2..cb1db4440 100644 --- a/src/StdMeshers/StdMeshers_ImportSource.hxx +++ b/src/StdMeshers/StdMeshers_ImportSource.hxx @@ -61,6 +61,7 @@ class STDMESHERS_EXPORT StdMeshers_ImportSource1D : public SMESH_Hypothesis virtual std::istream & LoadFrom(std::istream & load); virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape); virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0); + virtual bool DataDependOnParams() const { return true; } void RestoreGroups(const std::vector& groups); void StoreResultGroups(const std::vector& groups, diff --git a/src/StdMeshers/StdMeshers_Import_1D2D.cxx b/src/StdMeshers/StdMeshers_Import_1D2D.cxx index 8cbcefe53..17b5b5a9d 100644 --- a/src/StdMeshers/StdMeshers_Import_1D2D.cxx +++ b/src/StdMeshers/StdMeshers_Import_1D2D.cxx @@ -44,15 +44,20 @@ #include "Utils_SALOME_Exception.hxx" #include "utilities.h" +#include +#include #include #include +#include +#include +#include +#include #include #include #include #include #include #include -#include #include @@ -187,9 +192,28 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & Handle(Geom_Surface) surface = BRep_Tool::Surface( geomFace ); const bool reverse = - ( helper.GetSubShapeOri( tgtMesh->ShapeToMesh(), geomFace) == TopAbs_REVERSED ); + ( helper.GetSubShapeOri( tgtMesh->ShapeToMesh(), geomFace ) == TopAbs_REVERSED ); gp_Pnt p; gp_Vec du, dv; + BRepClass_FaceClassifier classifier; + Bnd_B2d bndBox2d; + { + Standard_Real umin,umax,vmin,vmax; + BRepTools::UVBounds(geomFace,umin,umax,vmin,vmax); + gp_XY pmin( umin,vmin ), pmax( umax,vmax ); + bndBox2d.Add( pmin ); + bndBox2d.Add( pmax ); + if ( helper.HasSeam() ) + { + const int i = helper.GetPeriodicIndex(); + pmin.SetCoord( i, helper.GetOtherParam( pmin.Coord( i ))); + pmax.SetCoord( i, helper.GetOtherParam( pmax.Coord( i ))); + bndBox2d.Add( pmin ); + bndBox2d.Add( pmax ); + } + bndBox2d.Enlarge( 1e-2 * Sqrt( bndBox2d.SquareExtent() )); + } + set subShapeIDs; subShapeIDs.insert( shapeID ); @@ -244,7 +268,10 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & StdMeshers_Import_1D::TNodeNodeMap* n2n; StdMeshers_Import_1D::TElemElemMap* e2e; - vector newNodes; + vector nodeState; + vector newNodes; // of a face + set bndNodes; // nodes classified ON + for ( size_t iG = 0; iG < srcGroups.size(); ++iG ) { const SMESHDS_GroupBase* srcGroup = srcGroups[iG]->GetGroupDS(); @@ -257,58 +284,126 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & const double groupTol = 0.5 * sqrt( getMinElemSize2( srcGroup )); minGroupTol = std::min( groupTol, minGroupTol ); + GeomAdaptor_Surface S( surface ); + const double clsfTol = Min( S.UResolution( 0.1 * groupTol ), + S.VResolution( 0.1 * groupTol )); + + StdMeshers_Import_1D::TNodeNodeMap::iterator n2nIt; + pair< StdMeshers_Import_1D::TNodeNodeMap::iterator, bool > it_isnew; + SMDS_ElemIteratorPtr srcElems = srcGroup->GetElements(); - SMDS_MeshNode *tmpNode = helper.AddNode(0,0,0); - gp_XY uv( Precision::Infinite(), Precision::Infinite() ); while ( srcElems->more() ) // loop on group contents { const SMDS_MeshElement* face = srcElems->next(); + // find or create nodes of a new face - newNodes.resize( face->NbNodes() ); + nodeState.resize( face->NbNodes() ); + newNodes.resize( nodeState.size() ); newNodes.back() = 0; int nbCreatedNodes = 0; + bool isOut = false, isIn = false; // if at least one node isIn - do not classify other nodes SMDS_MeshElement::iterator node = face->begin_nodes(); for ( size_t i = 0; i < newNodes.size(); ++i, ++node ) { - StdMeshers_Import_1D::TNodeNodeMap::iterator n2nIt = - n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )).first; - if ( n2nIt->second ) + SMESH_TNodeXYZ nXYZ = *node; + nodeState[ i ] = TopAbs_UNKNOWN; + + it_isnew = n2n->insert( make_pair( *node, (SMDS_MeshNode*)0 )); + n2nIt = it_isnew.first; + + const SMDS_MeshNode* & newNode = n2nIt->second; + if ( !it_isnew.second && !newNode ) + break; // a node is mapped to NULL - it is OUT of the FACE + + if ( newNode ) { - if ( !subShapeIDs.count( n2nIt->second->getshapeId() )) // node already on an EDGE - break; + if ( !subShapeIDs.count( newNode->getshapeId() )) + break; // node is Imported onto other FACE + if ( !isIn && bndNodes.count( *node )) + nodeState[ i ] = TopAbs_ON; } else { - // find a pre-existing node + // find a node pre-existing on EDGE or VERTEX dist2foundNodes.clear(); - existingNodeOcTr.NodesAround( SMESH_TNodeXYZ( *node ), dist2foundNodes, groupTol ); + existingNodeOcTr.NodesAround( nXYZ, dist2foundNodes, groupTol ); if ( !dist2foundNodes.empty() ) - (*n2nIt).second = dist2foundNodes.begin()->second; - } - if ( !n2nIt->second ) - { - // find out if node lies on theShape - tmpNode->setXYZ( (*node)->X(), (*node)->Y(), (*node)->Z()); - uv.SetCoord( Precision::Infinite(), Precision::Infinite() ); - if ( helper.CheckNodeUV( geomFace, tmpNode, uv, groupTol, /*force=*/true )) { - SMDS_MeshNode* newNode = tgtMesh->AddNode( (*node)->X(), (*node)->Y(), (*node)->Z()); - n2nIt->second = newNode; - tgtMesh->SetNodeOnFace( newNode, shapeID, uv.X(), uv.Y() ); - nbCreatedNodes++; + newNode = dist2foundNodes.begin()->second; + nodeState[ i ] = TopAbs_ON; } } - if ( !(newNodes[i] = n2nIt->second )) + + if ( !newNode ) + { + // find out if node lies on the surface of theShape + gp_XY uv( Precision::Infinite(), 0 ); + isOut = ( !helper.CheckNodeUV( geomFace, *node, uv, groupTol, /*force=*/true ) || + bndBox2d.IsOut( uv )); + if ( !isOut && !isIn ) // classify + { + classifier.Perform( geomFace, uv, clsfTol ); + nodeState[i] = classifier.State(); + isOut = ( nodeState[i] == TopAbs_OUT ); + } + if ( !isOut ) // create a new node + { + newNode = tgtMesh->AddNode( nXYZ.X(), nXYZ.Y(), nXYZ.Z()); + tgtMesh->SetNodeOnFace( newNode, shapeID, uv.X(), uv.Y() ); + nbCreatedNodes++; + if ( nodeState[i] == TopAbs_ON ) + bndNodes.insert( *node ); + else + isIn = true; + } + } + if ( !(newNodes[i] = newNode ) || isOut ) break; } + if ( !newNodes.back() ) continue; // not all nodes of the face lie on theShape + if ( !isIn ) // if all nodes are on FACE boundary, a mesh face can be OUT + { + // check state of nodes created for other faces + for ( size_t i = 0; i < nodeState.size() && !isIn; ++i ) + { + if ( nodeState[i] != TopAbs_UNKNOWN ) continue; + gp_XY uv = helper.GetNodeUV( geomFace, newNodes[i] ); + classifier.Perform( geomFace, uv, clsfTol ); + nodeState[i] = classifier.State(); + isIn = ( nodeState[i] == TopAbs_IN ); + } + if ( !isIn ) // classify face center + { + gp_XYZ gc( 0., 0., 0 ); + for ( size_t i = 0; i < newNodes.size(); ++i ) + gc += SMESH_TNodeXYZ( newNodes[i] ); + gc /= newNodes.size(); + + TopLoc_Location loc; + GeomAPI_ProjectPointOnSurf& proj = helper.GetProjector( geomFace, + loc, + helper.MaxTolerance( geomFace )); + if ( !loc.IsIdentity() ) loc.Transformation().Inverted().Transforms( gc ); + proj.Perform( gc ); + if ( !proj.IsDone() || proj.NbPoints() < 1 ) + continue; + Quantity_Parameter U,V; + proj.LowerDistanceParameters(U,V); + gp_XY uv( U,V ); + classifier.Perform( geomFace, uv, clsfTol ); + if ( classifier.State() != TopAbs_IN ) + continue; + } + } + // try to find already created face SMDS_MeshElement * newFace = 0; if ( nbCreatedNodes == 0 && tgtMesh->FindElement(newNodes, SMDSAbs_Face, /*noMedium=*/false)) - continue; // repeated face in source groups already created + continue; // repeated face in source groups already created // check future face orientation const int nbCorners = face->NbCornerNodes(); @@ -319,7 +414,7 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & gp_Vec geomNorm; do { - uv = helper.GetNodeUV( geomFace, newNodes[++iNode] ); + gp_XY uv = helper.GetNodeUV( geomFace, newNodes[++iNode] ); surface->D1( uv.X(),uv.Y(), p, du,dv ); geomNorm = reverse ? dv^du : du^dv; } @@ -384,9 +479,15 @@ bool StdMeshers_Import_1D2D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & // } } } - helper.GetMeshDS()->RemoveNode(tmpNode); + // Remove OUT nodes from n2n map + for ( n2nIt = n2n->begin(); n2nIt != n2n->end(); ) + if ( !n2nIt->second ) + n2n->erase( n2nIt++ ); + else + ++n2nIt; } + // ========================================================== // Put nodes on geom edges and create edges on them; // check if the whole geom face is covered by imported faces diff --git a/src/StdMeshers/StdMeshers_ViscousLayers.cxx b/src/StdMeshers/StdMeshers_ViscousLayers.cxx index 5d287cea0..61df856fe 100644 --- a/src/StdMeshers/StdMeshers_ViscousLayers.cxx +++ b/src/StdMeshers/StdMeshers_ViscousLayers.cxx @@ -1590,7 +1590,7 @@ SMESH_ComputeErrorPtr _ViscousBuilder::CheckHypotheses( SMESH_Mesh& mesh findSolidsWithLayers(); - bool ok = findFacesWithLayers(); + bool ok = findFacesWithLayers( true ); // remove _MeshOfSolid's of _SolidData's for ( size_t i = 0; i < _sdVec.size(); ++i )