src/StdMeshers/StdMeshers_Distribution.cxx

   1 //  SMESH StdMeshers : implementaion of point distribution algorithm
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : StdMeshers_Distribution.cxx
  25 //  Author : Alexandre SOLOVYOV
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "StdMeshers_Distribution.hxx"
  30 #include "CASCatch.hxx"
  31
  32 #include <math_GaussSingleIntegration.hxx>
  33 #include <utilities.h>
  34
  35 Function::Function( const int conv )
  36 : myConv( conv )
  37 {
  38 }
  39
  40 Function::~Function()
  41 {
  42 }
  43
  44 bool Function::value( const double, double& f ) const
  45 {
  46   bool ok = true;
  47   if( myConv==0 )
  48   {
  49     CASCatch_TRY
  50     {
  51       f = pow( 10, f );
  52     }
  53     CASCatch_CATCH(Standard_Failure)
  54     {
  55       Handle(Standard_Failure) aFail = Standard_Failure::Caught();
  56       f = 0.0;
  57       ok = false;
  58     }
  59   }
  60   else if( myConv==1 && f<0.0 )
  61     f = 0.0;
  62
  63   return ok;
  64 }
  65
  66 FunctionIntegral::FunctionIntegral( const Function* f, const double st )
  67 : Function( -1 ),
  68   myFunc( const_cast<Function*>( f ) ),
  69   myStart( st )
  70 {
  71 }
  72
  73 FunctionIntegral::~FunctionIntegral()
  74 {
  75 }
  76
  77 bool FunctionIntegral::value( const double t, double& f ) const
  78 {
  79   f = myFunc ? myFunc->integral( myStart, t ) : 0;
  80   return myFunc!=0 && Function::value( t, f );
  81 }
  82
  83 double FunctionIntegral::integral( const double, const double ) const
  84 {
  85   return 0;
  86 }
  87
  88 FunctionTable::FunctionTable( const std::vector<double>& data, const int conv )
  89 : Function( conv )
  90 {
  91   myData = data;
  92 }
  93
  94 FunctionTable::~FunctionTable()
  95 {
  96 }
  97
  98 bool FunctionTable::value( const double t, double& f ) const
  99 {
 100   int i1, i2;
 101   if( !findBounds( t, i1, i2 ) )
 102     return false;
 103
 104   double
 105     x1 = myData[2*i1], y1 = myData[2*i1+1],
 106     x2 = myData[2*i2], y2 = myData[2*i2+1];
 107
 108   Function::value( x1, y1 );
 109   Function::value( x2, y2 );
 110
 111   f = y1 + ( y2-y1 ) * ( t-x1 ) / ( x2-x1 );
 112   return true;
 113 }
 114
 115 double FunctionTable::integral( const int i ) const
 116 {
 117   if( i>=0 && i<myData.size()-1 )
 118     return integral( i, myData[2*(i+1)]-myData[2*i] );
 119   else
 120     return 0;
 121 }
 122
 123 double FunctionTable::integral( const int i, const double d ) const
 124 {
 125   double f1,f2, res = 0.0;
 126   if( value( myData[2*i]+d, f1 ) )
 127     if(!value(myData[2*i], f2))
 128       f2 = myData[2*i+1];
 129   res = (f2+f1) * d / 2.0;
 130   return res;
 131 }
 132
 133 double FunctionTable::integral( const double a, const double b ) const
 134 {
 135   int x1s, x1f, x2s, x2f;
 136   findBounds( a, x1s, x1f );
 137   findBounds( b, x2s, x2f );
 138   double J = 0;
 139   for( int i=x1s; i<x2s; i++ )
 140     J+=integral( i );
 141   J-=integral( x1s, a-myData[2*x1s] );
 142   J+=integral( x2s, b-myData[2*x2s] );
 143   return J;
 144 }
 145
 146 bool FunctionTable::findBounds( const double x, int& x_ind_1, int& x_ind_2 ) const
 147 {
 148   int n = myData.size() / 2;
 149   if( n==0 || x<myData[0] )
 150   {
 151     x_ind_1 = x_ind_2 = 0;
 152     return false;
 153   }
 154
 155   for( int i=0; i<n-1; i++ )
 156     if( myData[2*i]<=x && x<=myData[2*(i+1)] )
 157     {
 158       x_ind_1 = i;
 159       x_ind_2 = i+1;
 160       return true;
 161     }
 162   x_ind_1 = n-1;
 163   x_ind_2 = n-1;
 164   return false;
 165 }
 166
 167 FunctionExpr::FunctionExpr( const char* str, const int conv )
 168 : Function( conv ),
 169   myVars( 1, 1 ),
 170   myValues( 1, 1 )
 171 {
 172   bool ok = true;
 173   CASCatch_TRY
 174   {
 175     myExpr = ExprIntrp_GenExp::Create();
 176     myExpr->Process( ( Standard_CString )str );
 177   }
 178   CASCatch_CATCH(Standard_Failure)
 179   {
 180     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 181     ok = false;
 182   }
 183
 184   if( !ok || !myExpr->IsDone() )
 185     myExpr.Nullify();
 186
 187   myVars.ChangeValue( 1 ) = new Expr_NamedUnknown( "t" );
 188 }
 189
 190 FunctionExpr::~FunctionExpr()
 191 {
 192 }
 193
 194 Standard_Boolean FunctionExpr::Value( Standard_Real T, Standard_Real& F )
 195 {
 196   double f;
 197   Standard_Boolean res = value( T, f );
 198   F = f;
 199   return res;
 200 }
 201
 202 bool FunctionExpr::value( const double t, double& f ) const
 203 {
 204   if( myExpr.IsNull() )
 205     return false;
 206
 207   ( ( TColStd_Array1OfReal& )myValues ).ChangeValue( 1 ) = t;
 208   bool ok = true;
 209   CASCatch_TRY {
 210     f = myExpr->Expression()->Evaluate( myVars, myValues );
 211   }
 212   CASCatch_CATCH(Standard_Failure) {
 213     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 214     f = 0.0;
 215     ok = false;
 216   }
 217
 218   ok = Function::value( t, f ) && ok;
 219   return ok;
 220 }
 221
 222 double FunctionExpr::integral( const double a, const double b ) const
 223 {
 224   double res = 0.0;
 225   CASCatch_TRY {
 226     // skl for IPAL13079 (bug on Mandriva) - other cast
 227     //math_GaussSingleIntegration _int( ( math_Function& )*this, a, b, 20 );
 228     math_GaussSingleIntegration _int( *static_cast<math_Function*>( const_cast<FunctionExpr*> (this) ), a, b, 20 );
 229     if( _int.IsDone() )
 230       res = _int.Value();
 231   }
 232   CASCatch_CATCH(Standard_Failure)
 233   {
 234     res = 0.0;
 235     MESSAGE( "Exception in integral calculating" );
 236   }
 237   return res;
 238 }
 239
 240 double dihotomySolve( Function& f, const double val, const double _start, const double _fin, const double eps, bool& ok )
 241 {
 242   double start = _start, fin = _fin, start_val, fin_val; bool ok1, ok2;
 243   ok1 = f.value( start, start_val );
 244   ok2 = f.value( fin, fin_val );
 245
 246   if( !ok1 || !ok2 )
 247   {
 248     ok = false;
 249     return 0.0;
 250   }
 251
 252   bool start_pos = start_val>=val, fin_pos = fin_val>=val;
 253   ok = true;
 254
 255   while( fin-start>eps )
 256   {
 257     double mid = ( start+fin )/2.0, mid_val;
 258     ok = f.value( mid, mid_val );
 259     if( !ok )
 260       return 0.0;
 261
 262     //char buf[1024];
 263     //sprintf( buf, "start=%f\nfin=%f\nmid_val=%f\n", float( start ), float( fin ), float( mid_val ) );
 264     //MESSAGE( buf );
 265
 266     bool mid_pos = mid_val>=val;
 267     if( start_pos!=mid_pos )
 268     {
 269       fin_pos = mid_pos;
 270       fin = mid;
 271     }
 272     else if( fin_pos!=mid_pos )
 273     {
 274       start_pos = mid_pos;
 275       start = mid;
 276     }
 277     else
 278     {
 279       ok = false;
 280       break;
 281     }
 282   }
 283   return (start+fin)/2.0;
 284 }
 285
 286 bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end,
 287                         const int nbSeg, vector<double>& data, const double eps )
 288 {
 289   FunctionExpr F( f.ToCString(), conv );
 290   return buildDistribution( F, start, end, nbSeg, data, eps );
 291 }
 292
 293 bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end,
 294                         const int nbSeg, vector<double>& data, const double eps )
 295 {
 296   FunctionTable F( f, conv );
 297   return buildDistribution( F, start, end, nbSeg, data, eps );
 298 }
 299
 300 bool buildDistribution( const Function& func, const double start, const double end, const int nbSeg,
 301                         vector<double>& data, const double eps )
 302 {
 303   if( nbSeg<=0 )
 304     return false;
 305
 306   data.resize( nbSeg+1 );
 307   data[0] = start;
 308   double J = func.integral( start, end ) / nbSeg;
 309   if( J<1E-10 )
 310     return false;
 311
 312   bool ok;
 313   //MESSAGE( "distribution:" );
 314   //char buf[1024];
 315   for( int i=1; i<nbSeg; i++ )
 316   {
 317     FunctionIntegral f_int( &func, data[i-1] );
 318     data[i] = dihotomySolve( f_int, J, data[i-1], end, eps, ok );
 319     //sprintf( buf, "%f\n", float( data[i] ) );
 320     //MESSAGE( buf );
 321     if( !ok )
 322       return false;
 323   }
 324
 325   data[nbSeg] = end;
 326   return true;
 327 }