X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=413a9249439750c71c91cc85d961dfc3a2a1935c;hb=a695ce3aeecb27a023e248ccb9433d62916308cd;hp=cf4120437517a5885616c93e3d1a473df4ea0072;hpb=7b33bc39fd54725e6444d8814129c6fffd826617;p=modules%2Fsmesh.git diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx index cf4120437..413a92494 100644 --- a/src/StdMeshers/StdMeshers_Regular_1D.cxx +++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx @@ -1,4 +1,4 @@ -// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE // // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS @@ -6,7 +6,7 @@ // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either -// version 2.1 of the License. +// version 2.1 of the License, or (at your option) any later version. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -37,6 +37,7 @@ #include "SMESH_subMeshEventListener.hxx" #include "StdMeshers_Adaptive1D.hxx" #include "StdMeshers_Arithmetic1D.hxx" +#include "StdMeshers_Geometric1D.hxx" #include "StdMeshers_AutomaticLength.hxx" #include "StdMeshers_Deflection1D.hxx" #include "StdMeshers_Distribution.hxx" @@ -67,6 +68,7 @@ #include using namespace std; +using namespace StdMeshers; //============================================================================= /*! @@ -89,12 +91,14 @@ StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId, _compatibleHypothesis.push_back("StartEndLength"); _compatibleHypothesis.push_back("Deflection1D"); _compatibleHypothesis.push_back("Arithmetic1D"); + _compatibleHypothesis.push_back("GeometricProgression"); _compatibleHypothesis.push_back("FixedPoints1D"); _compatibleHypothesis.push_back("AutomaticLength"); _compatibleHypothesis.push_back("Adaptive1D"); - - _compatibleHypothesis.push_back("QuadraticMesh"); // auxiliary !!! - _compatibleHypothesis.push_back("Propagation"); // auxiliary !!! + // auxiliary: + _compatibleHypothesis.push_back("QuadraticMesh"); + _compatibleHypothesis.push_back("Propagation"); + _compatibleHypothesis.push_back("PropagOfDistribution"); } //============================================================================= @@ -109,7 +113,7 @@ StdMeshers_Regular_1D::~StdMeshers_Regular_1D() //============================================================================= /*! - * + * */ //============================================================================= @@ -124,13 +128,18 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh, const list & hyps = GetUsedHypothesis(aMesh, aShape, /*ignoreAuxiliaryHyps=*/false); + const SMESH_HypoFilter & propagFilter = StdMeshers_Propagation::GetFilter(); + // find non-auxiliary hypothesis const SMESHDS_Hypothesis *theHyp = 0; + set< string > propagTypes; list ::const_iterator h = hyps.begin(); for ( ; h != hyps.end(); ++h ) { if ( static_cast(*h)->IsAuxiliary() ) { if ( strcmp( "QuadraticMesh", (*h)->GetName() ) == 0 ) _quadraticMesh = true; + if ( propagFilter.IsOk( static_cast< const SMESH_Hypothesis*>( *h ), aShape )) + propagTypes.insert( (*h)->GetName() ); } else { if ( !theHyp ) @@ -223,6 +232,21 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh, aStatus = SMESH_Hypothesis::HYP_OK; } + else if (hypName == "GeometricProgression") + { + const StdMeshers_Geometric1D * hyp = + dynamic_cast (theHyp); + ASSERT(hyp); + _value[ BEG_LENGTH_IND ] = hyp->GetStartLength(); + _value[ END_LENGTH_IND ] = hyp->GetCommonRatio(); + ASSERT( _value[ BEG_LENGTH_IND ] > 0 && _value[ END_LENGTH_IND ] > 0 ); + _hypType = GEOMETRIC_1D; + + _revEdgesIDs = hyp->GetReversedEdges(); + + aStatus = SMESH_Hypothesis::HYP_OK; + } + else if (hypName == "FixedPoints1D") { _fpHyp = dynamic_cast (theHyp); ASSERT(_fpHyp); @@ -275,16 +299,53 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh, ASSERT(_adaptiveHyp); _hypType = ADAPTIVE; _onlyUnaryInput = false; + aStatus = SMESH_Hypothesis::HYP_OK; } else + { aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE; + } - return ( _hypType != NONE ); + if ( propagTypes.size() > 1 && aStatus == HYP_OK ) + { + // detect concurrent Propagation hyps + _usedHypList.clear(); + list< TopoDS_Shape > assignedTo; + if ( aMesh.GetHypotheses( aShape, propagFilter, _usedHypList, true, &assignedTo ) > 1 ) + { + // find most simple shape and a hyp on it + int simpleShape = TopAbs_COMPOUND; + const SMESHDS_Hypothesis* localHyp = 0; + list< TopoDS_Shape >::iterator shape = assignedTo.begin(); + list< const SMESHDS_Hypothesis *>::iterator hyp = _usedHypList.begin(); + for ( ; shape != assignedTo.end(); ++shape ) + if ( shape->ShapeType() > simpleShape ) + { + simpleShape = shape->ShapeType(); + localHyp = (*hyp); + } + // check if there a different hyp on simpleShape + shape = assignedTo.begin(); + hyp = _usedHypList.begin(); + for ( ; hyp != _usedHypList.end(); ++hyp, ++shape ) + if ( shape->ShapeType() == simpleShape && + !localHyp->IsSameName( **hyp )) + { + aStatus = HYP_INCOMPAT_HYPS; + return error( SMESH_Comment("Hypotheses of both \"") + << StdMeshers_Propagation::GetName() << "\" and \"" + << StdMeshers_PropagOfDistribution::GetName() + << "\" types can't be applied to the same edge"); + } + } + } + + return ( aStatus == SMESH_Hypothesis::HYP_OK ); } -static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, - double length, bool theReverse, - int nbSeg, Function& func, +static bool computeParamByFunc(Adaptor3d_Curve& C3d, + double first, double last, double length, + bool theReverse, int nbSeg, Function& func, list& theParams) { // never do this way @@ -298,31 +359,23 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, int nbPnt = 1 + nbSeg; vector x(nbPnt, 0.); - if (!buildDistribution(func, 0.0, 1.0, nbSeg, x, 1E-4)) + if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 )) return false; - MESSAGE( "Points:\n" ); - char buf[1024]; - for ( int i=0; i<=nbSeg; i++ ) - { - sprintf( buf, "%f\n", float(x[i] ) ); - MESSAGE( buf ); - } - - - // apply parameters in range [0,1] to the space of the curve double prevU = first; - double sign = 1.; - if (theReverse) + double sign = 1.; + if ( theReverse ) { prevU = last; - sign = -1.; + sign = -1.; } - for( int i = 1; i < nbSeg; i++ ) + + for ( int i = 1; i < nbSeg; i++ ) { double curvLength = length * (x[i] - x[i-1]) * sign; - GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU ); + double tol = Min( Precision::Confusion(), curvLength / 100. ); + GCPnts_AbscissaPoint Discret( tol, C3d, curvLength, prevU ); if ( !Discret.IsDone() ) return false; double U = Discret.Parameter(); @@ -616,6 +669,61 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, double f = theFirstU, l = theLastU; + // Propagation Of Distribution + // + if ( !_mainEdge.IsNull() && _isPropagOfDistribution ) + { + TopoDS_Edge mainEdge = TopoDS::Edge( _mainEdge ); // should not be a reference! + _gen->Compute( theMesh, mainEdge, /*aShapeOnly=*/true, /*anUpward=*/true); + + SMESHDS_SubMesh* smDS = theMesh.GetMeshDS()->MeshElements( mainEdge ); + if ( !smDS ) + return error("No mesh on the source edge of Propagation Of Distribution"); + if ( smDS->NbNodes() < 1 ) + return true; // 1 segment + + map< double, const SMDS_MeshNode* > mainEdgeParamsOfNodes; + if ( ! SMESH_Algo::GetSortedNodesOnEdge( theMesh.GetMeshDS(), mainEdge, _quadraticMesh, + mainEdgeParamsOfNodes, SMDSAbs_Edge )) + return error("Bad node parameters on the source edge of Propagation Of Distribution"); + + vector< double > segLen( mainEdgeParamsOfNodes.size() - 1 ); + double totalLen = 0; + BRepAdaptor_Curve mainEdgeCurve( mainEdge ); + map< double, const SMDS_MeshNode* >::iterator + u_n2 = mainEdgeParamsOfNodes.begin(), u_n1 = u_n2++; + for ( size_t i = 1; i < mainEdgeParamsOfNodes.size(); ++i, ++u_n1, ++u_n2 ) + { + segLen[ i-1 ] = GCPnts_AbscissaPoint::Length( mainEdgeCurve, + u_n1->first, + u_n2->first); + totalLen += segLen[ i-1 ]; + } + for ( size_t i = 0; i < segLen.size(); ++i ) + segLen[ i ] *= theLength / totalLen; + + size_t iSeg = theReverse ? segLen.size()-1 : 0; + size_t dSeg = theReverse ? -1 : +1; + double param = theFirstU; + size_t nbParams = 0; + for ( int i = 0, nb = segLen.size()-1; i < nb; ++i, iSeg += dSeg ) + { + GCPnts_AbscissaPoint Discret( theC3d, segLen[ iSeg ], param ); + if ( !Discret.IsDone() ) break; + param = Discret.Parameter(); + theParams.push_back( param ); + ++nbParams; + } + if ( nbParams != segLen.size()-1 ) + return error( SMESH_Comment("Can't divide into ") << segLen.size() << " segements"); + + compensateError( segLen[ theReverse ? segLen.size()-1 : 0 ], + segLen[ theReverse ? 0 : segLen.size()-1 ], + f, l, theLength, theC3d, theParams, true ); + return true; + } + + switch( _hypType ) { case LOCAL_LENGTH: @@ -824,12 +932,57 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, return true; } + case GEOMETRIC_1D: { + + double a1 = _value[ BEG_LENGTH_IND ], an; + double q = _value[ END_LENGTH_IND ]; + + double U1 = theReverse ? l : f; + double Un = theReverse ? f : l; + double param = U1; + double eltSize = a1; + if ( theReverse ) + eltSize = -eltSize; + + int nbParams = 0; + while ( true ) { + // computes a point on a curve at the distance + // from the point of parameter . + GCPnts_AbscissaPoint Discret( theC3d, eltSize, param ); + if ( !Discret.IsDone() ) break; + param = Discret.Parameter(); + if ( f < param && param < l ) + theParams.push_back( param ); + else + break; + an = eltSize; + eltSize *= q; + ++nbParams; + } + if ( nbParams > 1 ) + { + if ( Abs( param - Un ) < 0.2 * Abs( param - theParams.back() )) + { + compensateError( a1, Abs(eltSize), U1, Un, theLength, theC3d, theParams ); + } + else if ( Abs( Un - theParams.back() ) < + 0.2 * Abs( theParams.back() - *(++theParams.rbegin()))) + { + theParams.pop_back(); + compensateError( a1, Abs(an), U1, Un, theLength, theC3d, theParams ); + } + } + if (theReverse) theParams.reverse(); // NPAL18025 + + return true; + } + case FIXED_POINTS_1D: { const std::vector& aPnts = _fpHyp->GetPoints(); - const std::vector& nbsegs = _fpHyp->GetNbSegments(); - int i = 0; + const std::vector& nbsegs = _fpHyp->GetNbSegments(); TColStd_SequenceOfReal Params; - for(; i0.9999 ) continue; int j=1; bool IsExist = false; @@ -853,8 +1006,9 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, } double eltSize, segmentSize = 0.; double currAbscissa = 0; - for(i=0; i nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i]; + for ( int i = 0; i < Params.Length(); i++ ) + { + int nbseg = ( i > (int)nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i]; segmentSize = Params.Value(i+1)*theLength - currAbscissa; currAbscissa += segmentSize; GCPnts_AbscissaPoint APnt(theC3d, sign*segmentSize, par1); @@ -891,7 +1045,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh, par1 = par2; } // add for last - int nbseg = ( nbsegs.size() > Params.Length() ) ? nbsegs[Params.Length()] : nbsegs[0]; + int nbseg = ( (int)nbsegs.size() > Params.Length() ) ? nbsegs[Params.Length()] : nbsegs[0]; segmentSize = theLength - currAbscissa; eltSize = segmentSize/nbseg; GCPnts_UniformAbscissa Discret; @@ -960,7 +1114,7 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t if ( _hypType == ADAPTIVE ) { _adaptiveHyp->GetAlgo()->InitComputeError(); - _adaptiveHyp->GetAlgo()->Compute( theMesh, theShape, &_progress, &_progressTic ); + _adaptiveHyp->GetAlgo()->Compute( theMesh, theShape ); return error( _adaptiveHyp->GetAlgo()->GetComputeError() ); } @@ -1012,10 +1166,13 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t } if ( !_mainEdge.IsNull() ) { // take into account reversing the edge the hypothesis is propagated from + // (_mainEdge.Orientation() marks mutual orientation of EDGEs in propagation chain) reversed = ( _mainEdge.Orientation() == TopAbs_REVERSED ); - int mainID = meshDS->ShapeToIndex(_mainEdge); - if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end()) - reversed = !reversed; + if ( !_isPropagOfDistribution ) { + int mainID = meshDS->ShapeToIndex(_mainEdge); + if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), mainID) != _revEdgesIDs.end()) + reversed = !reversed; + } } // take into account this edge reversing if ( std::find( _revEdgesIDs.begin(), _revEdgesIDs.end(), shapeID) != _revEdgesIDs.end()) @@ -1221,22 +1378,22 @@ StdMeshers_Regular_1D::GetUsedHypothesis(SMESH_Mesh & aMesh, _usedHypList.clear(); _mainEdge.Nullify(); - SMESH_HypoFilter auxiliaryFilter, compatibleFilter; - auxiliaryFilter.Init( SMESH_HypoFilter::IsAuxiliary() ); - InitCompatibleHypoFilter( compatibleFilter, /*ignoreAux=*/true ); + SMESH_HypoFilter auxiliaryFilter( SMESH_HypoFilter::IsAuxiliary() ); + const SMESH_HypoFilter* compatibleFilter = GetCompatibleHypoFilter(/*ignoreAux=*/true ); // get non-auxiliary assigned directly to aShape - int nbHyp = aMesh.GetHypotheses( aShape, compatibleFilter, _usedHypList, false ); + int nbHyp = aMesh.GetHypotheses( aShape, *compatibleFilter, _usedHypList, false ); if (nbHyp == 0 && aShape.ShapeType() == TopAbs_EDGE) { // Check, if propagated from some other edge - _mainEdge = StdMeshers_Propagation::GetPropagationSource( aMesh, aShape ); + _mainEdge = StdMeshers_Propagation::GetPropagationSource( aMesh, aShape, + _isPropagOfDistribution ); if ( !_mainEdge.IsNull() ) { // Propagation of 1D hypothesis from on this edge; // get non-auxiliary assigned to _mainEdge - nbHyp = aMesh.GetHypotheses( _mainEdge, compatibleFilter, _usedHypList, true ); + nbHyp = aMesh.GetHypotheses( _mainEdge, *compatibleFilter, _usedHypList, true ); } }