idl/SMESH_BasicHypothesis.idl

Go to the documentation of this file.

// Copyright (C) 2007-2011  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.
//
// 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 StdMeshers_NumberOfSegments : SMESH::SMESH_Hypothesis
  {
    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);

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

  interface StdMeshers_Arithmetic1D : SMESH::SMESH_Hypothesis
  {
    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);
    
    void SetReversedEdges( in SMESH::long_array list );
    
    SMESH::long_array GetReversedEdges();
    
    void SetObjectEntry( in string entry );
    
    string GetObjectEntry();
  };

  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
  {
    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);

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


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

    double GetDeflection();
  };


  interface StdMeshers_FixedPoints1D : SMESH::SMESH_Hypothesis
  {
    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();
    
    void SetReversedEdges( in SMESH::long_array list );
    
    SMESH::long_array GetReversedEdges();
    
    void SetObjectEntry( in string entry );
    
    string GetObjectEntry();
  };


  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_QuadranglePreference : SMESH::SMESH_Hypothesis
  {
  };

  interface StdMeshers_TrianglePreference : 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();
  };

  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);
  };

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

    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_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_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_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
  {
  };

};

#endif