X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FStdMeshers%2FStdMeshers_Regular_1D.cxx;h=a24abbb98acc4093f57b2dbedb4950b11815224f;hb=15549165c3faa2be13dfb2df8676b2bad9e9b64c;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..a24abbb98 100644 --- a/src/StdMeshers/StdMeshers_Regular_1D.cxx +++ b/src/StdMeshers/StdMeshers_Regular_1D.cxx @@ -44,6 +44,7 @@ using namespace std; #include "SMDS_EdgePosition.hxx" #include "SMESH_subMesh.hxx" +#include "Utils_SALOME_Exception.hxx" #include "utilities.h" #include @@ -56,9 +57,14 @@ using namespace std; #include #include #include +#include +#include +#include +#include +#include #include -//#include +#include //============================================================================= /*! @@ -131,9 +137,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[ EXP_MODE_IND ] = (int) hyp->IsExponentMode(); _hypType = NB_SEGMENTS; aStatus = SMESH_Hypothesis::HYP_OK; } @@ -178,13 +204,316 @@ bool StdMeshers_Regular_1D::CheckHypothesis 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; + } + } +} + +/*! + * \brief This class provides interface for a density function + */ +class Function +{ +public: + Function(bool expMode) : _expMode(expMode) {} + double operator() (double t) const; + virtual bool IsReady() const = 0; +protected: + virtual double compute(double t) const = 0; +private: + bool _expMode; +}; + +/*! + * \brief This class provides computation of density function given by a table + */ +class TabFunction: public Function +{ +public: + TabFunction(const vector& table, bool expMode); + virtual bool IsReady() const; +protected: + virtual double compute(double t) const; +private: + const vector& _table; +}; + +/*! + * \brief This class provides computation of density function given by an expression + */ +class ExprFunction: public Function +{ +public: + ExprFunction(const char* expr, bool expMode); + virtual bool IsReady() const; +protected: + virtual double compute(double t) const; +private: + Handle(Expr_GeneralExpression) _expression; + Expr_Array1OfNamedUnknown _var; + mutable TColStd_Array1OfReal _val; +}; + +double Function::operator() (double t) const +{ + double res = compute(t); + if (_expMode) + res = pow(10, res); + return res; +} + +TabFunction::TabFunction(const vector& table, bool expMode) + : Function(expMode), + _table(table) +{ +} + +bool TabFunction::IsReady() const +{ + return true; +} + +double TabFunction::compute (double t) const +{ + //find place of in table + int i; + for (i=0; i < _table.size()/2; i++) + if (_table[i*2] > t) + break; + if (i >= _table.size()/2) + i = _table.size()/2 - 1; + + if (i == 0) + return _table[1]; + + // interpolate function value on found interval + // (t - x[i-1]) / (x[i] - x[i-1]) = (y - f[i-1]) / (f[i] - f[i-1]) + // => y = f[i-1] + (f[i] - f[i-1]) * (t - x[i-1]) / (x[i] - x[i-1]) + double x1 = _table[(i-1)*2]; + double x2 = _table[i*2]; + double y1 = _table[(i-1)*2+1]; + double y2 = _table[i*2+1]; + if (x2 - x1 < Precision::Confusion()) + throw SALOME_Exception("TabFunction::compute : confused points"); + return y1 + (y2 - y1) * ((t - x1) / (x2 - x1)); +} + +ExprFunction::ExprFunction(const char* expr, bool expMode) + : Function(expMode), + _var(1,1), + _val(1,1) +{ + Handle( ExprIntrp_GenExp ) gen = ExprIntrp_GenExp::Create(); + gen->Process(TCollection_AsciiString((char*)expr)); + if (gen->IsDone()) + { + _expression = gen->Expression(); + _var(1) = new Expr_NamedUnknown("t"); + } +} + +bool ExprFunction::IsReady() const +{ + return !_expression.IsNull(); +} + +double ExprFunction::compute (double t) const +{ + ASSERT(!_expression.IsNull()); + _val(1) = t; + return _expression->Evaluate(_var, _val); +} + +//================================================================================ +/*! + * \brief Compute next abscissa when two previous ones are given + * \param sm2 - before previous abscissa + * \param sm1 - previous abscissa + * \param func - function of density + * \param reverse - the direction of next abscissa, increase (0) or decrease (1) + * \retval double - the new abscissa + * + * The abscissa s is given by the formulae + * + * ....|--------|----------------|..... + * sm2 sm1 s + * + * func(sm2) / func(sm1) = (sm1-sm2) / (s-sm1) + * => (s-sm1) * func(sm2) = (sm1-sm2) * func(sm1) + * => s = sm1 + (sm1-sm2) * func(sm1) / func(sm2) + */ +//================================================================================ + +static double nextAbscissa(double sm2, double sm1, const Function& func, int reverse) +{ + if (reverse) + { + sm1 = 1.0 - sm1; + sm2 = 1.0 - sm2; + } + return sm1 + (sm1-sm2) * func(sm1) / func(sm2); +} + +//================================================================================ +/*! + * \brief Compute distribution of points on a curve following the law of a function + * \param C3d - the curve to discretize + * \param first - the first parameter on the curve + * \param last - the last parameter on the curve + * \param theReverse - flag indicating that the curve must be reversed + * \param nbSeg - number of output segments + * \param func - the function f(t) + * \param theParams - output points + * \retval bool - true if success + */ +//================================================================================ + +static bool computeParamByFunc(Adaptor3d_Curve& C3d, double first, double last, + double length, bool theReverse, + int nbSeg, const Function& func, + list& theParams) +{ + if (!func.IsReady()) + return false; + vector xxx[2]; + int nbPnt = 1 + nbSeg; + int rev, i; + for (rev=0; rev < 2; rev++) + { + // curv abscisses initialisation + vector x(nbPnt, 0.); + // the first abscissa is 0.0 + + // The aim of the algorithm is to find a second abscisse x[1] such as the last + // one x[nbSeg] is very close to 1.0 with the epsilon precision + + double x1_too_small = 0.0; + double x1_too_large = RealLast(); + double x1 = 1.0/nbSeg; + while (1) + { + x[1] = x1; + + // Check if the abscissa of the point 2 to N-1 + // are in the segment ... + + bool ok = true; + for (i=2; i <= nbSeg; i++) + { + x[i] = nextAbscissa(x[i-2], x[i-1], func, rev); + if (x[i] - 1.0 > Precision::Confusion()) + { + x[nbSeg] = x[i]; + ok = false; + break; + } + } + if (!ok) + { + // The segments are to large + // Decrease x1 ... + x1_too_large = x1; + x1 = (x1_too_small+x1_too_large)/2; + continue; + } + + // Look at the abscissa of the point N + // which is to be close to 1.0 + + // break condition --> algo converged !! + + if (1.0 - x[nbSeg] < Precision::Confusion()) + break; + + // not ok ... + + x1_too_small = x1; + + // Modify x1 value + + if (x1_too_large > 1e100) + x1 = 2*x1; + else + x1 = (x1_too_small+x1_too_large)/2; + } + xxx[rev] = x; + } + + // average + vector x(nbPnt, 0.); + for (i=0; i < nbPnt; i++) + x[i] = (xxx[0][i] + (1.0 - xxx[1][nbPnt-i])) / 2; + + // 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 (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 false; +} + //============================================================================= /*! * */ //============================================================================= bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge, - list & theParams) const + list & theParams, + const bool theReverse) const { theParams.clear(); @@ -193,7 +522,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(const TopoDS_Edge& theEdge GeomAdaptor_Curve C3d(Curve); double length = EdgeLength(theEdge); - //SCRUTE(length); switch( _hypType ) { @@ -203,6 +531,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 +539,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: + { + TabFunction func(_vvalue[ TAB_FUNC_IND ], (bool)_ivalue[ EXP_MODE_IND ]); + return computeParamByFunc(C3d, f, l, length, theReverse, + _ivalue[ NB_SEGMENTS_IND ], func, + theParams); + } + break; + case StdMeshers_NumberOfSegments::DT_ExprFunc: + { + ExprFunction func(_svalue[ EXPR_FUNC_IND ].c_str(), (bool)_ivalue[ EXP_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; } } @@ -253,102 +604,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; - } - } - - 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 ); - } + compensateError( a1, an, U1, Un, length, C3d, theParams ); 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:; } @@ -373,6 +699,7 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & aMesh, const TopoDS_Shape & aSh 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 +728,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 +751,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 +777,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 +801,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(); } }