SMESH_BasicHypothesis.idl

Go to the documentation of this file.

// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, 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
//

//  File   : SMESH_BasicHypothesis.idl
//  Author : Paul RASCLE, EDF
//
#ifndef _SMESH_BASICHYPOTHESIS_IDL_
#define _SMESH_BASICHYPOTHESIS_IDL_

#include "SALOME_Exception.idl"
#include "SMESH_Hypothesis.idl"
#include "SMESH_Mesh.idl"

module StdMeshers
{
  interface StdMeshers_LocalLength : SMESH::SMESH_Hypothesis
  {
    void SetLength(in double length)
      raises (SALOME::SALOME_Exception);

    void SetPrecision(in double precision)
      raises (SALOME::SALOME_Exception);

    double GetLength();

    double GetPrecision();
  };

  interface StdMeshers_MaxLength : SMESH::SMESH_Hypothesis
  {
    void SetLength(in double length)
      raises (SALOME::SALOME_Exception);
    double GetLength();
    boolean HavePreestimatedLength();
    double GetPreestimatedLength();
    void SetPreestimatedLength(in double length);
    void SetUsePreestimatedLength(in boolean toUse);
    boolean GetUsePreestimatedLength();
  };

  interface StdMeshers_AutomaticLength : SMESH::SMESH_Hypothesis
  {
    void SetFineness(in double theFineness)
      raises (SALOME::SALOME_Exception);

    double GetFineness();
  };

  interface Reversible1D
  {
    void SetReversedEdges( in SMESH::long_array list );
    
    SMESH::long_array GetReversedEdges();
    
    void SetObjectEntry( in string entry );
    
    string GetObjectEntry();
  };

  interface StdMeshers_NumberOfSegments : SMESH::SMESH_Hypothesis, Reversible1D
  {
    SMESH::double_array BuildDistributionExpr( in string func, in long nbSeg, in long conv )
      raises (SALOME::SALOME_Exception);
    SMESH::double_array BuildDistributionTab( in SMESH::double_array func, in long nbSeg, in long conv )
      raises (SALOME::SALOME_Exception);
  
    void SetNumberOfSegments(in long segmentsNumber)
      raises (SALOME::SALOME_Exception);

    long GetNumberOfSegments();

    void SetDistrType(in long typ)
      raises (SALOME::SALOME_Exception);

    long GetDistrType();

    void SetScaleFactor(in double scaleFactor)
      raises (SALOME::SALOME_Exception);

    double GetScaleFactor()
      raises (SALOME::SALOME_Exception);

    void SetTableFunction(in SMESH::double_array table)
      raises (SALOME::SALOME_Exception);

    SMESH::double_array GetTableFunction()
      raises (SALOME::SALOME_Exception);

    void SetExpressionFunction(in string expr)
      raises (SALOME::SALOME_Exception);

    string GetExpressionFunction()
      raises (SALOME::SALOME_Exception);

    void SetConversionMode(in long conv )
      raises (SALOME::SALOME_Exception);

    long ConversionMode()
      raises (SALOME::SALOME_Exception);
  };

  interface StdMeshers_Arithmetic1D : SMESH::SMESH_Hypothesis, Reversible1D
  {
    void SetLength(in double length, in boolean isStartLength) 
      raises (SALOME::SALOME_Exception);

    void SetStartLength(in double length) 
      raises (SALOME::SALOME_Exception);

    void SetEndLength(in double length)
      raises (SALOME::SALOME_Exception);

    double GetLength(in boolean isStartLength);

  };

  interface StdMeshers_Geometric1D : SMESH::SMESH_Hypothesis, Reversible1D
  {
    void SetStartLength(in double length) 
      raises (SALOME::SALOME_Exception);

    void SetCommonRatio(in double factor)
      raises (SALOME::SALOME_Exception);

    double GetStartLength();

    double GetCommonRatio();

  };

  interface StdMeshers_MaxElementArea : SMESH::SMESH_Hypothesis
  {
    void SetMaxElementArea(in double area) 
      raises (SALOME::SALOME_Exception);

    double GetMaxElementArea();
  };

  interface StdMeshers_LengthFromEdges : SMESH::SMESH_Hypothesis
  {
    void SetMode(in long mode) 
      raises (SALOME::SALOME_Exception);

    long GetMode();
  };

