]> SALOME platform Git repositories - modules/smesh.git/blob - src/StdMeshers/StdMeshers_NumberOfSegments.cxx
Salome HOME
Protection for the case of python command wrapped over several lines
[modules/smesh.git] / src / StdMeshers / StdMeshers_NumberOfSegments.cxx
1 // Copyright (C) 2007-2020  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  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, or (at your option) any later version.
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 //  SMESH SMESH : implementation of SMESH idl descriptions
24 //  File   : StdMeshers_NumberOfSegments.cxx
25 //           Moved here from SMESH_NumberOfSegments.cxx
26 //  Author : Paul RASCLE, EDF
27 //  Module : SMESH
28 //
29 #include "StdMeshers_NumberOfSegments.hxx"
30
31 #include "SMESHDS_Mesh.hxx"
32 #include "SMESHDS_SubMesh.hxx"
33 #include "SMESH_Comment.hxx"
34 #include "SMESH_Mesh.hxx"
35 #include "StdMeshers_Distribution.hxx"
36
37 #include <ExprIntrp_GenExp.hxx>
38 #include <Expr_Array1OfNamedUnknown.hxx>
39 #include <Expr_NamedUnknown.hxx>
40 #include <TColStd_Array1OfReal.hxx>
41 #include <TCollection_AsciiString.hxx>
42 #include <TopExp.hxx>
43 #include <TopTools_IndexedMapOfShape.hxx>
44
45 #include <Standard_Failure.hxx>
46 #include <Standard_ErrorHandler.hxx>
47
48 #include <Basics_Utils.hxx>
49
50 using namespace StdMeshers;
51 using namespace std;
52
53 const double PRECISION = 1e-7;
54
55 //=============================================================================
56 /*!
57  *  
58  */
59 //=============================================================================
60
61 StdMeshers_NumberOfSegments::StdMeshers_NumberOfSegments(int         hypId,
62                                                          SMESH_Gen * gen)
63   : StdMeshers_Reversible1D(hypId, gen),
64     _numberOfSegments(15),//issue 19923
65     _distrType(DT_Regular),
66     _scaleFactor(1.),
67     _convMode(1)  //cut negative by default
68 {
69   _name = "NumberOfSegments";
70   _param_algo_dim = 1;
71 }
72
73 //=============================================================================
74 /*!
75  *  
76  */
77 //=============================================================================
78
79 StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
80 {
81 }
82
83 //=============================================================================
84 /*!
85  *  
86  */
87 //=============================================================================
88 const vector<double>&
89 StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
90   throw ( SALOME_Exception )
91 {
92   if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
93     _distr.resize( 0 );
94   return _distr;
95 }
96
97 const vector<double>&
98 StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
99                                                    int nbSeg,
100                                                    int conv )
101   throw ( SALOME_Exception )
102 {
103   if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
104     _distr.resize( 0 );
105   return _distr;
106 }
107
108 //=============================================================================
109 /*!
110  *  
111  */
112 //=============================================================================
113
114 void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
115 throw(SALOME_Exception)
116 {
117   int oldNumberOfSegments = _numberOfSegments;
118   if (segmentsNumber <= 0)
119     throw SALOME_Exception(LOCALIZED("number of segments must be positive"));
120   _numberOfSegments = segmentsNumber;
121
122   if (oldNumberOfSegments != _numberOfSegments)
123     NotifySubMeshesHypothesisModification();
124 }
125
126 //=============================================================================
127 /*!
128  *  
129  */
130 //=============================================================================
131
132 int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
133 {
134   return _numberOfSegments;
135 }
136
137 //================================================================================
138 /*!
139  * 
140  */
141 //================================================================================
142
143 void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
144   throw(SALOME_Exception)
145 {
146   if (typ < DT_Regular || typ > DT_ExprFunc)
147     throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
148
149   if (typ != _distrType)
150   {
151     _distrType = typ;
152     NotifySubMeshesHypothesisModification();
153   }
154 }
155
156 //================================================================================
157 /*!
158  * 
159  */
160 //================================================================================
161
162 StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType() const
163 {
164   return _distrType;
165 }
166
167 //================================================================================
168 /*!
169  * 
170  */
171 //================================================================================
172
173 void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
174   throw(SALOME_Exception)
175 {
176   if (scaleFactor < PRECISION)
177     throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
178
179   if (_distrType != DT_Scale)
180     _distrType = DT_Scale;
181
182 //  commented by mpa for IPAL 52986
183 //  if ( fabs(scaleFactor - 1.0) < PRECISION )
184 //    _distrType = DT_Regular;
185
186   if ( fabs(_scaleFactor - scaleFactor) > PRECISION )
187   {
188     _scaleFactor = scaleFactor;
189     NotifySubMeshesHypothesisModification();
190   }
191 }
192
193 //================================================================================
194 /*!
195  *
196  */
197 //================================================================================
198
199 double StdMeshers_NumberOfSegments::GetScaleFactor() const
200   throw(SALOME_Exception)
201 {
202   if (_distrType != DT_Scale)
203     throw SALOME_Exception(LOCALIZED("not a scale distribution"));
204   return _scaleFactor;
205 }
206
207 //================================================================================
208 /*!
209  *
210  */
211 //================================================================================
212
213 void StdMeshers_NumberOfSegments::SetTableFunction(const vector<double>& table)
214   throw(SALOME_Exception)
215 {
216   if (_distrType != DT_TabFunc)
217     _distrType = DT_TabFunc;
218   //throw SALOME_Exception(LOCALIZED("not a table function distribution"));
219   if ( (table.size() % 2) != 0 )
220     throw SALOME_Exception(LOCALIZED("odd size of vector of table function"));
221
222   double prev = -PRECISION;
223   bool isSame = table.size() == _table.size();
224
225   bool pos = false;
226   for ( size_t i = 0; i < table.size() / 2; i++ )
227   {
228     double par = table[i*2];
229     double val = table[i*2+1];
230     if( _convMode==0 )
231     {
232       try {
233         OCC_CATCH_SIGNALS;
234         val = pow( 10.0, val );
235       }
236       catch(Standard_Failure) {
237         throw SALOME_Exception( LOCALIZED( "invalid value"));
238         return;
239       }
240     }
241     else if( _convMode==1 && val<0.0 )
242       val = 0.0;
243
244     if ( par < 0 || par > 1)
245       throw SALOME_Exception(LOCALIZED("parameter of table function is out of range [0,1]"));
246     if ( fabs(par-prev) < PRECISION )
247       throw SALOME_Exception(LOCALIZED("two parameters are the same"));
248     if ( val < 0 )
249       throw SALOME_Exception(LOCALIZED("value of table function is not positive"));
250     if( val > PRECISION )
251       pos = true;
252     if (isSame)
253     {
254       double oldpar = _table[i*2];
255       double oldval = _table[i*2+1];
256       if ( fabs(par - oldpar) > PRECISION || fabs(val - oldval) > PRECISION )
257         isSame = false;
258     }
259     prev = par;
260   }
261
262   if( !pos )
263     throw SALOME_Exception(LOCALIZED("value of table function is not positive"));
264
265   if ( pos && !isSame )
266   {
267     _table = table;
268     NotifySubMeshesHypothesisModification();
269   }
270 }
271
272 //================================================================================
273 /*!
274  *
275  */
276 //================================================================================
277
278 const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
279   throw(SALOME_Exception)
280 {
281   if (_distrType != DT_TabFunc)
282     throw SALOME_Exception(LOCALIZED("not a table function distribution"));
283   return _table;
284 }
285
286 //================================================================================
287 /*! check if only 't' is unknown variable in expression
288  */
289 //================================================================================
290 bool isCorrectArg( const Handle( Expr_GeneralExpression )& expr )
291 {
292   Handle( Expr_NamedUnknown ) sub = Handle( Expr_NamedUnknown )::DownCast( expr );
293   if( !sub.IsNull() )
294     return sub->GetName()=="t";
295
296   bool res = true;
297   for( int i=1, n=expr->NbSubExpressions(); i<=n && res; i++ )
298   {
299     Handle( Expr_GeneralExpression ) sub = expr->SubExpression( i );
300     Handle( Expr_NamedUnknown ) name = Handle( Expr_NamedUnknown )::DownCast( sub );
301     if( !name.IsNull() )
302     {
303       if( name->GetName()!="t" )
304         res = false;
305     }
306     else
307       res = isCorrectArg( sub );
308   }
309   return res;
310 }
311
312 //================================================================================
313 /*! this function parses the expression 'str' in order to check if syntax is correct
314  *  ( result in 'syntax' ) and if only 't' is unknown variable in expression ( result in 'args' )
315  */
316 //================================================================================
317 bool process( const TCollection_AsciiString& str, int convMode,
318               bool& syntax, bool& args,
319               bool& non_neg, bool& non_zero,
320               bool& singulars, double& sing_point )
321 {
322   Kernel_Utils::Localizer loc;
323
324   bool parsed_ok = true;
325   Handle( ExprIntrp_GenExp ) myExpr;
326   try {
327     OCC_CATCH_SIGNALS;
328     myExpr = ExprIntrp_GenExp::Create();
329     myExpr->Process( str.ToCString() );
330   } catch(Standard_Failure) {
331     parsed_ok = false;
332   }
333
334   syntax = false;
335   args = false;
336   if( parsed_ok && myExpr->IsDone() )
337   {
338     syntax = true;
339     args = isCorrectArg( myExpr->Expression() );
340   }
341
342   bool res = parsed_ok && syntax && args;
343   if( !res )
344     myExpr.Nullify();
345
346   non_neg = true;
347   singulars = false;
348   non_zero = false;
349
350   if( res )
351   {
352     FunctionExpr f( str.ToCString(), convMode );
353     const int max = 500;
354     for( int i=0; i<=max; i++ )
355     {
356       double t = double(i)/double(max), val;
357       if( !f.value( t, val ) )
358       {
359         sing_point = t;
360         singulars = true;
361         break;
362       }
363       if( val<0 )
364       {
365         non_neg = false;
366         break;
367       }
368       if( val>PRECISION )
369         non_zero = true;
370     }
371   }
372
373   return res && non_neg && non_zero && ( !singulars );
374 }
375
376 //================================================================================
377 /*!
378  * 
379  */
380 //================================================================================
381
382 void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
383   throw(SALOME_Exception)
384 {
385   if (_distrType != DT_ExprFunc)
386     _distrType = DT_ExprFunc;
387
388   string func = CheckExpressionFunction( expr, _convMode );
389   if( _func != func )
390   {
391     _func = func;
392     NotifySubMeshesHypothesisModification();
393   }
394 }
395
396 //=======================================================================
397 //function : CheckExpressionFunction
398 //purpose  : Checks validity of  the expression of the function f(t), e.g. "sin(t)".
399 //           In case of validity returns a cleaned expression
400 //=======================================================================
401
402 std::string
403 StdMeshers_NumberOfSegments::CheckExpressionFunction( const std::string& expr,
404                                                       const int          convMode)
405     throw (SALOME_Exception)
406 {
407   // remove white spaces
408   TCollection_AsciiString str((Standard_CString)expr.c_str());
409   str.RemoveAll(' ');
410   str.RemoveAll('\t');
411   str.RemoveAll('\r');
412   str.RemoveAll('\n');
413
414   bool syntax, args, non_neg, singulars, non_zero;
415   double sing_point;
416   bool res = process( str, convMode, syntax, args, non_neg, non_zero, singulars, sing_point );
417   if( !res )
418   {
419     if( !syntax )
420       throw SALOME_Exception(SMESH_Comment("invalid expression syntax: ") << str );
421     if( !args )
422       throw SALOME_Exception(LOCALIZED("only 't' may be used as function argument"));
423     if( !non_neg )
424       throw SALOME_Exception(LOCALIZED("only non-negative function can be used"));
425     if( singulars )
426     {
427       char buf[1024];
428       sprintf( buf, "Function has singular point in %.3f", sing_point );
429       throw SALOME_Exception( buf );
430     }
431     if( !non_zero )
432       throw SALOME_Exception(LOCALIZED("f(t)=0 cannot be used"));
433   }
434  
435   return str.ToCString();
436 }
437
438 //================================================================================
439 /*!
440  * 
441  */
442 //================================================================================
443
444 const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
445   throw(SALOME_Exception)
446 {
447   if (_distrType != DT_ExprFunc)
448     throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
449   return _func.c_str();
450 }
451
452 //================================================================================
453 /*!
454  * 
455  */
456 //================================================================================
457
458 void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
459   throw(SALOME_Exception)
460 {
461 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
462 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
463
464   if( conv != _convMode )
465   {
466     _convMode = conv;
467     NotifySubMeshesHypothesisModification();
468   }
469 }
470
471 //================================================================================
472 /*!
473  * 
474  */
475 //================================================================================
476
477 int StdMeshers_NumberOfSegments::ConversionMode() const
478   throw(SALOME_Exception)
479 {
480 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
481 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
482   return _convMode;
483 }
484
485 //=============================================================================
486 /*!
487  *  
488  */
489 //=============================================================================
490
491 ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
492 {
493   int listSize = _edgeIDs.size();
494   save << _numberOfSegments << " " << (int)_distrType;
495   switch (_distrType)
496   {
497   case DT_Scale:
498     save << " " << _scaleFactor;
499     break;
500   case DT_TabFunc:
501     save << " " << _table.size();
502     for ( size_t i = 0; i < _table.size(); i++ )
503       save << " " << _table[i];
504     break;
505   case DT_ExprFunc:
506     save << " " << _func;
507     break;
508   case DT_Regular:
509   default:
510     break;
511   }
512
513   if (_distrType == DT_TabFunc || _distrType == DT_ExprFunc)
514     save << " " << _convMode;
515
516   if ( _distrType != DT_Regular && listSize > 0 ) {
517     save << " " << listSize;
518     for ( int i = 0; i < listSize; i++ )
519       save << " " << _edgeIDs[i];
520     save << " " << _objEntry;
521   }
522   
523   return save;
524 }
525
526 //=============================================================================
527 /*!
528  *  
529  */
530 //=============================================================================
531
532 istream & StdMeshers_NumberOfSegments::LoadFrom(istream & load)
533 {
534   bool isOK = true;
535   int a;
536
537   // read number of segments
538   isOK = static_cast<bool>(load >> a);
539   if (isOK)
540     _numberOfSegments = a;
541   else
542     load.clear(ios::badbit | load.rdstate());
543
544   // read second stored value. It can be two variants here:
545   // 1. If the hypothesis is stored in old format (nb.segments and scale factor),
546   //    we wait here the scale factor, which is double.
547   // 2. If the hypothesis is stored in new format
548   //    (nb.segments, distr.type, some other params.),
549   //    we wait here the distribution type, which is integer
550   double scale_factor;
551   isOK = static_cast<bool>(load >> scale_factor);
552   a = (int)scale_factor;
553
554   // try to interpret distribution type,
555   // supposing that this hypothesis was written in the new format
556   if (isOK)
557   {
558     if (a < DT_Regular || a > DT_ExprFunc)
559       _distrType = DT_Regular;
560     else
561       _distrType = (DistrType) a;
562   }
563   else
564     load.clear(ios::badbit | load.rdstate());
565
566   // parameters of distribution
567   double b;
568   switch (_distrType)
569   {
570   case DT_Scale:
571     {
572       isOK = static_cast<bool>(load >> b);
573       if (isOK)
574         _scaleFactor = b;
575       else
576       {
577         load.clear(ios::badbit | load.rdstate());
578         // this can mean, that the hypothesis is stored in old format
579         _distrType = DT_Regular;
580         _scaleFactor = scale_factor;
581       }
582     }
583     break;
584   case DT_TabFunc:
585     {
586       isOK = static_cast<bool>(load >> a);
587       if (isOK)
588       {
589         _table.resize(a, 0.);
590         for ( size_t i=0; i < _table.size(); i++ )
591         {
592           isOK = static_cast<bool>(load >> b);
593           if (isOK)
594             _table[i] = b;
595           else
596             load.clear(ios::badbit | load.rdstate());
597         }
598       }
599       else
600       {
601         load.clear(ios::badbit | load.rdstate());
602         // this can mean, that the hypothesis is stored in old format
603         _distrType = DT_Regular;
604         _scaleFactor = scale_factor;
605       }
606     }
607     break;
608   case DT_ExprFunc:
609     {
610       string str;
611       isOK = static_cast<bool>(load >> str);
612       if (isOK)
613         _func = str;
614       else
615       {
616         load.clear(ios::badbit | load.rdstate());
617         // this can mean, that the hypothesis is stored in old format
618         _distrType = DT_Regular;
619         _scaleFactor = scale_factor;
620       }
621     }
622     break;
623   case DT_Regular:
624   default:
625     break;
626   }
627
628   if (_distrType == DT_TabFunc || _distrType == DT_ExprFunc)
629   {
630     isOK = static_cast<bool>(load >> a);
631     if (isOK)
632       _convMode = a;
633     else
634       load.clear(ios::badbit | load.rdstate());
635   }
636
637   // load reversed edges IDs
638   int intVal;
639   isOK = static_cast<bool>(load >> intVal);
640   if ( isOK && _distrType != DT_Regular && intVal > 0 ) {
641     _edgeIDs.reserve( intVal );
642     for ( size_t i = 0; i < _edgeIDs.capacity() && isOK; i++) {
643       isOK = static_cast<bool>(load >> intVal);
644       if ( isOK ) _edgeIDs.push_back( intVal );
645     }
646     isOK = static_cast<bool>(load >> _objEntry);
647   }
648
649   return load;
650 }
651
652 //=============================================================================
653 /*!
654  *
655  */
656 //=============================================================================
657
658 ostream & operator <<(ostream & save, StdMeshers_NumberOfSegments & hyp)
659 {
660   return hyp.SaveTo( save );
661 }
662
663 //=============================================================================
664 /*!
665  *  
666  */
667 //=============================================================================
668
669 istream & operator >>(istream & load, StdMeshers_NumberOfSegments & hyp)
670 {
671   return hyp.LoadFrom( load );
672 }
673
674 //================================================================================
675 /*!
676  * \brief Initialize number of segments by the mesh built on the geometry
677  * \param theMesh - the built mesh
678  * \param theShape - the geometry of interest
679  * \retval bool - true if parameter values have been successfully defined
680  */
681 //================================================================================
682
683 bool StdMeshers_NumberOfSegments::SetParametersByMesh(const SMESH_Mesh*   theMesh,
684                                                       const TopoDS_Shape& theShape)
685 {
686   if ( !theMesh || theShape.IsNull() )
687     return false;
688
689   _numberOfSegments = 0;
690   _distrType = DT_Regular;
691
692   int nbEdges = 0;
693   TopTools_IndexedMapOfShape edgeMap;
694   TopExp::MapShapes( theShape, TopAbs_EDGE, edgeMap );
695   SMESHDS_Mesh* aMeshDS = const_cast< SMESH_Mesh* >( theMesh )->GetMeshDS();
696   for ( int i = 1; i <= edgeMap.Extent(); ++i )
697   {
698     // get current segment length
699     SMESHDS_SubMesh * eSubMesh = aMeshDS->MeshElements( edgeMap( i ));
700     if ( eSubMesh && eSubMesh->NbElements())
701       _numberOfSegments += eSubMesh->NbElements();
702
703     ++nbEdges;
704   }
705   if ( nbEdges )
706     _numberOfSegments /= nbEdges;
707
708   if (_numberOfSegments == 0) _numberOfSegments = 1;
709
710   return nbEdges;
711 }
712 //================================================================================
713 /*!
714  * \brief Initialize my parameter values by default parameters.
715  *  \retval bool - true if parameter values have been successfully defined
716  */
717 //================================================================================
718
719 bool StdMeshers_NumberOfSegments::SetParametersByDefaults(const TDefaults&  dflts,
720                                                           const SMESH_Mesh* /*theMesh*/)
721 {
722   return (_numberOfSegments = dflts._nbSegments );
723 }