StdMeshers_NumberOfSegments.hxx

Go to the documentation of this file.

// Copyright (C) 2007-2026  CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
//  SMESH SMESH : implementation of SMESH idl descriptions
//  File   : StdMeshers_NumberOfSegments.hxx
//           Moved here from SMESH_NumberOfSegments.hxx
//  Author : Paul RASCLE, EDF
//  Module : SMESH
//
#ifndef _SMESH_NUMBEROFSEGMENTS_HXX_
#define _SMESH_NUMBEROFSEGMENTS_HXX_
 
#include "StdMeshers_Reversible1D.hxx"
#include "SMESH_Hypothesis.hxx"
#include "Utils_SALOME_Exception.hxx"
 
#include <smIdType.hxx>
 
#include <vector>
 
class STDMESHERS_EXPORT StdMeshers_NumberOfSegments: public StdMeshers_Reversible1D
{
public:
  StdMeshers_NumberOfSegments(int hypId, SMESH_Gen* gen);
  virtual ~StdMeshers_NumberOfSegments();
 
  // Builds point distribution according to passed function
  const std::vector<double>& BuildDistributionExpr( const char*, int, int );
  const std::vector<double>& BuildDistributionTab( const std::vector<double>&, int, int );
 
  void SetNumberOfSegments(smIdType segmentsNumber);
 
  smIdType GetNumberOfSegments() const;
 
  enum DistrType
  {
    DT_Regular, 
    DT_Scale,   
    DT_TabFunc, 
    DT_ExprFunc, 
    DT_BetaLaw 
  };
 
  void SetDistrType(DistrType typ);
 
  DistrType GetDistrType() const;
 
  bool IsValidDistrType(int distrType) const;
 
  virtual void SetScaleFactor(double scaleFactor);
 
  double GetScaleFactor() const;
 
  virtual void SetBeta(double scaleFactor);
 
  double GetBeta() const;
 
  void SetTableFunction(const std::vector<double>& table);
 
  const std::vector<double>& GetTableFunction() const;
 
  void SetExpressionFunction( const char* expr);
 
  const char* GetExpressionFunction() const;
 
  static std::string CheckExpressionFunction( const std::string& expr,
                                              const int          convMode);
 
  void SetConversionMode( int conv );
 
  int ConversionMode() const;
 
  virtual bool SetParametersByMesh(const SMESH_Mesh* theMesh, const TopoDS_Shape& theShape);
 
  virtual bool SetParametersByDefaults(const TDefaults& dflts, const SMESH_Mesh* theMesh=0);
 
  virtual std::ostream & SaveTo(std::ostream & save);
  virtual std::istream & LoadFrom(std::istream & load);
  friend std::ostream& operator << (std::ostream & save, StdMeshers_NumberOfSegments & hyp);
  friend std::istream& operator >> (std::istream & load, StdMeshers_NumberOfSegments & hyp);
 
protected:
  smIdType            _numberOfSegments; 
  DistrType           _distrType;        
  double              _scaleFactor;      
  double              _beta;             
  std::vector<double> _table, _distr;    
  std::string         _func;             
  int                 _convMode;         
};
 
#endif