]> SALOME platform Git repositories - modules/smesh.git/blob - src/StdMeshers/StdMeshers_Distribution.cxx
Salome HOME
Update test for new version of PartitionAlgo.
[modules/smesh.git] / 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
31 #include <math_GaussSingleIntegration.hxx>
32 #include <utilities.h>
33
34 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
35 #define NO_CAS_CATCH
36 #endif
37
38 #include <Standard_Failure.hxx>
39
40 #ifdef NO_CAS_CATCH
41 #include <Standard_ErrorHandler.hxx>
42 #else
43 #include "CASCatch.hxx"
44 #endif
45
46 Function::Function( const int conv )
47 : myConv( conv )
48 {
49 }
50
51 Function::~Function()
52 {
53 }
54
55 bool Function::value( const double, double& f ) const
56 {
57   bool ok = true;
58   if (myConv == 0) {
59 #ifdef NO_CAS_CATCH
60     try {
61       OCC_CATCH_SIGNALS;
62 #else
63     CASCatch_TRY {
64 #endif
65       f = pow( 10, f );
66 #ifdef NO_CAS_CATCH
67     } catch(Standard_Failure) {
68 #else
69     } CASCatch_CATCH(Standard_Failure) {
70 #endif
71       Handle(Standard_Failure) aFail = Standard_Failure::Caught();
72       f = 0.0;
73       ok = false;
74     }
75   }
76   else if( myConv==1 && f<0.0 )
77     f = 0.0;
78
79   return ok;
80 }
81
82 FunctionIntegral::FunctionIntegral( const Function* f, const double st )
83 : Function( -1 ),
84   myFunc( const_cast<Function*>( f ) ),
85   myStart( st )
86 {
87 }
88
89 FunctionIntegral::~FunctionIntegral()
90 {
91 }
92
93 bool FunctionIntegral::value( const double t, double& f ) const
94 {
95   f = myFunc ? myFunc->integral( myStart, t ) : 0;
96   return myFunc!=0 && Function::value( t, f );
97 }
98
99 double FunctionIntegral::integral( const double, const double ) const
100 {
101   return 0;
102 }
103
104 FunctionTable::FunctionTable( const std::vector<double>& data, const int conv )
105 : Function( conv )
106 {
107   myData = data;
108 }
109
110 FunctionTable::~FunctionTable()
111 {
112 }
113
114 bool FunctionTable::value( const double t, double& f ) const
115 {
116   int i1, i2;
117   if( !findBounds( t, i1, i2 ) )
118     return false;
119
120   double
121     x1 = myData[2*i1], y1 = myData[2*i1+1],
122     x2 = myData[2*i2], y2 = myData[2*i2+1];
123
124   Function::value( x1, y1 );
125   Function::value( x2, y2 );
126   
127   f = y1 + ( y2-y1 ) * ( t-x1 ) / ( x2-x1 );
128   return true;
129 }
130
131 double FunctionTable::integral( const int i ) const
132 {
133   if( i>=0 && i<myData.size()-1 )
134     return integral( i, myData[2*(i+1)]-myData[2*i] );
135   else
136     return 0;
137 }
138
139 double FunctionTable::integral( const int i, const double d ) const
140 {
141   double f1,f2, res = 0.0;
142   if( value( myData[2*i]+d, f1 ) )
143     if(!value(myData[2*i], f2))
144       f2 = myData[2*i+1];
145   res = (f2+f1) * d / 2.0;
146   return res;
147 }
148
149 double FunctionTable::integral( const double a, const double b ) const
150 {
151   int x1s, x1f, x2s, x2f;
152   findBounds( a, x1s, x1f );
153   findBounds( b, x2s, x2f );
154   double J = 0;
155   for( int i=x1s; i<x2s; i++ )
156     J+=integral( i );
157   J-=integral( x1s, a-myData[2*x1s] );
158   J+=integral( x2s, b-myData[2*x2s] );
159   return J;
160 }
161
162 bool FunctionTable::findBounds( const double x, int& x_ind_1, int& x_ind_2 ) const
163 {
164   int n = myData.size() / 2;
165   if( n==0 || x<myData[0] )
166   {
167     x_ind_1 = x_ind_2 = 0;
168     return false;
169   }
170
171   for( int i=0; i<n-1; i++ )
172     if( myData[2*i]<=x && x<=myData[2*(i+1)] )
173     {
174       x_ind_1 = i;
175       x_ind_2 = i+1;
176       return true;
177     }
178   x_ind_1 = n-1;
179   x_ind_2 = n-1;
180   return false;
181 }
182
183 FunctionExpr::FunctionExpr( const char* str, const int conv )
184 : Function( conv ),
185   myVars( 1, 1 ),
186   myValues( 1, 1 )
187 {
188   bool ok = true;
189 #ifdef NO_CAS_CATCH
190   try {
191     OCC_CATCH_SIGNALS;
192 #else
193   CASCatch_TRY {
194 #endif
195     myExpr = ExprIntrp_GenExp::Create();
196     myExpr->Process( ( Standard_CString )str );
197 #ifdef NO_CAS_CATCH
198   } catch(Standard_Failure) {
199 #else
200   } CASCatch_CATCH(Standard_Failure) {
201 #endif
202     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
203     ok = false;
204   }
205
206   if( !ok || !myExpr->IsDone() )
207     myExpr.Nullify();
208
209   myVars.ChangeValue( 1 ) = new Expr_NamedUnknown( "t" );
210 }
211
212 FunctionExpr::~FunctionExpr()
213 {
214 }
215
216 Standard_Boolean FunctionExpr::Value( Standard_Real T, Standard_Real& F )
217 {
218   double f;
219   Standard_Boolean res = value( T, f );
220   F = f;
221   return res;
222 }
223
224 bool FunctionExpr::value( const double t, double& f ) const
225 {
226   if( myExpr.IsNull() )
227     return false;
228
229   ( ( TColStd_Array1OfReal& )myValues ).ChangeValue( 1 ) = t;
230   bool ok = true;
231 #ifdef NO_CAS_CATCH
232   try {
233     OCC_CATCH_SIGNALS;
234 #else
235   CASCatch_TRY {
236 #endif
237     f = myExpr->Expression()->Evaluate( myVars, myValues );
238 #ifdef NO_CAS_CATCH
239   } catch(Standard_Failure) {
240 #else
241   } CASCatch_CATCH(Standard_Failure) {
242 #endif
243     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
244     f = 0.0;
245     ok = false;
246   }
247
248   ok = Function::value( t, f ) && ok;
249   return ok;
250 }
251
252 double FunctionExpr::integral( const double a, const double b ) const
253 {
254   double res = 0.0;
255 #ifdef NO_CAS_CATCH
256   try {
257     OCC_CATCH_SIGNALS;
258 #else
259   CASCatch_TRY {
260 #endif
261     math_GaussSingleIntegration _int
262       ( *static_cast<math_Function*>( const_cast<FunctionExpr*> (this) ), a, b, 20 );
263     if( _int.IsDone() )
264       res = _int.Value();
265 #ifdef NO_CAS_CATCH
266   } catch(Standard_Failure) {
267 #else
268   } CASCatch_CATCH(Standard_Failure) {
269 #endif
270     res = 0.0;
271     MESSAGE( "Exception in integral calculating" );
272   }
273   return res;
274 }
275
276 double dihotomySolve( Function& f, const double val, const double _start, const double _fin, const double eps, bool& ok )
277 {
278   double start = _start, fin = _fin, start_val, fin_val; bool ok1, ok2;
279   ok1 = f.value( start, start_val );
280   ok2 = f.value( fin, fin_val );
281
282   if( !ok1 || !ok2 )
283   {
284     ok = false;
285     return 0.0;
286   }
287
288   bool start_pos = start_val>=val, fin_pos = fin_val>=val;
289   ok = true;
290   
291   while( fin-start>eps )
292   {
293     double mid = ( start+fin )/2.0, mid_val;
294     ok = f.value( mid, mid_val );
295     if( !ok )
296       return 0.0;
297
298     //char buf[1024];
299     //sprintf( buf, "start=%f\nfin=%f\nmid_val=%f\n", float( start ), float( fin ), float( mid_val ) );
300     //MESSAGE( buf );
301
302     bool mid_pos = mid_val>=val;
303     if( start_pos!=mid_pos )
304     {
305       fin_pos = mid_pos;
306       fin = mid;
307     }
308     else if( fin_pos!=mid_pos )
309     {
310       start_pos = mid_pos;
311       start = mid;
312     }
313     else
314     {
315       ok = false;
316       break;
317     }
318   }
319   return (start+fin)/2.0;
320 }
321
322 bool buildDistribution( const TCollection_AsciiString& f, const int conv, const double start, const double end,
323                         const int nbSeg, vector<double>& data, const double eps )
324 {
325   FunctionExpr F( f.ToCString(), conv );
326   return buildDistribution( F, start, end, nbSeg, data, eps );
327 }
328
329 bool buildDistribution( const std::vector<double>& f, const int conv, const double start, const double end,
330                         const int nbSeg, vector<double>& data, const double eps )
331 {
332   FunctionTable F( f, conv );
333   return buildDistribution( F, start, end, nbSeg, data, eps );
334 }
335
336 bool buildDistribution( const Function& func, const double start, const double end, const int nbSeg,
337                         vector<double>& data, const double eps )
338 {
339   if( nbSeg<=0 )
340     return false;
341
342   data.resize( nbSeg+1 );
343   data[0] = start;
344   double J = func.integral( start, end ) / nbSeg;
345   if( J<1E-10 )
346     return false;
347
348   bool ok;
349   //MESSAGE( "distribution:" );
350   //char buf[1024];
351   for( int i=1; i<nbSeg; i++ )
352   {
353     FunctionIntegral f_int( &func, data[i-1] );
354     data[i] = dihotomySolve( f_int, J, data[i-1], end, eps, ok );
355     //sprintf( buf, "%f\n", float( data[i] ) );
356     //MESSAGE( buf );
357     if( !ok )
358       return false;
359   }
360
361   data[nbSeg] = end;
362   return true;
363 }