src/StdMeshers/StdMeshers_AutomaticLength.cxx

   1 //  Copyright (C) 2007-2010  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
  23 //  SMESH SMESH : implementaion of SMESH idl descriptions
  24 //  File   : StdMeshers_AutomaticLength.cxx
  25 //  Author : Edward AGAPOV, OCC
  26 //  Module : SMESH
  27 //
  28 #include "StdMeshers_AutomaticLength.hxx"
  29
  30 #include "SMESH_Mesh.hxx"
  31 #include "SMESHDS_Mesh.hxx"
  32 #include "SMESH_Algo.hxx"
  33 #include "SMESHDS_SubMesh.hxx"
  34
  35 #include "utilities.h"
  36
  37 #include <TopTools_IndexedMapOfShape.hxx>
  38 #include <TopExp.hxx>
  39 #include <TopoDS.hxx>
  40 #include <TopoDS_Edge.hxx>
  41
  42 using namespace std;
  43
  44 //=============================================================================
  45 /*!
  46  *
  47  */
  48 //=============================================================================
  49
  50 StdMeshers_AutomaticLength::StdMeshers_AutomaticLength(int hypId, int studyId, SMESH_Gen * gen)
  51   :SMESH_Hypothesis(hypId, studyId, gen)
  52 {
  53   _name = "AutomaticLength";
  54   _param_algo_dim = 1; // is used by SMESH_Regular_1D
  55
  56   _mesh = 0;
  57   _fineness = 0;
  58 }
  59
  60 //=============================================================================
  61 /*!
  62  *
  63  */
  64 //=============================================================================
  65
  66 StdMeshers_AutomaticLength::~StdMeshers_AutomaticLength()
  67 {
  68 }
  69
  70 //================================================================================
  71 /*!
  72  * \brief Set Fineness
  73  * \param theFineness - The Fineness value [0.0-1.0],
  74  *                        0 - coarse mesh
  75  *                        1 - fine mesh
  76  *
  77  * Raise if theFineness is out of range
  78  * The "Initial Number of Elements on the Shortest Edge" (S0)
  79  * is divided by (0.5 + 4.5 x theFineness)
  80  */
  81 //================================================================================
  82
  83 const double theCoarseConst = 0.5;
  84 const double theFineConst   = 4.5;
  85
  86 void StdMeshers_AutomaticLength::SetFineness(double theFineness)
  87   throw(SALOME_Exception)
  88 {
  89   if ( theFineness < 0.0 || theFineness > 1.0 )
  90     throw SALOME_Exception(LOCALIZED("theFineness is out of range [0.0-1.0]"));
  91
  92   if ( _fineness != theFineness )
  93   {
  94     NotifySubMeshesHypothesisModification();
  95     _fineness = theFineness;
  96   }
  97 }
  98
  99 namespace {
 100
 101   //================================================================================
 102   /*!
 103    * \brief Return pointer to TopoDS_TShape
 104    * \param theShape - The TopoDS_Shape
 105    * \retval inline const TopoDS_TShape* - result
 106    */
 107   //================================================================================
 108
 109   inline const TopoDS_TShape* getTShape(const TopoDS_Shape& theShape)
 110   {
 111     return theShape.TShape().operator->();
 112   }
 113
 114   //================================================================================
 115   /*!
 116    * \brief computes segment length by S0 and edge length
 117    */
 118   //================================================================================
 119
 120   const double a14divPI = 14. / PI;
 121
 122   inline double segLength(double S0, double edgeLen, double minLen )
 123   {
 124     // PAL10237
 125     // S = S0 * f(L/Lmin) where f(x) = 1 + (2/Pi * 7 * atan(x/5) )
 126     // =>
 127     // S = S0 * ( 1 + 14/PI * atan( L / ( 5 * Lmin )))
 128     return S0 * ( 1. + a14divPI * atan( edgeLen / ( 5 * minLen )));
 129   }
 130
 131   //================================================================================
 132   /*!
 133    * \brief Compute segment length for all edges
 134    * \param theMesh - The mesh
 135    * \param theTShapeToLengthMap - The map of edge to segment length
 136    */
 137   //================================================================================
 138
 139   void computeLengths( SMESHDS_Mesh*                       aMesh,
 140                        map<const TopoDS_TShape*, double> & theTShapeToLengthMap,
 141                        double &                            theS0,
 142                        double &                            theMinLen)
 143   {
 144     theTShapeToLengthMap.clear();
 145
 146     TopoDS_Shape aMainShape = aMesh->ShapeToMesh();
 147
 148     // Find length of longest and shortest edge
 149     double Lmin = DBL_MAX, Lmax = -DBL_MAX;
 150     TopTools_IndexedMapOfShape edgeMap;
 151     TopExp::MapShapes( aMainShape, TopAbs_EDGE, edgeMap);
 152     for ( int i = 1; i <= edgeMap.Extent(); ++i )
 153     {
 154       TopoDS_Edge edge = TopoDS::Edge( edgeMap(i) );
 155       //if ( BRep_Tool::Degenerated( edge )) continue;
 156
 157       Standard_Real L = SMESH_Algo::EdgeLength( edge );
 158       if ( L < DBL_MIN ) continue;
 159
 160       if ( L > Lmax ) Lmax = L;
 161       if ( L < Lmin ) Lmin = L;
 162
 163       // remember i-th edge length
 164       theTShapeToLengthMap.insert( make_pair( getTShape( edge ), L ));
 165     }
 166
 167     // Compute S0
 168
 169     // image attached to PAL10237
 170
 171     //   NbSeg
 172     //     ^
 173     //     |
 174     //   10|\
 175     //     | \
 176     //     |  \
 177     //     |   \
 178     //    5|    --------
 179     //     |
 180     //     +------------>
 181     //     1    10       Lmax/Lmin
 182
 183     const int NbSegMin = 5, NbSegMax = 10; //  on axis NbSeg
 184     const double Lrat1 = 1., Lrat2 = 10.;  //  on axis Lmax/Lmin
 185
 186     double Lratio = Lmax/Lmin;
 187     double NbSeg = NbSegMin;
 188     if ( Lratio < Lrat2 )
 189       NbSeg += ( Lrat2 - Lratio ) / ( Lrat2 - Lrat1 )  * ( NbSegMax - NbSegMin );
 190
 191     double S0 = Lmin / (int) NbSeg;
 192     MESSAGE( "S0 = " << S0 << ", Lmin = " << Lmin << ", Nbseg = " << (int) NbSeg);
 193
 194     // Compute segments length for all edges
 195     map<const TopoDS_TShape*, double>::iterator tshape_length = theTShapeToLengthMap.begin();
 196     for ( ; tshape_length != theTShapeToLengthMap.end(); ++tshape_length )
 197     {
 198       double & L = tshape_length->second;
 199       L = segLength( S0, L, Lmin );
 200     }
 201     theS0 = S0;
 202     theMinLen = Lmin;
 203   }
 204 }
 205
 206 //=============================================================================
 207 /*!
 208  * \brief Computes segment length for an edge of given length
 209  */
 210 //=============================================================================
 211
 212 double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh* theMesh,
 213                                              const double      theEdgeLength)
 214   throw(SALOME_Exception)
 215 {
 216   if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
 217
 218   SMESHDS_Mesh* aMeshDS = const_cast< SMESH_Mesh* > ( theMesh )->GetMeshDS();
 219   if ( theMesh != _mesh )
 220   {
 221     computeLengths( aMeshDS, _TShapeToLength, _S0, _minLen );
 222     _mesh = theMesh;
 223   }
 224   double L = segLength( _S0, theEdgeLength, _minLen );
 225   return L / (theCoarseConst + theFineConst * _fineness);
 226 }
 227
 228 //=============================================================================
 229 /*!
 230  *
 231  */
 232 //=============================================================================
 233
 234 double StdMeshers_AutomaticLength::GetLength(const SMESH_Mesh*   theMesh,
 235                                              const TopoDS_Shape& anEdge)
 236   throw(SALOME_Exception)
 237 {
 238   if ( !theMesh ) throw SALOME_Exception(LOCALIZED("NULL Mesh"));
 239
 240   if ( anEdge.IsNull() || anEdge.ShapeType() != TopAbs_EDGE )
 241     throw SALOME_Exception(LOCALIZED("Bad edge shape"));
 242
 243   if ( theMesh != _mesh )
 244   {
 245     SMESHDS_Mesh* aMeshDS = const_cast< SMESH_Mesh* > ( theMesh )->GetMeshDS();
 246     computeLengths( aMeshDS, _TShapeToLength, _S0, _minLen );
 247     _mesh = theMesh;
 248   }
 249
 250   map<const TopoDS_TShape*, double>::iterator tshape_length =
 251     _TShapeToLength.find( getTShape( anEdge ));
 252
 253   if ( tshape_length == _TShapeToLength.end() )
 254     return 1; // it is a dgenerated edge
 255
 256   return tshape_length->second / (theCoarseConst + theFineConst * _fineness);
 257 }
 258
 259 //=============================================================================
 260 /*!
 261  *
 262  */
 263 //=============================================================================
 264
 265 ostream & StdMeshers_AutomaticLength::SaveTo(ostream & save)
 266 {
 267   save << _fineness;
 268   return save;
 269 }
 270
 271 //=============================================================================
 272 /*!
 273  *
 274  */
 275 //=============================================================================
 276
 277 istream & StdMeshers_AutomaticLength::LoadFrom(istream & load)
 278 {
 279   if ( ! ( load >> _fineness ))
 280     load.clear(ios::badbit | load.rdstate());
 281   return load;
 282 }
 283
 284 //=============================================================================
 285 /*!
 286  *
 287  */
 288 //=============================================================================
 289
 290 ostream & operator <<(ostream & save, StdMeshers_AutomaticLength & hyp)
 291 {
 292   return hyp.SaveTo( save );
 293 }
 294
 295 //=============================================================================
 296 /*!
 297  *
 298  */
 299 //=============================================================================
 300
 301 istream & operator >>(istream & load, StdMeshers_AutomaticLength & hyp)
 302 {
 303   return hyp.LoadFrom( load );
 304 }
 305
 306 //================================================================================
 307 /*!
 308  * \brief Initialize Fineness by the mesh built on the geometry
 309  * \param theMesh - the built mesh
 310  * \param theShape - the geometry of interest
 311  * \retval bool - true if parameter values have been successfully defined
 312  */
 313 //================================================================================
 314
 315 bool StdMeshers_AutomaticLength::SetParametersByMesh(const SMESH_Mesh*   theMesh,
 316                                                      const TopoDS_Shape& theShape)
 317 {
 318   if ( !theMesh || theShape.IsNull() )
 319     return false;
 320
 321   _fineness = 0;
 322
 323   SMESHDS_Mesh* aMeshDS = const_cast< SMESH_Mesh* >( theMesh )->GetMeshDS();
 324
 325   int nbEdges = 0;
 326   TopTools_IndexedMapOfShape edgeMap;
 327   TopExp::MapShapes( theShape, TopAbs_EDGE, edgeMap );
 328   for ( int i = 1; i <= edgeMap.Extent(); ++i )
 329   {
 330     const TopoDS_Edge& edge = TopoDS::Edge( edgeMap( i ));
 331
 332     // assure the base automatic length is stored in _TShapeToLength
 333     if ( i == 1 )
 334       GetLength( theMesh, edge );
 335
 336     // get current segment length
 337     double L = SMESH_Algo::EdgeLength( edge );
 338     if ( L <= DBL_MIN )
 339       continue;
 340     SMESHDS_SubMesh * eSubMesh = aMeshDS->MeshElements( edge );
 341     if ( !eSubMesh )
 342       return false;
 343     int nbSeg = eSubMesh->NbElements();
 344     if ( nbSeg < 1 )
 345       continue;
 346     double segLen = L / nbSeg;
 347
 348     // get segment length from _TShapeToLength
 349     map<const TopoDS_TShape*, double>::iterator tshape_length =
 350       _TShapeToLength.find( getTShape( edge ));
 351     if ( tshape_length == _TShapeToLength.end() )
 352       continue;
 353     double autoLen = tshape_length->second;
 354
 355     // segLen = autoLen / (theCoarseConst + theFineConst * _fineness) -->
 356     _fineness += ( autoLen / segLen - theCoarseConst ) / theFineConst;
 357
 358     ++nbEdges;
 359   }
 360   if ( nbEdges )
 361     _fineness /= nbEdges;
 362
 363   if (_fineness > 1.0)
 364     _fineness = 1.0;
 365   else if (_fineness < 0.0)
 366     _fineness = 0.0;
 367
 368   return nbEdges;
 369 }
 370
 371 //================================================================================
 372 /*!
 373  * \brief Initialize my parameter values by default parameters.
 374  *  \retval bool - true if parameter values have been successfully defined
 375  */
 376 //================================================================================
 377
 378 bool StdMeshers_AutomaticLength::SetParametersByDefaults(const TDefaults&  /*theDflts*/,
 379                                                          const SMESH_Mesh* /*theMesh*/)
 380 {
 381   return false;
 382
 383   // assure the base automatic length is stored in _TShapeToLength
 384 //   GetLength( theMesh, elemLenght );
 385
 386 //   // find maximal edge length
 387 //   double maxLen = 0;
 388 //   map<const TopoDS_TShape*, double>::iterator
 389 //     tshape_length = _TShapeToLength.begin(), slEnd = _TShapeToLength.end();
 390 //   for ( ; tshape_length != slEnd; ++tshape_length )
 391 //     if ( tshape_length->second > maxLen )
 392 //       maxLen = tshape_length->second;
 393
 394 //   // automatic length for longest element
 395 //   double autoLen = GetLength( theMesh, maxLen );
 396
 397 //   // elemLenght = autoLen / (theCoarseConst + theFineConst * _fineness) -->
 398 //   _fineness = ( autoLen / elemLenght - theCoarseConst ) / theFineConst;
 399
 400 //   return true;
 401 }
 402
 403