src/StdMeshers/StdMeshers_NumberOfSegments.cxx

   1 //  Copyright (C) 2007-2008  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.
  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 //  SMESH SMESH : implementaion of SMESH idl descriptions
  23 //  File   : StdMeshers_NumberOfSegments.cxx
  24 //           Moved here from SMESH_NumberOfSegments.cxx
  25 //  Author : Paul RASCLE, EDF
  26 //  Module : SMESH
  27 //
  28 #include "StdMeshers_NumberOfSegments.hxx"
  29
  30 #include "StdMeshers_Distribution.hxx"
  31 #include "SMESHDS_SubMesh.hxx"
  32 #include "SMESH_Mesh.hxx"
  33
  34 #include <ExprIntrp_GenExp.hxx>
  35 #include <Expr_Array1OfNamedUnknown.hxx>
  36 #include <Expr_NamedUnknown.hxx>
  37 #include <TColStd_Array1OfReal.hxx>
  38 #include <TCollection_AsciiString.hxx>
  39 #include <TopExp.hxx>
  40 #include <TopTools_IndexedMapOfShape.hxx>
  41
  42 #if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
  43 #define NO_CAS_CATCH
  44 #endif
  45
  46 #include <Standard_Failure.hxx>
  47
  48 #ifdef NO_CAS_CATCH
  49 #include <Standard_ErrorHandler.hxx>
  50 #endif
  51
  52 using namespace std;
  53
  54 const double PRECISION = 1e-7;
  55
  56 //=============================================================================
  57 /*!
  58  *
  59  */
  60 //=============================================================================
  61
  62 StdMeshers_NumberOfSegments::StdMeshers_NumberOfSegments(int         hypId,
  63                                                          int         studyId,
  64                                                          SMESH_Gen * gen)
  65   : SMESH_Hypothesis(hypId, studyId, gen),
  66     _numberOfSegments(15),//issue 19923
  67     _distrType(DT_Regular),
  68     _scaleFactor(1.),
  69     _convMode(1)  //cut negative by default
  70 {
  71   _name = "NumberOfSegments";
  72   _param_algo_dim = 1;
  73 }
  74
  75 //=============================================================================
  76 /*!
  77  *
  78  */
  79 //=============================================================================
  80
  81 StdMeshers_NumberOfSegments::~StdMeshers_NumberOfSegments()
  82 {
  83 }
  84
  85 //=============================================================================
  86 /*!
  87  *
  88  */
  89 //=============================================================================
  90 const vector<double>&
  91 StdMeshers_NumberOfSegments::BuildDistributionExpr( const char* expr,int nbSeg,int conv )
  92   throw ( SALOME_Exception )
  93 {
  94   if( !buildDistribution( TCollection_AsciiString( ( Standard_CString )expr ), conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
  95     _distr.resize( 0 );
  96   return _distr;
  97 }
  98
  99 const vector<double>&
 100 StdMeshers_NumberOfSegments::BuildDistributionTab( const vector<double>& tab,
 101                                                    int nbSeg,
 102                                                    int conv )
 103   throw ( SALOME_Exception )
 104 {
 105   if( !buildDistribution( tab, conv, 0.0, 1.0, nbSeg, _distr, 1E-4 ) )
 106     _distr.resize( 0 );
 107   return _distr;
 108 }
 109
 110 //=============================================================================
 111 /*!
 112  *
 113  */
 114 //=============================================================================
 115
 116 void StdMeshers_NumberOfSegments::SetNumberOfSegments(int segmentsNumber)
 117 throw(SALOME_Exception)
 118 {
 119   int oldNumberOfSegments = _numberOfSegments;
 120   if (segmentsNumber <= 0)
 121     throw SALOME_Exception(LOCALIZED("number of segments must be positive"));
 122   _numberOfSegments = segmentsNumber;
 123
 124   if (oldNumberOfSegments != _numberOfSegments)
 125     NotifySubMeshesHypothesisModification();
 126 }
 127
 128 //=============================================================================
 129 /*!
 130  *
 131  */
 132 //=============================================================================
 133
 134 int StdMeshers_NumberOfSegments::GetNumberOfSegments() const
 135 {
 136   return _numberOfSegments;
 137 }
 138
 139 //================================================================================
 140 /*!
 141  *
 142  */
 143 //================================================================================
 144
 145 void StdMeshers_NumberOfSegments::SetDistrType(DistrType typ)
 146   throw(SALOME_Exception)
 147 {
 148   if (typ < DT_Regular || typ > DT_ExprFunc)
 149     throw SALOME_Exception(LOCALIZED("distribution type is out of range"));
 150
 151   if (typ != _distrType)
 152   {
 153     _distrType = typ;
 154     NotifySubMeshesHypothesisModification();
 155   }
 156 }
 157
 158 //================================================================================
 159 /*!
 160  *
 161  */
 162 //================================================================================
 163
 164 StdMeshers_NumberOfSegments::DistrType StdMeshers_NumberOfSegments::GetDistrType() const
 165 {
 166   return _distrType;
 167 }
 168
 169 //================================================================================
 170 /*!
 171  *
 172  */
 173 //================================================================================
 174
 175 void StdMeshers_NumberOfSegments::SetScaleFactor(double scaleFactor)
 176   throw(SALOME_Exception)
 177 {
 178   if (_distrType != DT_Scale)
 179     _distrType = DT_Scale;
 180     //throw SALOME_Exception(LOCALIZED("not a scale distribution"));
 181   if (scaleFactor < PRECISION)
 182     throw SALOME_Exception(LOCALIZED("scale factor must be positive"));
 183   //if (fabs(scaleFactor - 1.0) < PRECISION)
 184   //  throw SALOME_Exception(LOCALIZED("scale factor must not be equal to 1"));
 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   int i;
 223   double prev = -PRECISION;
 224   bool isSame = table.size() == _table.size();
 225
 226   bool pos = false;
 227   for (i=0; i < table.size()/2; i++) {
 228     double par = table[i*2];
 229     double val = table[i*2+1];
 230     if( _convMode==0 )
 231     {
 232       try {
 233 #ifdef NO_CAS_CATCH
 234         OCC_CATCH_SIGNALS;
 235 #endif
 236         val = pow( 10.0, val );
 237       } catch(Standard_Failure) {
 238         Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 239         throw SALOME_Exception( LOCALIZED( "invalid value"));
 240         return;
 241       }
 242     }
 243     else if( _convMode==1 && val<0.0 )
 244       val = 0.0;
 245
 246     if ( par<0 || par > 1)
 247       throw SALOME_Exception(LOCALIZED("parameter of table function is out of range [0,1]"));
 248     if ( fabs(par-prev)<PRECISION )
 249       throw SALOME_Exception(LOCALIZED("two parameters are the same"));
 250     if ( val < 0 )
 251       throw SALOME_Exception(LOCALIZED("value of table function is not positive"));
 252     if( val>PRECISION )
 253       pos = true;
 254     if (isSame)
 255     {
 256       double oldpar = _table[i*2];
 257       double oldval = _table[i*2+1];
 258       if (fabs(par - oldpar) > PRECISION || fabs(val - oldval) > PRECISION)
 259         isSame = false;
 260     }
 261     prev = par;
 262   }
 263
 264   if( !pos )
 265     throw SALOME_Exception(LOCALIZED("value of table function is not positive"));
 266
 267   if( pos && !isSame )
 268   {
 269     _table = table;
 270     NotifySubMeshesHypothesisModification();
 271   }
 272 }
 273
 274 //================================================================================
 275 /*!
 276  *
 277  */
 278 //================================================================================
 279
 280 const vector<double>& StdMeshers_NumberOfSegments::GetTableFunction() const
 281   throw(SALOME_Exception)
 282 {
 283   if (_distrType != DT_TabFunc)
 284     throw SALOME_Exception(LOCALIZED("not a table function distribution"));
 285   return _table;
 286 }
 287
 288 //================================================================================
 289 /*! check if only 't' is unknown variable in expression
 290  */
 291 //================================================================================
 292 bool isCorrectArg( const Handle( Expr_GeneralExpression )& expr )
 293 {
 294   Handle( Expr_NamedUnknown ) sub = Handle( Expr_NamedUnknown )::DownCast( expr );
 295   if( !sub.IsNull() )
 296     return sub->GetName()=="t";
 297
 298   bool res = true;
 299   for( int i=1, n=expr->NbSubExpressions(); i<=n && res; i++ )
 300   {
 301     Handle( Expr_GeneralExpression ) sub = expr->SubExpression( i );
 302     Handle( Expr_NamedUnknown ) name = Handle( Expr_NamedUnknown )::DownCast( sub );
 303     if( !name.IsNull() )
 304     {
 305       if( name->GetName()!="t" )
 306         res = false;
 307     }
 308     else
 309       res = isCorrectArg( sub );
 310   }
 311   return res;
 312 }
 313
 314 //================================================================================
 315 /*! this function parses the expression 'str' in order to check if syntax is correct
 316  *  ( result in 'syntax' ) and if only 't' is unknown variable in expression ( result in 'args' )
 317  */
 318 //================================================================================
 319 bool process( const TCollection_AsciiString& str, int convMode,
 320               bool& syntax, bool& args,
 321               bool& non_neg, bool& non_zero,
 322               bool& singulars, double& sing_point )
 323 {
 324   // Set "C" numeric locale to save numbers correctly
 325   std::string aCurLocale = setlocale(LC_NUMERIC, 0);
 326   setlocale(LC_NUMERIC, "C");
 327
 328   bool parsed_ok = true;
 329   Handle( ExprIntrp_GenExp ) myExpr;
 330   try {
 331 #ifdef NO_CAS_CATCH
 332     OCC_CATCH_SIGNALS;
 333 #endif
 334     myExpr = ExprIntrp_GenExp::Create();
 335     myExpr->Process( str.ToCString() );
 336   } catch(Standard_Failure) {
 337     Handle(Standard_Failure) aFail = Standard_Failure::Caught();
 338     parsed_ok = false;
 339   }
 340
 341   syntax = false;
 342   args = false;
 343   if( parsed_ok && myExpr->IsDone() )
 344   {
 345     syntax = true;
 346     args = isCorrectArg( myExpr->Expression() );
 347   }
 348
 349   bool res = parsed_ok && syntax && args;
 350   if( !res )
 351     myExpr.Nullify();
 352
 353   non_neg = true;
 354   singulars = false;
 355   non_zero = false;
 356
 357   if( res )
 358   {
 359     FunctionExpr f( str.ToCString(), convMode );
 360     const int max = 500;
 361     for( int i=0; i<=max; i++ )
 362     {
 363       double t = double(i)/double(max), val;
 364       if( !f.value( t, val ) )
 365       {
 366         sing_point = t;
 367         singulars = true;
 368         break;
 369       }
 370       if( val<0 )
 371       {
 372         non_neg = false;
 373         break;
 374       }
 375       if( val>PRECISION )
 376         non_zero = true;
 377     }
 378   }
 379
 380   // Return previous locale
 381   setlocale(LC_NUMERIC, aCurLocale.data());
 382
 383   return res && non_neg && non_zero && ( !singulars );
 384 }
 385
 386 //================================================================================
 387 /*!
 388  *
 389  */
 390 //================================================================================
 391
 392 void StdMeshers_NumberOfSegments::SetExpressionFunction(const char* expr)
 393   throw(SALOME_Exception)
 394 {
 395   if (_distrType != DT_ExprFunc)
 396     _distrType = DT_ExprFunc;
 397     //throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
 398
 399   // remove white spaces
 400   TCollection_AsciiString str((Standard_CString)expr);
 401   str.RemoveAll(' ');
 402   str.RemoveAll('\t');
 403   str.RemoveAll('\r');
 404   str.RemoveAll('\n');
 405
 406   bool syntax, args, non_neg, singulars, non_zero;
 407   double sing_point;
 408   bool res = process( str, _convMode, syntax, args, non_neg, non_zero, singulars, sing_point );
 409   if( !res )
 410   {
 411     if( !syntax )
 412       throw SALOME_Exception(LOCALIZED("invalid expression syntax"));
 413     if( !args )
 414       throw SALOME_Exception(LOCALIZED("only 't' may be used as function argument"));
 415     if( !non_neg )
 416       throw SALOME_Exception(LOCALIZED("only non-negative function can be used as density"));
 417     if( singulars )
 418     {
 419       char buf[1024];
 420       sprintf( buf, "Function has singular point in %.3f", sing_point );
 421       throw SALOME_Exception( buf );
 422     }
 423     if( !non_zero )
 424       throw SALOME_Exception(LOCALIZED("f(t)=0 cannot be used as density"));
 425
 426     return;
 427   }
 428
 429   string func = expr;
 430   if( _func != func )
 431   {
 432     _func = func;
 433     NotifySubMeshesHypothesisModification();
 434   }
 435 }
 436
 437 //================================================================================
 438 /*!
 439  *
 440  */
 441 //================================================================================
 442
 443 const char* StdMeshers_NumberOfSegments::GetExpressionFunction() const
 444   throw(SALOME_Exception)
 445 {
 446   if (_distrType != DT_ExprFunc)
 447     throw SALOME_Exception(LOCALIZED("not an expression function distribution"));
 448   return _func.c_str();
 449 }
 450
 451 //================================================================================
 452 /*!
 453  *
 454  */
 455 //================================================================================
 456
 457 void StdMeshers_NumberOfSegments::SetConversionMode( int conv )
 458   throw(SALOME_Exception)
 459 {
 460 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 461 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
 462
 463   if( conv != _convMode )
 464   {
 465     _convMode = conv;
 466     NotifySubMeshesHypothesisModification();
 467   }
 468 }
 469
 470 //================================================================================
 471 /*!
 472  *
 473  */
 474 //================================================================================
 475
 476 int StdMeshers_NumberOfSegments::ConversionMode() const
 477   throw(SALOME_Exception)
 478 {
 479 //   if (_distrType != DT_TabFunc && _distrType != DT_ExprFunc)
 480 //     throw SALOME_Exception(LOCALIZED("not a functional distribution"));
 481   return _convMode;
 482 }
 483
 484 //=============================================================================
 485 /*!
 486  *
 487  */
 488 //=============================================================================
 489
 490 ostream & StdMeshers_NumberOfSegments::SaveTo(ostream & save)
 491 {
 492   int listSize = _edgeIDs.size();
 493   save << _numberOfSegments << " " << (int)_distrType;
 494   switch (_distrType)
 495   {
 496   case DT_Scale:
 497     save << " " << _scaleFactor;
 498     break;
 499   case DT_TabFunc:
 500     int i;
 501     save << " " << _table.size();
 502     for (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 = (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 ditribution type, which is integer
 550   double scale_factor;
 551   isOK = (load >> scale_factor);
 552   a = (int)scale_factor;
 553
 554   // try to interprete ditribution 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 = (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 = (load >> a);
 587       if (isOK)
 588       {
 589         _table.resize(a, 0.);
 590         int i;
 591         for (i=0; i < _table.size(); i++)
 592         {
 593           isOK = (load >> b);
 594           if (isOK)
 595             _table[i] = b;
 596           else
 597             load.clear(ios::badbit | load.rdstate());
 598         }
 599       }
 600       else
 601       {
 602         load.clear(ios::badbit | load.rdstate());
 603         // this can mean, that the hypothesis is stored in old format
 604         _distrType = DT_Regular;
 605         _scaleFactor = scale_factor;
 606       }
 607     }
 608     break;
 609   case DT_ExprFunc:
 610     {
 611       string str;
 612       isOK = (load >> str);
 613       if (isOK)
 614         _func = str;
 615       else
 616       {
 617         load.clear(ios::badbit | load.rdstate());
 618         // this can mean, that the hypothesis is stored in old format
 619         _distrType = DT_Regular;
 620         _scaleFactor = scale_factor;
 621       }
 622     }
 623     break;
 624   case DT_Regular:
 625   default:
 626     break;
 627   }
 628
 629   if (_distrType == DT_TabFunc || _distrType == DT_ExprFunc)
 630   {
 631     isOK = (load >> a);
 632     if (isOK)
 633       _convMode = a;
 634     else
 635       load.clear(ios::badbit | load.rdstate());
 636   }
 637
 638   // load reversed edges IDs
 639   int intVal;
 640   isOK = (load >> intVal);
 641   if ( isOK && _distrType != DT_Regular && intVal > 0 ) {
 642     _edgeIDs.reserve( intVal );
 643     for (int i = 0; i < _edgeIDs.capacity() && isOK; i++) {
 644       isOK = (load >> intVal);
 645       if ( isOK ) _edgeIDs.push_back( intVal );
 646     }
 647     isOK = (load >> _objEntry);
 648   }
 649
 650   return load;
 651 }
 652
 653 //=============================================================================
 654 /*!
 655  *
 656  */
 657 //=============================================================================
 658
 659 ostream & operator <<(ostream & save, StdMeshers_NumberOfSegments & hyp)
 660 {
 661   return hyp.SaveTo( save );
 662 }
 663
 664 //=============================================================================
 665 /*!
 666  *
 667  */
 668 //=============================================================================
 669
 670 istream & operator >>(istream & load, StdMeshers_NumberOfSegments & hyp)
 671 {
 672   return hyp.LoadFrom( load );
 673 }
 674
 675 //================================================================================
 676 /*!
 677  * \brief Initialize number of segments by the mesh built on the geometry
 678  * \param theMesh - the built mesh
 679  * \param theShape - the geometry of interest
 680  * \retval bool - true if parameter values have been successfully defined
 681  */
 682 //================================================================================
 683
 684 bool StdMeshers_NumberOfSegments::SetParametersByMesh(const SMESH_Mesh*   theMesh,
 685                                                       const TopoDS_Shape& theShape)
 686 {
 687   if ( !theMesh || theShape.IsNull() )
 688     return false;
 689
 690   _numberOfSegments = 0;
 691   _distrType = DT_Regular;
 692
 693   int nbEdges = 0;
 694   TopTools_IndexedMapOfShape edgeMap;
 695   TopExp::MapShapes( theShape, TopAbs_EDGE, edgeMap );
 696   SMESHDS_Mesh* aMeshDS = const_cast< SMESH_Mesh* >( theMesh )->GetMeshDS();
 697   for ( int i = 1; i <= edgeMap.Extent(); ++i )
 698   {
 699     // get current segment length
 700     SMESHDS_SubMesh * eSubMesh = aMeshDS->MeshElements( edgeMap( i ));
 701     if ( eSubMesh && eSubMesh->NbElements())
 702       _numberOfSegments += eSubMesh->NbElements();
 703
 704     ++nbEdges;
 705   }
 706   if ( nbEdges )
 707     _numberOfSegments /= nbEdges;
 708
 709   if (_numberOfSegments == 0) _numberOfSegments = 1;
 710
 711   return nbEdges;
 712 }
 713 //================================================================================
 714 /*!
 715  * \brief Initialize my parameter values by default parameters.
 716  *  \retval bool - true if parameter values have been successfully defined
 717  */
 718 //================================================================================
 719
 720 bool StdMeshers_NumberOfSegments::SetParametersByDefaults(const TDefaults&  dflts,
 721                                                           const SMESH_Mesh* /*theMesh*/)
 722 {
 723   return (_numberOfSegments = dflts._nbSegments );
 724 }
 725
 726 //=============================================================================
 727 /*!
 728  *
 729  */
 730 //=============================================================================
 731
 732 void StdMeshers_NumberOfSegments::SetReversedEdges( std::vector<int>& ids )
 733 {
 734   if ( ids != _edgeIDs ) {
 735     _edgeIDs = ids;
 736
 737     NotifySubMeshesHypothesisModification();
 738   }
 739 }
 740