  interface StdMeshers_StartEndLength : SMESH::SMESH_Hypothesis, Reversible1D
  {
    void SetLength(in double length, in boolean isStartLength) 
      raises (SALOME::SALOME_Exception);

    void SetStartLength(in double length) 
      raises (SALOME::SALOME_Exception);

    void SetEndLength(in double length)
      raises (SALOME::SALOME_Exception);

    double GetLength(in boolean isStartLength);

  };


  interface StdMeshers_Deflection1D : SMESH::SMESH_Hypothesis
  {
    void SetDeflection(in double deflection)
      raises (SALOME::SALOME_Exception);

    double GetDeflection();
  };

  interface StdMeshers_FixedPoints1D : SMESH::SMESH_Hypothesis, Reversible1D
  {
    void SetPoints(in SMESH::double_array listParams) 
      raises (SALOME::SALOME_Exception);
    void SetNbSegments(in SMESH::long_array listNbSeg) 
      raises (SALOME::SALOME_Exception);

    SMESH::double_array GetPoints();
    
    SMESH::long_array GetNbSegments();

  };

  interface StdMeshers_Adaptive1D : SMESH::SMESH_Hypothesis
  {
    void SetMinSize(in double minSegLen) raises (SALOME::SALOME_Exception);
    double GetMinSize();

    void SetMaxSize(in double maxSegLen) raises (SALOME::SALOME_Exception);
    double GetMaxSize();

    void SetDeflection(in double deflection) raises (SALOME::SALOME_Exception);
    double GetDeflection();
  };

  interface StdMeshers_MaxElementVolume : SMESH::SMESH_Hypothesis
  {
    void SetMaxElementVolume(in double volume) 
      raises (SALOME::SALOME_Exception);

    double GetMaxElementVolume();
  };

  interface StdMeshers_NotConformAllowed : SMESH::SMESH_Hypothesis
  {
  };

  interface StdMeshers_Propagation : SMESH::SMESH_Hypothesis
  {
  };

  interface StdMeshers_PropagOfDistribution : SMESH::SMESH_Hypothesis
  {
  };

  interface StdMeshers_QuadranglePreference : SMESH::SMESH_Hypothesis
  {
  };

  interface StdMeshers_QuadraticMesh : SMESH::SMESH_Hypothesis
  {
  };


  interface StdMeshers_NumberOfLayers : SMESH::SMESH_Hypothesis
  {
    void SetNumberOfLayers(in long numberOfLayers) 
      raises (SALOME::SALOME_Exception);

    long GetNumberOfLayers();

  };

  interface StdMeshers_LayerDistribution : SMESH::SMESH_Hypothesis
  {
    void SetLayerDistribution(in SMESH::SMESH_Hypothesis distributionHyp) 
      raises (SALOME::SALOME_Exception);

    SMESH::SMESH_Hypothesis GetLayerDistribution();

  };

  interface StdMeshers_NumberOfLayers2D : StdMeshers_NumberOfLayers
  {
  };

  interface StdMeshers_LayerDistribution2D : StdMeshers_LayerDistribution
  {
  };

  interface StdMeshers_ProjectionSource1D : SMESH::SMESH_Hypothesis
  {
    void SetSourceEdge(in GEOM::GEOM_Object edge)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object GetSourceEdge();

    void SetSourceMesh(in SMESH::SMESH_Mesh mesh);

    SMESH::SMESH_Mesh GetSourceMesh();

    void SetVertexAssociation(in GEOM::GEOM_Object sourceVertex,
                              in GEOM::GEOM_Object targetVertex)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object  GetSourceVertex();

    GEOM::GEOM_Object  GetTargetVertex();
  };

  interface StdMeshers_ProjectionSource2D : SMESH::SMESH_Hypothesis
  {
    void SetSourceFace(in GEOM::GEOM_Object face)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object GetSourceFace();

    void SetSourceMesh(in SMESH::SMESH_Mesh mesh);

    SMESH::SMESH_Mesh GetSourceMesh();

    void SetVertexAssociation(in GEOM::GEOM_Object sourceVertex1,
                              in GEOM::GEOM_Object sourceVertex2,
                              in GEOM::GEOM_Object targetVertex1,
                              in GEOM::GEOM_Object targetVertex2)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object  GetSourceVertex(in long i)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object  GetTargetVertex(in long i)
      raises (SALOME::SALOME_Exception);
  };

