SMESH_BasicHypothesis.idl

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
//
 
//  File   : SMESH_BasicHypothesis.idl
//  Author : Paul RASCLE, EDF
//
#ifndef _SMESH_BASICHYPOTHESIS_IDL_
#define _SMESH_BASICHYPOTHESIS_IDL_
 
#include "GEOM_Gen.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 SMESH::smIdType  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 SetBeta(in double beta)
      raises (SALOME::SALOME_Exception);
 
    double GetBeta()
      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::smIdType_array listNbSeg)
      raises (SALOME::SALOME_Exception);
 
    SMESH::double_array GetPoints();
    
    SMESH::smIdType_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();
 
    void SetCorners( in SMESH::long_array vertexIDs );
 
    SMESH::long_array GetCorners();
  };
 
  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();
 
    void SetGroupName(in string name);
    string GetGroupName();
  };
 
  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();
 
    void SetGroupName(in string name);
    string GetGroupName();
  };
 
  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 SetToConsiderInternalFaces(in boolean toTreat);
    boolean GetToConsiderInternalFaces();
 
    void SetToUseThresholdForInternalFaces(in boolean toUse);
    boolean GetToUseThresholdForInternalFaces();
 
    void SetToCreateFaces(in boolean toCreate);
    boolean GetToCreateFaces();
    
    void SetToUseQuanta(in boolean toUseQuanta);
    boolean GetToUseQuanta();
 
    void SetQuanta(in double quanta) raises (SALOME::SALOME_Exception);
    double GetQuanta();
 
    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);
  };
 
 
  struct BlockCS // Local coordinate system of a block
  {
    GEOM::GEOM_Object solid;
    GEOM::GEOM_Object vertex000;
    GEOM::GEOM_Object vertex001;
  };
  typedef sequence<BlockCS> blockcs_array;
 
  interface StdMeshers_BlockRenumber : SMESH::SMESH_Hypothesis
  {
    void SetBlocksOrientation( in blockcs_array blockCS );
    blockcs_array GetBlocksOrientation();
  };
 
  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_Quadrangle_2D : SMESH::SMESH_2D_Algo
  {
  };
 
  interface StdMeshers_QuadFromMedialAxis_1D2D : SMESH::SMESH_2D_Algo
  {
  };
 
  interface StdMeshers_PolygonPerFace_2D : SMESH::SMESH_2D_Algo
  {
  };
 
  interface StdMeshers_PolyhedronPerSolid_3D : SMESH::SMESH_3D_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
  {
  };
  interface StdMeshers_ViscousLayerBuilder : SMESH::SMESH_2D_Algo
  {
    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);
    void SetNumberLayers(in short numberOfLayers ) raises (SALOME::SALOME_Exception);
    void SetStretchFactor(in double strechFactor ) raises (SALOME::SALOME_Exception);
    void SetMethod( in VLExtrusionMethod how ) raises (SALOME::SALOME_Exception);
    void SetGroupName(in string name) raises (SALOME::SALOME_Exception);
 
    GEOM::GEOM_Object GetShrinkGeometry( in SMESH::SMESH_Mesh finalMesh, in GEOM::GEOM_Object theObject ) raises (SALOME::SALOME_Exception);
 
    boolean AddLayers( in SMESH::SMESH_Mesh sourceMesh, in SMESH::SMESH_Mesh finalMesh, in GEOM::GEOM_Object theObject ) raises (SALOME::SALOME_Exception);
 
  };
 
};
 
#endif