X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=d3d92f9ea20d8a66a327c83c04ee3208f5623fbc;hb=da425c6a4aa2f29deb92e1ebbebbd0855f373b16;hp=d7d2e844e7f99fa4079d1fa6628e88df670fb2c8;hpb=ed456586bfb1411c5bff73b221658766689a6253;p=modules%2Fsmesh.git diff --git a/src/StdMeshers/StdMeshers_Regular_1D.cxx b/src/StdMeshers/StdMeshers_Regular_1D.cxx index d7d2e844e..d3d92f9ea 100644 --- a/src/StdMeshers/StdMeshers_Regular_1D.cxx +++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx @@ -30,20 +30,26 @@ using namespace std; #include "StdMeshers_Regular_1D.hxx" +#include "StdMeshers_Distribution.hxx" #include "SMESH_Gen.hxx" #include "SMESH_Mesh.hxx" +#include "SMESH_HypoFilter.hxx" +#include "SMESH_subMesh.hxx" + +#include #include "StdMeshers_LocalLength.hxx" #include "StdMeshers_NumberOfSegments.hxx" #include "StdMeshers_Arithmetic1D.hxx" #include "StdMeshers_StartEndLength.hxx" #include "StdMeshers_Deflection1D.hxx" +#include "StdMeshers_AutomaticLength.hxx" #include "SMDS_MeshElement.hxx" #include "SMDS_MeshNode.hxx" #include "SMDS_EdgePosition.hxx" -#include "SMESH_subMesh.hxx" +#include "Utils_SALOME_Exception.hxx" #include "utilities.h" #include @@ -56,9 +62,14 @@ using namespace std; #include #include #include +#include +#include +#include +#include +#include #include -//#include +#include //============================================================================= /*! @@ -78,6 +89,7 @@ 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("AutomaticLength"); } //============================================================================= @@ -131,9 +143,29 @@ bool StdMeshers_Regular_1D::CheckHypothesis const StdMeshers_NumberOfSegments * hyp = dynamic_cast (theHyp); ASSERT(hyp); - _value[ NB_SEGMENTS_IND ] = hyp->GetNumberOfSegments(); - _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor(); - ASSERT( _value[ NB_SEGMENTS_IND ] > 0 ); + _ivalue[ NB_SEGMENTS_IND ] = hyp->GetNumberOfSegments(); + ASSERT( _ivalue[ NB_SEGMENTS_IND ] > 0 ); + _ivalue[ DISTR_TYPE_IND ] = (int) hyp->GetDistrType(); + switch (_ivalue[ DISTR_TYPE_IND ]) + { + case StdMeshers_NumberOfSegments::DT_Scale: + _value[ SCALE_FACTOR_IND ] = hyp->GetScaleFactor(); + break; + case StdMeshers_NumberOfSegments::DT_TabFunc: + _vvalue[ TAB_FUNC_IND ] = hyp->GetTableFunction(); + break; + case StdMeshers_NumberOfSegments::DT_ExprFunc: + _svalue[ EXPR_FUNC_IND ] = hyp->GetExpressionFunction(); + break; + case StdMeshers_NumberOfSegments::DT_Regular: + break; + default: + ASSERT(0); + break; + } + if (_ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_TabFunc || + _ivalue[ DISTR_TYPE_IND ] == StdMeshers_NumberOfSegments::DT_ExprFunc) + _ivalue[ CONV_MODE_IND ] = hyp->ConversionMode(); _hypType = NB_SEGMENTS; aStatus = SMESH_Hypothesis::HYP_OK; } @@ -172,19 +204,126 @@ bool StdMeshers_Regular_1D::CheckHypothesis _hypType = DEFLECTION; aStatus = SMESH_Hypothesis::HYP_OK; } + + else if (hypName == "AutomaticLength") + { + StdMeshers_AutomaticLength * hyp = const_cast + (dynamic_cast (theHyp)); + ASSERT(hyp); + _value[ BEG_LENGTH_IND ] = _value[ END_LENGTH_IND ] = hyp->GetLength( &aMesh, aShape ); + ASSERT( _value[ BEG_LENGTH_IND ] > 0 ); + _hypType = LOCAL_LENGTH; + aStatus = SMESH_Hypothesis::HYP_OK; + } else aStatus = SMESH_Hypothesis::HYP_INCOMPATIBLE; return ( _hypType != NONE ); } +//======================================================================= +//function : compensateError +//purpose : adjust theParams so that the last segment length == an +//======================================================================= + +static void compensateError(double a1, double an, + double U1, double Un, + double length, + GeomAdaptor_Curve& C3d, + list & theParams) +{ + int i, nPar = theParams.size(); + if ( a1 + an < length && nPar > 1 ) + { + list::reverse_iterator itU = theParams.rbegin(); + double Ul = *itU++; + // dist from the last point to the edge end , it should be equal + double Ln = GCPnts_AbscissaPoint::Length( C3d, Ul, Un ); + double dLn = an - Ln; // error of + if ( Abs( dLn ) <= Precision::Confusion() ) + return; + double dU = Abs( Ul - *itU ); // parametric length of the last but one segment + double dUn = dLn * Abs( Un - U1 ) / length; // parametric error of + if ( dUn < 0.5 * dU ) { // last segment is a bit shorter than it should + dUn = -dUn; // move the last parameter to the edge beginning + } + else { // last segment is much shorter than it should -> remove the last param and + theParams.pop_back(); nPar--; // move the rest points toward the edge end + Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un ); + dUn = ( an - Ln ) * Abs( Un - U1 ) / length; + if ( dUn < 0.5 * dU ) + dUn = -dUn; + } + if ( U1 > Un ) + dUn = -dUn; + double q = dUn / ( nPar - 1 ); + for ( itU = theParams.rbegin(), i = 1; i < nPar; itU++, i++ ) { + (*itU) += dUn; + dUn -= q; + } + } +} + +static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, + double length, bool theReverse, + int nbSeg, Function& func, + list& theParams) +{ + OSD::SetSignal( true ); + + if( nbSeg<=0 ) + return false; + + MESSAGE( "computeParamByFunc" ); + + int nbPnt = 1 + nbSeg; + vector x(nbPnt, 0.); + + 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) + { + prevU = last; + sign = -1.; + } + for( int i = 1; i < nbSeg; i++ ) + { + double curvLength = length * (x[i] - x[i-1]) * sign; + GCPnts_AbscissaPoint Discret( C3d, curvLength, prevU ); + if ( !Discret.IsDone() ) + return false; + double U = Discret.Parameter(); + if ( U > first && U < last ) + theParams.push_back( U ); + else + return false; + prevU = U; + } + return true; +} + //============================================================================= /*! * */ //============================================================================= bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge, - list & theParams) const + list & theParams, + const bool theReverse) const { theParams.clear(); @@ -193,7 +332,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge GeomAdaptor_Curve C3d(Curve); double length = EdgeLength(theEdge); - //SCRUTE(length); switch( _hypType ) { @@ -203,6 +341,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge double eltSize = 1; if ( _hypType == LOCAL_LENGTH ) { + // Local Length hypothesis double nbseg = ceil(length / _value[ BEG_LENGTH_IND ]); // integer sup if (nbseg <= 0) nbseg = 1; // degenerated edge @@ -210,25 +349,47 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge } else { - double epsilon = 0.001; - if (fabs(_value[ SCALE_FACTOR_IND ] - 1.0) > epsilon) + // Number Of Segments hypothesis + switch (_ivalue[ DISTR_TYPE_IND ]) { - double alpha = - pow( _value[ SCALE_FACTOR_IND ], 1.0 / (_value[ NB_SEGMENTS_IND ] - 1)); - double factor = - length / (1 - pow( alpha,_value[ NB_SEGMENTS_IND ])); - - int i, NbPoints = (int) _value[ NB_SEGMENTS_IND ]; - for ( i = 2; i < NbPoints; i++ ) + case StdMeshers_NumberOfSegments::DT_Scale: { - double param = factor * (1 - pow(alpha, i - 1)); - theParams.push_back( param ); + double scale = _value[ SCALE_FACTOR_IND ]; + if ( theReverse ) + scale = 1. / scale; + double alpha = pow( scale , 1.0 / (_ivalue[ NB_SEGMENTS_IND ] - 1)); + double factor = (l - f) / (1 - pow( alpha,_ivalue[ NB_SEGMENTS_IND ])); + + int i, NbPoints = 1 + _ivalue[ NB_SEGMENTS_IND ]; + for ( i = 2; i < NbPoints; i++ ) + { + double param = f + factor * (1 - pow(alpha, i - 1)); + theParams.push_back( param ); + } + return true; } - return true; - } - else - { - eltSize = length / _value[ NB_SEGMENTS_IND ]; + break; + case StdMeshers_NumberOfSegments::DT_TabFunc: + { + FunctionTable func(_vvalue[ TAB_FUNC_IND ], _ivalue[ CONV_MODE_IND ]); + return computeParamByFunc(C3d, f, l, length, theReverse, + _ivalue[ NB_SEGMENTS_IND ], func, + theParams); + } + break; + case StdMeshers_NumberOfSegments::DT_ExprFunc: + { + FunctionExpr func(_svalue[ EXPR_FUNC_IND ].c_str(), _ivalue[ CONV_MODE_IND ]); + return computeParamByFunc(C3d, f, l, length, theReverse, + _ivalue[ NB_SEGMENTS_IND ], func, + theParams); + } + break; + case StdMeshers_NumberOfSegments::DT_Regular: + eltSize = length / _ivalue[ NB_SEGMENTS_IND ]; + break; + default: + return false; } } @@ -242,6 +403,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge double param = Discret.Parameter(i); theParams.push_back( param ); } + compensateError( eltSize, eltSize, f, l, length, C3d, theParams ); // for PAL9899 return true; } @@ -253,102 +415,77 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge double an = _value[ END_LENGTH_IND ]; double q = ( length - a1 ) / ( length - an ); - double U1 = Min ( f, l ); - double Un = Max ( f, l ); + double U1 = theReverse ? l : f; + double Un = theReverse ? f : l; double param = U1; - double eltSize = a1; + double eltSize = theReverse ? -a1 : a1; while ( 1 ) { // computes a point on a curve at the distance // from the point of parameter . GCPnts_AbscissaPoint Discret( C3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); - if ( param < Un ) + if ( param > f && param < l ) theParams.push_back( param ); else break; eltSize *= q; } - if ( a1 + an < length ) { - // compensate error - double Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un ); - double dLn = an - Ln; - if ( dLn < 0.5 * an ) - dLn = -dLn; - else { - theParams.pop_back(); - Ln = GCPnts_AbscissaPoint::Length( C3d, theParams.back(), Un ); - dLn = an - Ln; - if ( dLn < 0.5 * an ) - dLn = -dLn; - } - double dUn = dLn * ( Un - U1 ) / length; -// SCRUTE( Ln ); -// SCRUTE( dLn ); -// SCRUTE( dUn ); - list::reverse_iterator itU = theParams.rbegin(); - int i, n = theParams.size(); - for ( i = 1 ; i < n; itU++, i++ ) { - (*itU) += dUn; - dUn /= q; - } - } - + compensateError( a1, an, U1, Un, length, C3d, theParams ); return true; } - case DEFLECTION: { - - GCPnts_UniformDeflection Discret(C3d, _value[ DEFLECTION_IND ], true); - if ( !Discret.IsDone() ) - return false; - - int NbPoints = Discret.NbPoints(); - for ( int i = 2; i < NbPoints; i++ ) - { - double param = Discret.Parameter(i); - theParams.push_back( param ); - } - return true; - - } - case ARITHMETIC_1D: { - // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = length + + // arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = length double a1 = _value[ BEG_LENGTH_IND ]; double an = _value[ END_LENGTH_IND ]; - double nd = (2 * length) / (an + a1) - 1; - int n = int(nd); - if(n != nd) - n++; + double q = ( an - a1 ) / ( 2 *length/( a1 + an ) - 1 ); + int n = int( 1 + ( an - a1 ) / q ); - double q = ((2 * length) / (n + 1) - 2 * a1) / n; - double U1 = Min ( f, l ); - double Un = Max ( f, l ); + double U1 = theReverse ? l : f; + double Un = theReverse ? f : l; double param = U1; double eltSize = a1; - - double L=0; - while ( 1 ) { - L+=eltSize; + if ( theReverse ) { + eltSize = -eltSize; + q = -q; + } + while ( n-- > 0 && eltSize * ( Un - U1 ) > 0 ) { // computes a point on a curve at the distance // from the point of parameter . GCPnts_AbscissaPoint Discret( C3d, eltSize, param ); if ( !Discret.IsDone() ) break; param = Discret.Parameter(); - if ( fabs(param - Un) > Precision::Confusion() && param < Un) { + if ( param > f && param < l ) theParams.push_back( param ); - } else break; eltSize += q; } + compensateError( a1, an, U1, Un, length, C3d, theParams ); return true; } + case DEFLECTION: { + + GCPnts_UniformDeflection Discret(C3d, _value[ DEFLECTION_IND ], true); + if ( !Discret.IsDone() ) + return false; + + int NbPoints = Discret.NbPoints(); + for ( int i = 2; i < NbPoints; i++ ) + { + double param = Discret.Parameter(i); + theParams.push_back( param ); + } + return true; + + } + default:; } @@ -371,8 +508,13 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh SMESHDS_Mesh * meshDS = aMesh.GetMeshDS(); aMesh.GetSubMesh(aShape); + // quardatic mesh required? + SMESH_HypoFilter filter( SMESH_HypoFilter::HasName( "QuadraticMesh" )); + bool isQuadraticMesh = aMesh->GetHypothesis( aShape, filter, true ); + const TopoDS_Edge & EE = TopoDS::Edge(aShape); TopoDS_Edge E = TopoDS::Edge(EE.Oriented(TopAbs_FORWARD)); + int shapeID = meshDS->ShapeToIndex( E ); double f, l; Handle(Geom_Curve) Curve = BRep_Tool::Curve(E, f, l); @@ -401,8 +543,11 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh if (!Curve.IsNull()) { list< double > params; + bool reversed = false; + if ( !_mainEdge.IsNull() ) + reversed = aMesh.IsReversedInChain( EE, _mainEdge ); try { - if ( ! computeInternalParameters( E, params )) + if ( ! computeInternalParameters( E, params, reversed )) return false; } catch ( Standard_Failure ) { @@ -421,19 +566,14 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh //Add the Node in the DataStructure SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z()); - meshDS->SetNodeOnEdge(node, E); - - // **** edgePosition associe au point = param. - SMDS_EdgePosition* epos = - dynamic_cast(node->GetPosition().get()); - epos->SetUParameter(param); + meshDS->SetNodeOnEdge(node, shapeID, param); SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); - meshDS->SetMeshElementOnShape(edge, E); + meshDS->SetMeshElementOnShape(edge, shapeID); idPrev = node; } SMDS_MeshEdge* edge = meshDS->AddEdge(idPrev, idLast); - meshDS->SetMeshElementOnShape(edge, E); + meshDS->SetMeshElementOnShape(edge, shapeID); } else { @@ -452,18 +592,14 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh { double param = f + (i - 1) * du; SMDS_MeshNode * node = meshDS->AddNode(P.X(), P.Y(), P.Z()); - meshDS->SetNodeOnEdge(node, E); - - SMDS_EdgePosition* epos = - dynamic_cast(node->GetPosition().get()); - epos->SetUParameter(param); + meshDS->SetNodeOnEdge(node, shapeID, param); SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, node); - meshDS->SetMeshElementOnShape(edge, E); + meshDS->SetMeshElementOnShape(edge, shapeID); idPrev = node; } SMDS_MeshEdge * edge = meshDS->AddEdge(idPrev, idLast); - meshDS->SetMeshElementOnShape(edge, E); + meshDS->SetMeshElementOnShape(edge, shapeID); } return true; } @@ -480,15 +616,17 @@ const list & StdMeshers_Regular_1D::GetUsedHypothes _usedHypList.clear(); _usedHypList = GetAppliedHypothesis(aMesh, aShape); // copy int nbHyp = _usedHypList.size(); + _mainEdge.Nullify(); if (nbHyp == 0) { // Check, if propagated from some other edge - TopoDS_Shape aMainEdge; if (aShape.ShapeType() == TopAbs_EDGE && - aMesh.IsPropagatedHypothesis(aShape, aMainEdge)) + aMesh.IsPropagatedHypothesis(aShape, _mainEdge)) { // Propagation of 1D hypothesis from on this edge - _usedHypList = GetAppliedHypothesis(aMesh, aMainEdge); // copy + //_usedHypList = GetAppliedHypothesis(aMesh, _mainEdge); // copy + // use a general method in order not to nullify _mainEdge + _usedHypList = SMESH_Algo::GetUsedHypothesis(aMesh, _mainEdge); // copy nbHyp = _usedHypList.size(); } }