  interface StdMeshers_ProjectionSource3D : SMESH::SMESH_Hypothesis
  {
    void SetSource3DShape(in GEOM::GEOM_Object shape)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object GetSource3DShape();

    void SetSourceMesh(in SMESH::SMESH_Mesh mesh);

    SMESH::SMESH_Mesh GetSourceMesh();

    void SetVertexAssociation(in GEOM::GEOM_Object sourceVertex1,
                              in GEOM::GEOM_Object sourceVertex2,
                              in GEOM::GEOM_Object targetVertex1,
                              in GEOM::GEOM_Object targetVertex2)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object  GetSourceVertex(in long i)
      raises (SALOME::SALOME_Exception);

    GEOM::GEOM_Object  GetTargetVertex(in long i)
      raises (SALOME::SALOME_Exception);
  };

  interface StdMeshers_SegmentLengthAroundVertex : SMESH::SMESH_Hypothesis
  {
    void SetLength(in double length)
      raises (SALOME::SALOME_Exception);

    double GetLength();
  };

  enum QuadType
  {
    QUAD_STANDARD,
    QUAD_TRIANGLE_PREF,
    QUAD_QUADRANGLE_PREF,
    QUAD_QUADRANGLE_PREF_REVERSED,
    QUAD_REDUCED,
    QUAD_NB_TYPES /* this is not a type of quadrangulation */
  };

  interface StdMeshers_QuadrangleParams : SMESH::SMESH_Hypothesis
  {
    void SetTriaVertex( in long vertID );
    
    long GetTriaVertex();
    
    void SetObjectEntry( in string entry );
    
    string GetObjectEntry();
    
    void SetQuadType( in QuadType type );

    QuadType GetQuadType();

    void SetEnforcedNodes(in GEOM::ListOfGO vertices, in SMESH::nodes_array points)
      raises (SALOME::SALOME_Exception);

    void GetEnforcedNodes(out GEOM::ListOfGO vertices, out SMESH::nodes_array points);

    SMESH::string_array GetEnfVertices();
  };

  interface StdMeshers_ImportSource1D : SMESH::SMESH_Hypothesis
  {
    void SetSourceEdges(in SMESH::ListOfGroups groups);
    SMESH::string_array GetSourceEdges();

    void SetCopySourceMesh(in boolean toCopyMesh, in boolean toCopyGroups);
    void GetCopySourceMesh(out boolean toCopyMesh,out boolean toCopyGroups);
  };

  interface StdMeshers_ImportSource2D : SMESH::SMESH_Hypothesis
  {
    void SetSourceFaces(in SMESH::ListOfGroups groups);
    SMESH::string_array GetSourceFaces();

    void SetCopySourceMesh(in boolean toCopyMesh,in boolean toCopyGroups);
    void GetCopySourceMesh(out boolean toCopyMesh,out boolean toCopyGroups);
  };

  enum VLExtrusionMethod { 
    // node is translated along normal to a surface with possible further smoothing
    SURF_OFFSET_SMOOTH,
    // node is translated along the average normal of surrounding faces till
    // intersection with a neighbor face translated along its own normal 
    // by the layers thickness
    FACE_OFFSET,
    // node is translated along the average normal of surrounding faces
    // by the layers thickness
    NODE_OFFSET
  };

  interface StdMeshers_ViscousLayers : SMESH::SMESH_Hypothesis
  {
    void SetIgnoreFaces(in SMESH::long_array faceIDs) raises (SALOME::SALOME_Exception);
    SMESH::long_array GetIgnoreFaces();

    void SetFaces(in SMESH::long_array faceIDs,
                  in boolean           toIgnore) raises (SALOME::SALOME_Exception);
    SMESH::long_array GetFaces();
    boolean           GetIsToIgnoreFaces();

    void SetTotalThickness(in double thickness) raises (SALOME::SALOME_Exception);
    double GetTotalThickness();

    void SetNumberLayers(in short nb) raises (SALOME::SALOME_Exception);
    short GetNumberLayers();

    void SetStretchFactor(in double factor) raises (SALOME::SALOME_Exception);
    double GetStretchFactor();

    void SetMethod( in VLExtrusionMethod how );
    VLExtrusionMethod GetMethod();
  };

  interface StdMeshers_ViscousLayers2D : SMESH::SMESH_Hypothesis
  {
    void SetIgnoreEdges(in SMESH::long_array edgeIDs) raises (SALOME::SALOME_Exception);
    SMESH::long_array GetIgnoreEdges();

    void SetEdges(in SMESH::long_array edgeIDs, 
                  in boolean           toIgnore) raises (SALOME::SALOME_Exception);
    SMESH::long_array GetEdges();
    boolean           GetIsToIgnoreEdges();

    void SetTotalThickness(in double thickness) raises (SALOME::SALOME_Exception);
    double GetTotalThickness();

    void SetNumberLayers(in short nb) raises (SALOME::SALOME_Exception);
    short GetNumberLayers();

    void SetStretchFactor(in double factor) raises (SALOME::SALOME_Exception);
    double GetStretchFactor();
  };

  interface StdMeshers_CartesianParameters3D : SMESH::SMESH_Hypothesis
  {
    void SetSizeThreshold(in double threshold) raises (SALOME::SALOME_Exception);
    double GetSizeThreshold();

    boolean IsGridBySpacing(in short axis);

    void SetGrid(in SMESH::double_array  coords,
                 in short                axis) raises (SALOME::SALOME_Exception);
    SMESH::double_array GetGrid(in short axis) raises (SALOME::SALOME_Exception);

    void SetGridSpacing(in SMESH::string_array spaceFunctions,
                        in SMESH::double_array internalPoints,
                        in short               axis) raises (SALOME::SALOME_Exception);

    void GetGridSpacing(out SMESH::string_array spaceFunctions,
                        out SMESH::double_array internalPoints,
                        in short                axis) raises (SALOME::SALOME_Exception);
    void SetAxesDirs(in SMESH::DirStruct x,
                     in SMESH::DirStruct y,
                     in SMESH::DirStruct z ) raises (SALOME::SALOME_Exception);
    void GetAxesDirs(out SMESH::DirStruct x,
                     out SMESH::DirStruct y,
                     out SMESH::DirStruct z );
    void SetFixedPoint(in SMESH::PointStruct p, in boolean toUnset);
    boolean GetFixedPoint(out SMESH::PointStruct p);

    void SetToAddEdges(in boolean toAdd);
    boolean GetToAddEdges();

    void ComputeOptimalAxesDirs(in GEOM::GEOM_Object shape,
                                in boolean           isOrthogonal,
                                out SMESH::DirStruct x,
                                out SMESH::DirStruct y,
                                out SMESH::DirStruct z ) 
      raises (SALOME::SALOME_Exception);

    SMESH::double_array ComputeCoordinates(in double              x0,
                                           in double              x1,
                                           in SMESH::string_array spaceFuns,
                                           in SMESH::double_array points,
                                           in string              axisName ) 
      raises (SALOME::SALOME_Exception);
  };

  interface StdMeshers_SegmentAroundVertex_0D : SMESH::SMESH_0D_Algo
  {
  };

  interface StdMeshers_Regular_1D : SMESH::SMESH_1D_Algo
  {
  };

  interface StdMeshers_CompositeSegment_1D : SMESH::SMESH_1D_Algo
  {
  };

  interface StdMeshers_MEFISTO_2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_Quadrangle_2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_QuadFromMedialAxis_1D2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_PolygonPerFace_2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_Hexa_3D : SMESH::SMESH_3D_Algo
  {
  };

  interface StdMeshers_Prism_3D : SMESH::SMESH_3D_Algo
  {
  };

  interface StdMeshers_RadialPrism_3D : SMESH::SMESH_3D_Algo
  {
  };

  interface StdMeshers_Projection_3D : SMESH::SMESH_3D_Algo
  {
  };

  interface StdMeshers_Projection_2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_Projection_1D2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_Projection_1D : SMESH::SMESH_1D_Algo
  {
  };

  interface StdMeshers_UseExisting_2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_UseExisting_1D : SMESH::SMESH_1D_Algo
  {
  };

  interface StdMeshers_RadialQuadrangle_1D2D : SMESH::SMESH_2D_Algo
  {
  };

  interface StdMeshers_Import_1D2D : SMESH::SMESH_2D_Algo
  {
  };
  interface StdMeshers_Import_1D : SMESH::SMESH_1D_Algo
  {
  };
  interface StdMeshers_Cartesian_3D : SMESH::SMESH_3D_Algo
  {
  };

};

#endif