mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-09-22 10:42:52 +05:00
d3c3260cd9
Delete .vscode/settings.json Publish shrinkGeometry. Refactor StdMeshers_Cartesian_3D and StdMeshers_Cartesian_VL classes to allow passing an arbitrary shrink mesh to the viscous layer builder. Use StdMeshers_Cartesian_VL in StdMeshers_ViscousLayerBuilder to handle geometry shrinking and viscous layer building. Create maps to link shrink solid and the solid assign to the shrink mesh. Code cleanup. Defining map btw original shape (TopAbs_COMPOUND) and result shrink object. Refactor to support viscous layer of faces. Code clean up and add of tests. Documentation and code cleanup erase debug comment. Modif after code review. Avoid compilation warning from ViscousLayerBuilder and ViscousLayerBuilder_i classes.
1288 lines
38 KiB
Plaintext
1288 lines
38 KiB
Plaintext
// Copyright (C) 2007-2023 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"
|
|
/*!
|
|
* StdMeshers: interfaces to standard hypotheses and algorithms
|
|
*/
|
|
module StdMeshers
|
|
{
|
|
/*!
|
|
* StdMeshers_LocalLength: interface of "Average length" hypothesis
|
|
*/
|
|
interface StdMeshers_LocalLength : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <length> parameter value
|
|
*/
|
|
void SetLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <precision> parameter value
|
|
*
|
|
* Precision parameter is used to allow rounding a number of segments,
|
|
* calculated from the edge length and average length of segment,
|
|
* to the lower integer, if this value outstands from it in bounds of the precision.
|
|
* Otherwise, the number of segments is rounded to the higher integer.
|
|
* Use value 0.5 to provide rounding to the nearest integer,
|
|
* 1.0 for the lower integer, 0.0 for the higher integer.
|
|
* Default value is 1e-07. In old studies, restored from file,
|
|
* this value will be set to zero, what corresponds to the old behaviour.
|
|
*/
|
|
void SetPrecision(in double precision)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <length> parameter value
|
|
*/
|
|
double GetLength();
|
|
|
|
/*!
|
|
* Returns <precision> parameter value
|
|
*/
|
|
double GetPrecision();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_MaxLength: interface of "Max length" hypothesis
|
|
*/
|
|
interface StdMeshers_MaxLength : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <length> parameter value
|
|
*/
|
|
void SetLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
/*!
|
|
* Returns <length> parameter value
|
|
*/
|
|
double GetLength();
|
|
/*!
|
|
* Returns true if preestemated length is defined
|
|
*/
|
|
boolean HavePreestimatedLength();
|
|
/*!
|
|
* Returns preestemated length
|
|
*/
|
|
double GetPreestimatedLength();
|
|
/*!
|
|
* Sets preestemated length
|
|
*/
|
|
void SetPreestimatedLength(in double length);
|
|
/*!
|
|
* Sets boolean parameter enabling/desabling usage of length computed
|
|
* basing on size of bounding box of shape to mesh
|
|
*/
|
|
void SetUsePreestimatedLength(in boolean toUse);
|
|
/*!
|
|
* Returns value of boolean parameter enabling/desabling usage of length computed
|
|
* basing on size of bounding box of shape to mesh
|
|
*/
|
|
boolean GetUsePreestimatedLength();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_AutomaticLength: interface of "Automatic length" hypothesis
|
|
*/
|
|
interface StdMeshers_AutomaticLength : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets Fineness parameter value
|
|
*/
|
|
void SetFineness(in double theFineness)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <Fineness> parameter value
|
|
*/
|
|
double GetFineness();
|
|
};
|
|
|
|
/*!
|
|
* Common interface of 1D hypotheses that can be reversed
|
|
*/
|
|
interface Reversible1D
|
|
{
|
|
/*!
|
|
* Set list of edges to reverse
|
|
*/
|
|
void SetReversedEdges( in SMESH::long_array list );
|
|
|
|
/*!
|
|
* Returns list of edges to reverse
|
|
*/
|
|
SMESH::long_array GetReversedEdges();
|
|
|
|
/*!
|
|
* Set entry of the main object
|
|
*/
|
|
void SetObjectEntry( in string entry );
|
|
|
|
/*!
|
|
* Get the entry of the main object
|
|
*/
|
|
string GetObjectEntry();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_NumberOfSegments: interface of "Nb. Segments" hypothesis
|
|
*/
|
|
interface StdMeshers_NumberOfSegments : SMESH::SMESH_Hypothesis, Reversible1D
|
|
{
|
|
/*!
|
|
* Builds and returns point distribution according to passed density function
|
|
*/
|
|
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);
|
|
|
|
/*!
|
|
* Sets <number of segments> parameter value
|
|
*/
|
|
void SetNumberOfSegments(in SMESH::smIdType segmentsNumber)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <number of segments> parameter value
|
|
*/
|
|
long GetNumberOfSegments();
|
|
|
|
/*!
|
|
* Sets <distribution type> parameter value
|
|
*/
|
|
void SetDistrType(in long typ)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <distribution type> parameter value
|
|
*/
|
|
long GetDistrType();
|
|
|
|
/*!
|
|
* Sets <scale factor> parameter value
|
|
*/
|
|
void SetScaleFactor(in double scaleFactor)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <scale factor> parameter value
|
|
*/
|
|
double GetScaleFactor()
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <table function> parameter value for distribution DT_TabFunc
|
|
*/
|
|
void SetTableFunction(in SMESH::double_array table)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <table function> parameter value for distribution DT_TabFunc
|
|
*/
|
|
SMESH::double_array GetTableFunction()
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <expression function> parameter value for distribution DT_ExprFunc
|
|
*/
|
|
void SetExpressionFunction(in string expr)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <expression function> parameter value for distribution DT_ExprFunc
|
|
*/
|
|
string GetExpressionFunction()
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <conversion mode> parameter value for functional distributions
|
|
*/
|
|
void SetConversionMode(in long conv )
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <conversion mode> parameter value for functional distributions
|
|
*/
|
|
long ConversionMode()
|
|
raises (SALOME::SALOME_Exception);
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Arithmetic1D: interface of "Arithmetic 1D" hypothesis
|
|
*/
|
|
interface StdMeshers_Arithmetic1D : SMESH::SMESH_Hypothesis, Reversible1D
|
|
{
|
|
/*!
|
|
* Sets <start segment length> or <end segment length> parameter value
|
|
* * OBSOLETE *. Avoid such a way of interface design
|
|
* * It is recommended to dedicate a method to each parameter.
|
|
*/
|
|
void SetLength(in double length, in boolean isStartLength)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <start segment length> parameter value
|
|
*/
|
|
void SetStartLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <end segment length> parameter value
|
|
*/
|
|
void SetEndLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <start segment length> or <end segment length> parameter value
|
|
*/
|
|
double GetLength(in boolean isStartLength);
|
|
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Arithmetic1D: interface of "Geometric 1D" hypothesis
|
|
*/
|
|
interface StdMeshers_Geometric1D : SMESH::SMESH_Hypothesis, Reversible1D
|
|
{
|
|
/*!
|
|
* Sets length of the first segment
|
|
*/
|
|
void SetStartLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets value of Common Ratio
|
|
*/
|
|
void SetCommonRatio(in double factor)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns length of the first segment
|
|
*/
|
|
double GetStartLength();
|
|
|
|
/*!
|
|
* Returns value of Common Ratio
|
|
*/
|
|
double GetCommonRatio();
|
|
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_MaxElementArea: interface of "Max. Triangle Area" hypothesis
|
|
*/
|
|
interface StdMeshers_MaxElementArea : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <maximum element area> parameter value
|
|
*/
|
|
void SetMaxElementArea(in double area)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <maximum element area> parameter value
|
|
*/
|
|
double GetMaxElementArea();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_LengthFromEdges: interface of "Length From Edges (2D Hyp. for Triangulator)" hypothesis
|
|
*/
|
|
interface StdMeshers_LengthFromEdges : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <mode> parameter value
|
|
*/
|
|
void SetMode(in long mode)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <mode> parameter value
|
|
*/
|
|
long GetMode();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_StartEndLength: interface of "Start and End Length" hypothesis
|
|
*/
|
|
interface StdMeshers_StartEndLength : SMESH::SMESH_Hypothesis, Reversible1D
|
|
{
|
|
/*!
|
|
* Sets <start segment length> or <end segment length> parameter value
|
|
* * OBSOLETE *. Avoid such a way of interface design.
|
|
* * It is recommended to dedicate a method to each parameter.
|
|
*/
|
|
void SetLength(in double length, in boolean isStartLength)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <start segment length> parameter value
|
|
*/
|
|
void SetStartLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Sets <end segment length> parameter value
|
|
*/
|
|
void SetEndLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <start segment length> or <end segment length> parameter value
|
|
*/
|
|
double GetLength(in boolean isStartLength);
|
|
|
|
};
|
|
|
|
|
|
/*!
|
|
* StdMeshers_Deflection1D: interface of "Deflection 1D" hypothesis
|
|
*/
|
|
interface StdMeshers_Deflection1D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <deflection> parameter value
|
|
*/
|
|
void SetDeflection(in double deflection)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <deflection> parameter value
|
|
*/
|
|
double GetDeflection();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_FixedPoints1D: interface of "Fixed points 1D" hypothesis
|
|
*/
|
|
interface StdMeshers_FixedPoints1D : SMESH::SMESH_Hypothesis, Reversible1D
|
|
{
|
|
/*!
|
|
* Sets some points on edge using parameter on curve from 0 to 1
|
|
* (additionally it is neecessary to check orientation of edges and
|
|
* create list of reversed edges if it is needed) and sets numbers
|
|
* of segments between given points (default values are equals 1)
|
|
*/
|
|
void SetPoints(in SMESH::double_array listParams)
|
|
raises (SALOME::SALOME_Exception);
|
|
void SetNbSegments(in SMESH::smIdType_array listNbSeg)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns list of point's parameters
|
|
*/
|
|
SMESH::double_array GetPoints();
|
|
|
|
/*!
|
|
* Returns list of numbers of segments
|
|
*/
|
|
SMESH::smIdType_array GetNbSegments();
|
|
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Adaptive1D: interface of "Adaptive" hypothesis
|
|
*/
|
|
interface StdMeshers_Adaptive1D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets minimal allowed segment length
|
|
*/
|
|
void SetMinSize(in double minSegLen) raises (SALOME::SALOME_Exception);
|
|
double GetMinSize();
|
|
|
|
/*!
|
|
* Sets maximal allowed segment length
|
|
*/
|
|
void SetMaxSize(in double maxSegLen) raises (SALOME::SALOME_Exception);
|
|
double GetMaxSize();
|
|
|
|
/*!
|
|
* Sets <deflection> parameter value,
|
|
* i.e. a maximal allowed distance between a segment and an edge.
|
|
*/
|
|
void SetDeflection(in double deflection) raises (SALOME::SALOME_Exception);
|
|
double GetDeflection();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_MaxElementVolume: interface of "Max. Hexahedron or Tetrahedron Volume" hypothesis
|
|
*/
|
|
interface StdMeshers_MaxElementVolume : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <maximum element volume> parameter value
|
|
*/
|
|
void SetMaxElementVolume(in double volume)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <maximum element volume> parameter value
|
|
*/
|
|
double GetMaxElementVolume();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_NotConformAllowed: interface of "Not Conform Mesh Allowed" hypothesis.
|
|
* Presence of this hypothesis permits to algorithm generation of not conform mesh.
|
|
*/
|
|
interface StdMeshers_NotConformAllowed : SMESH::SMESH_Hypothesis
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Propagation: interface of "Propagation of 1D Hyp. on
|
|
* Opposite Edges" hypothesis.
|
|
* Presence of this hypothesis on any edge propagates any other 1D
|
|
* hypothesis from this edge on all edges, opposite to it.
|
|
* It concerns only edges of quadrangle faces.
|
|
*/
|
|
interface StdMeshers_Propagation : SMESH::SMESH_Hypothesis
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Propagation: interface of "Propagation of Node
|
|
* Distribution on Opposite Edges" hypothesis.
|
|
* Presence of this hypothesis on any edge propagates distribution of nodes
|
|
* from this edge on all edges, opposite to it.
|
|
* It concerns only edges of quadrangle faces.
|
|
*/
|
|
interface StdMeshers_PropagOfDistribution : SMESH::SMESH_Hypothesis
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_QuadranglePreference: interface of "QuadranglePreference" hypothesis.
|
|
* This hypothesis is used by StdMeshers_Quadrangle_2D algorithm.
|
|
* Presence of this hypothesis forces construction of quadrangles if the number
|
|
* of nodes on opposite edges is not the same in the case where the global number
|
|
* of nodes on edges is even
|
|
*/
|
|
interface StdMeshers_QuadranglePreference : SMESH::SMESH_Hypothesis
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_QuadraticMesh: interface of "QuadraticMesh" hypothesis.
|
|
* This is an auxiliary 1D hypothesis whose presence forces construction
|
|
* of quadratic edges.
|
|
* If the 2D mesher sees that all boundary edges are quadratic ones,
|
|
* it generates quadratic faces, else it generates linear faces using
|
|
* medium nodes as if they were vertex ones.
|
|
* The 3D mesher generates quadratic volumes only if all boundary faces
|
|
* are quadratic ones, else it fails.
|
|
*/
|
|
interface StdMeshers_QuadraticMesh : SMESH::SMESH_Hypothesis
|
|
{
|
|
};
|
|
|
|
|
|
/*!
|
|
* StdMeshers_NumberOfLayers: interface of "Nb. Layers" hypothesis.
|
|
* This hypothesis is used by "Radial prism" algorithm.
|
|
* It specifies number of segments between the internal
|
|
* and the external surfaces.
|
|
*/
|
|
interface StdMeshers_NumberOfLayers : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <number of segments> parameter value
|
|
*/
|
|
void SetNumberOfLayers(in long numberOfLayers)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <number of layers> parameter value
|
|
*/
|
|
long GetNumberOfLayers();
|
|
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_LayerDistribution: interface of "Distribution of Layers" hypothesis.
|
|
* This hypothesis is used by "Radial prism" algorithm.
|
|
* It specifies 1D hypothesis defining distribution of segments between the internal
|
|
* and the external surfaces.
|
|
*/
|
|
interface StdMeshers_LayerDistribution : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets 1D hypothesis specifying distribution of layers
|
|
*/
|
|
void SetLayerDistribution(in SMESH::SMESH_Hypothesis distributionHyp)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns 1D hypothesis specifying distribution of layers
|
|
*/
|
|
SMESH::SMESH_Hypothesis GetLayerDistribution();
|
|
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_NumberOfLayers2D: interface of "Nb. Layers" hypothesis.
|
|
* This hypothesis is used by "Radial quadrangle" algorithm.
|
|
* It specifies number of segments between the internal
|
|
* and the external surfaces.
|
|
*/
|
|
interface StdMeshers_NumberOfLayers2D : StdMeshers_NumberOfLayers
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_LayerDistribution2D: interface of "Distribution of Layers" hypothesis.
|
|
* This hypothesis is used by "Radial quadrangle" algorithm.
|
|
* It specifies 1D hypothesis defining distribution of segments between the internal
|
|
* and the external surfaces.
|
|
*/
|
|
interface StdMeshers_LayerDistribution2D : StdMeshers_LayerDistribution
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* interface of "ProjectionSource1D" hypothesis.
|
|
* This hypothesis specifies a meshed edge to take a mesh pattern from
|
|
* and optionally association of vertices between the source edge and a
|
|
* target one (where a hipothesis is assigned to)
|
|
*/
|
|
interface StdMeshers_ProjectionSource1D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets source <edge> to take a mesh pattern from
|
|
*/
|
|
void SetSourceEdge(in GEOM::GEOM_Object edge)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns the source edge
|
|
*/
|
|
GEOM::GEOM_Object GetSourceEdge();
|
|
|
|
/*!
|
|
* Sets source <mesh> to take a mesh pattern from
|
|
*/
|
|
void SetSourceMesh(in SMESH::SMESH_Mesh mesh);
|
|
|
|
/*!
|
|
* Return source mesh
|
|
*/
|
|
SMESH::SMESH_Mesh GetSourceMesh();
|
|
|
|
/*!
|
|
* Sets vertex association between the source edge and the target one.
|
|
* This parameter is optional
|
|
*/
|
|
void SetVertexAssociation(in GEOM::GEOM_Object sourceVertex,
|
|
in GEOM::GEOM_Object targetVertex)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns the vertex associated with the target vertex.
|
|
* Result may be nil if association not set
|
|
*/
|
|
GEOM::GEOM_Object GetSourceVertex();
|
|
|
|
/*!
|
|
* Returns the vertex associated with the source vertex.
|
|
* Result may be nil if association not set
|
|
*/
|
|
GEOM::GEOM_Object GetTargetVertex();
|
|
};
|
|
|
|
/*!
|
|
* interface of "ProjectionSource2D" hypothesis.
|
|
* This hypothesis specifies a meshed face to take a mesh pattern from
|
|
* and optionally association of vertices between the source face and a
|
|
* target one (where a hipothesis is assigned to)
|
|
*/
|
|
interface StdMeshers_ProjectionSource2D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets a source <face> to take a mesh pattern from
|
|
*/
|
|
void SetSourceFace(in GEOM::GEOM_Object face)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns the source face
|
|
*/
|
|
GEOM::GEOM_Object GetSourceFace();
|
|
|
|
/*!
|
|
* Sets source <mesh> to take a mesh pattern from
|
|
*/
|
|
void SetSourceMesh(in SMESH::SMESH_Mesh mesh);
|
|
|
|
/*!
|
|
* Return source mesh
|
|
*/
|
|
SMESH::SMESH_Mesh GetSourceMesh();
|
|
|
|
/*!
|
|
* Sets vertex association between the source face and the target one.
|
|
* This parameter is optional.
|
|
* Two vertices must belong to one edge of a face
|
|
*/
|
|
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);
|
|
|
|
/*!
|
|
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
|
|
* Result may be nil if association not set.
|
|
* Valid indices are 1 and 2
|
|
*/
|
|
GEOM::GEOM_Object GetSourceVertex(in long i)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns the <i>-th target vertex associated with the <i>-th source vertex.
|
|
* Result may be nil if association not set.
|
|
* Valid indices are 1 and 2
|
|
*/
|
|
GEOM::GEOM_Object GetTargetVertex(in long i)
|
|
raises (SALOME::SALOME_Exception);
|
|
};
|
|
|
|
/*!
|
|
* interface of "ProjectionSource3D" hypothesis.
|
|
* This hypothesis specifies a meshed shell or solid to take a mesh pattern from
|
|
* and optionally association of vertices between the source shape and a
|
|
* target one (where a hipothesis is assigned to)
|
|
*/
|
|
interface StdMeshers_ProjectionSource3D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets a source <shape> to take a mesh pattern from
|
|
*/
|
|
void SetSource3DShape(in GEOM::GEOM_Object shape)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns the source shape
|
|
*/
|
|
GEOM::GEOM_Object GetSource3DShape();
|
|
|
|
/*!
|
|
* Sets source <mesh> to take a mesh pattern from
|
|
*/
|
|
void SetSourceMesh(in SMESH::SMESH_Mesh mesh);
|
|
|
|
/*!
|
|
* Return source mesh
|
|
*/
|
|
SMESH::SMESH_Mesh GetSourceMesh();
|
|
|
|
/*!
|
|
* Sets vertex association between the source shape and the target one.
|
|
* This parameter is optional.
|
|
* Two vertices must belong to one edge of a shape
|
|
*/
|
|
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);
|
|
|
|
/*!
|
|
* Returns the <i>-th source vertex associated with the <i>-th target vertex.
|
|
* Result may be nil if association not set.
|
|
* Valid indices are 1 and 2
|
|
*/
|
|
GEOM::GEOM_Object GetSourceVertex(in long i)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns the <i>-th target vertex associated with the <i>-th source vertex.
|
|
* Result may be nil if association not set.
|
|
* Valid indices are 1 and 2
|
|
*/
|
|
GEOM::GEOM_Object GetTargetVertex(in long i)
|
|
raises (SALOME::SALOME_Exception);
|
|
};
|
|
|
|
/*!
|
|
* interface of "SegmentLengthAroundVertex" hypothesis.
|
|
* This hypothesis specifies length of segments adjacent to the vertex the
|
|
* hypothesis is assigned to
|
|
*/
|
|
interface StdMeshers_SegmentLengthAroundVertex : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Sets <length> parameter value
|
|
*/
|
|
void SetLength(in double length)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns <length> parameter value
|
|
*/
|
|
double GetLength();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_QuadrangleParams: interface of "Quadrangle Params" hypothesis
|
|
*/
|
|
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
|
|
{
|
|
/*!
|
|
* Set base vertex for triangles
|
|
*/
|
|
void SetTriaVertex( in long vertID );
|
|
|
|
/*!
|
|
* Returns base vertex for triangles
|
|
*/
|
|
long GetTriaVertex();
|
|
|
|
/*!
|
|
* Set entry of the main object
|
|
*/
|
|
void SetObjectEntry( in string entry );
|
|
|
|
/*!
|
|
* Get the entry of the main object
|
|
*/
|
|
string GetObjectEntry();
|
|
|
|
/*!
|
|
* Set the type of quadrangulation
|
|
*/
|
|
void SetQuadType( in QuadType type );
|
|
|
|
/*!
|
|
* Get the type of quadrangulation
|
|
*/
|
|
QuadType GetQuadType();
|
|
|
|
/*!
|
|
* Set positions of enforced nodes
|
|
*/
|
|
void SetEnforcedNodes(in GEOM::ListOfGO vertices, in SMESH::nodes_array points)
|
|
raises (SALOME::SALOME_Exception);
|
|
|
|
/*!
|
|
* Returns positions of enforced nodes
|
|
*/
|
|
void GetEnforcedNodes(out GEOM::ListOfGO vertices, out SMESH::nodes_array points);
|
|
|
|
/*!
|
|
* Returns entries of shapes defining enforced nodes
|
|
*/
|
|
SMESH::string_array GetEnfVertices();
|
|
|
|
/*!
|
|
* Set corner vertices
|
|
*/
|
|
void SetCorners( in SMESH::long_array vertexIDs );
|
|
|
|
/*!
|
|
* Return IDs of corner vertices
|
|
*/
|
|
SMESH::long_array GetCorners();
|
|
};
|
|
|
|
/*!
|
|
* interface of "Source edges" hypothesis.
|
|
* This hypothesis specifies groups of edges of other mesh to be imported
|
|
* in this mesh
|
|
*/
|
|
interface StdMeshers_ImportSource1D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Set edges to import from other mesh
|
|
*/
|
|
void SetSourceEdges(in SMESH::ListOfGroups groups);
|
|
SMESH::string_array GetSourceEdges();
|
|
|
|
/*!
|
|
* Set to import the whole other mesh or not, and if yes, to
|
|
* copy groups of not. By default the mesh is not copied.
|
|
*/
|
|
void SetCopySourceMesh(in boolean toCopyMesh, in boolean toCopyGroups);
|
|
void GetCopySourceMesh(out boolean toCopyMesh,out boolean toCopyGroups);
|
|
};
|
|
|
|
/*!
|
|
* interface of "Source faces" hypothesis.
|
|
* This hypothesis specifies groups of faces of other mesh to be imported
|
|
* in this mesh
|
|
*/
|
|
interface StdMeshers_ImportSource2D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Set faces to import from other mesh
|
|
*/
|
|
void SetSourceFaces(in SMESH::ListOfGroups groups);
|
|
SMESH::string_array GetSourceFaces();
|
|
|
|
/*!
|
|
* Set to import the whole other mesh or not, and if yes, to
|
|
* copy groups of not. By default the mesh is not copied.
|
|
*/
|
|
void SetCopySourceMesh(in boolean toCopyMesh,in boolean toCopyGroups);
|
|
void GetCopySourceMesh(out boolean toCopyMesh,out boolean toCopyGroups);
|
|
};
|
|
|
|
/*!
|
|
* Method of computing translation of a node at Viscous Layers construction
|
|
*/
|
|
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 of "Viscous Layers" hypothesis.
|
|
* This hypothesis specifies parameters of layers of prisms to build
|
|
* near mesh boundary. This hypothesis can be used by several 3D algorithms:
|
|
* NETGEN 3D, Hexahedron(i,j,k), MG_Tetra
|
|
*/
|
|
interface StdMeshers_ViscousLayers : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Set faces to exclude from treatment
|
|
*/
|
|
void SetIgnoreFaces(in SMESH::long_array faceIDs) raises (SALOME::SALOME_Exception);
|
|
SMESH::long_array GetIgnoreFaces();
|
|
|
|
/*!
|
|
* Set faces either to exclude from treatment or to make the Viscous Layers on.
|
|
*/
|
|
void SetFaces(in SMESH::long_array faceIDs,
|
|
in boolean toIgnore) raises (SALOME::SALOME_Exception);
|
|
SMESH::long_array GetFaces();
|
|
boolean GetIsToIgnoreFaces();
|
|
|
|
/*!
|
|
* Set total thickness of layers of prisms
|
|
*/
|
|
void SetTotalThickness(in double thickness) raises (SALOME::SALOME_Exception);
|
|
double GetTotalThickness();
|
|
|
|
/*!
|
|
* Set number of layers of prisms
|
|
*/
|
|
void SetNumberLayers(in short nb) raises (SALOME::SALOME_Exception);
|
|
short GetNumberLayers();
|
|
|
|
/*!
|
|
* Set factor (>=1.0) of growth of layer thickness towards inside of mesh
|
|
*/
|
|
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 of "Viscous Layers 2D" hypothesis.
|
|
* This hypothesis specifies parameters of layers of quadrilaterals to build
|
|
* near mesh boundary. This hypothesis can be used by several 2D algorithms:
|
|
* Quadrangle (mapping), NETGEN, BLSURF
|
|
*/
|
|
interface StdMeshers_ViscousLayers2D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Set edges to exclude from treatment
|
|
*/
|
|
void SetIgnoreEdges(in SMESH::long_array edgeIDs) raises (SALOME::SALOME_Exception);
|
|
SMESH::long_array GetIgnoreEdges();
|
|
|
|
/*!
|
|
* Set edges either to exclude from treatment or to make the Viscous Layers on.
|
|
*/
|
|
void SetEdges(in SMESH::long_array edgeIDs,
|
|
in boolean toIgnore) raises (SALOME::SALOME_Exception);
|
|
SMESH::long_array GetEdges();
|
|
boolean GetIsToIgnoreEdges();
|
|
|
|
/*!
|
|
* Set total thickness of layers of prisms
|
|
*/
|
|
void SetTotalThickness(in double thickness) raises (SALOME::SALOME_Exception);
|
|
double GetTotalThickness();
|
|
|
|
/*!
|
|
* Set number of layers of prisms
|
|
*/
|
|
void SetNumberLayers(in short nb) raises (SALOME::SALOME_Exception);
|
|
short GetNumberLayers();
|
|
|
|
/*!
|
|
* Set factor (>=1.0) of growth of layer thickness towards inside of mesh
|
|
*/
|
|
void SetStretchFactor(in double factor) raises (SALOME::SALOME_Exception);
|
|
double GetStretchFactor();
|
|
|
|
void SetGroupName(in string name);
|
|
string GetGroupName();
|
|
};
|
|
|
|
/*!
|
|
* interface of "Body fitting Parameters" hypothesis.
|
|
* This hypothesis specifies
|
|
* - Size threshold
|
|
* - Definition of the Cartesian grid
|
|
* - Direction of grid axes
|
|
*/
|
|
interface StdMeshers_CartesianParameters3D : SMESH::SMESH_Hypothesis
|
|
{
|
|
/*!
|
|
* Set size threshold. A polyhedral cell got by cutting an initial
|
|
* hexahedron by geometry boundary is considered small and is removed if
|
|
* it's size is \a threshold times less than the size of the initial hexahedron.
|
|
* threshold must be > 1.0
|
|
*/
|
|
void SetSizeThreshold(in double threshold) raises (SALOME::SALOME_Exception);
|
|
double GetSizeThreshold();
|
|
|
|
/*!
|
|
* \brief Return true if the grid is defined by spacing functions and
|
|
* not by node coordinates in given direction (X==0,...)
|
|
*/
|
|
boolean IsGridBySpacing(in short axis);
|
|
|
|
/*!
|
|
* Set coordinates of nodes along an axis (countered from zero)
|
|
*/
|
|
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);
|
|
|
|
/*!
|
|
* \brief Set grid spacing along an axis
|
|
* \param spaceFunctions - functions defining spacing values at given point on axis
|
|
* \param internalPoints - points dividing a grid into parts along an axis
|
|
* \param axis - index of an axis counterd from zero, i.e. 0==X, 1==Y, 2==Z
|
|
*
|
|
* Parameter t of spaceFunction f(t) is a position [0,1] within bounding box of
|
|
* the shape to mesh or within an interval defined by internal points
|
|
*/
|
|
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);
|
|
/*!
|
|
* Set custom direction of axes
|
|
*/
|
|
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 );
|
|
/*!
|
|
* Set/unset a fixed point, at which a node will be created provided that grid
|
|
* is defined by spacing in all directions
|
|
*/
|
|
void SetFixedPoint(in SMESH::PointStruct p, in boolean toUnset);
|
|
boolean GetFixedPoint(out SMESH::PointStruct p);
|
|
|
|
/*!
|
|
* Enable implementation of geometrical edges into the mesh. If this feature
|
|
* is disabled, sharp edges of the shape are lost ("smoothed") in the mesh if
|
|
* they don't coincide with the grid lines
|
|
*/
|
|
void SetToAddEdges(in boolean toAdd);
|
|
boolean GetToAddEdges();
|
|
|
|
/*!
|
|
* Enable treatment of geom faces, either shared by solids or internal.
|
|
*/
|
|
void SetToConsiderInternalFaces(in boolean toTreat);
|
|
boolean GetToConsiderInternalFaces();
|
|
|
|
/*!
|
|
* Enable applying size threshold to grid cells cut by internal geom faces.
|
|
*/
|
|
void SetToUseThresholdForInternalFaces(in boolean toUse);
|
|
boolean GetToUseThresholdForInternalFaces();
|
|
|
|
/*!
|
|
* Enable creation of mesh faces.
|
|
*/
|
|
void SetToCreateFaces(in boolean toCreate);
|
|
boolean GetToCreateFaces();
|
|
|
|
/*!
|
|
* Return axes at which a number of generated hexahedra is maximal
|
|
*/
|
|
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);
|
|
|
|
/*!
|
|
* \brief Compute node coordinates by spacing functions
|
|
* \param x0 - lower coordinate
|
|
* \param x1 - upper coordinate
|
|
* \param spaceFuns - space functions
|
|
* \param points - internal points
|
|
* \param axisName - e.g. "X"
|
|
* \return the computed coordinates
|
|
*/
|
|
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 of "Renumber" hypothesis used by Hexahedron(ijk) algorithm
|
|
* to renumber mesh of a block to be structured-like
|
|
*/
|
|
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();
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_SegmentAroundVertex_0D: interface of "SegmentAroundVertex" algorithm
|
|
*/
|
|
interface StdMeshers_SegmentAroundVertex_0D : SMESH::SMESH_0D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Regular_1D: interface of "Wire discretisation" algorithm
|
|
*/
|
|
interface StdMeshers_Regular_1D : SMESH::SMESH_1D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_CompositeSegment_1D: interface of "Composite side discretisation" algorithm
|
|
*/
|
|
interface StdMeshers_CompositeSegment_1D : SMESH::SMESH_1D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Quadrangle_2D: interface of "Quadrangle (Mapping)" algorithm
|
|
*/
|
|
interface StdMeshers_Quadrangle_2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_QuadFromMedialAxis_1D2D: interface of "Quadrangle (Medial Axis Projection)" algorithm
|
|
*/
|
|
interface StdMeshers_QuadFromMedialAxis_1D2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_PolygonPerFace_2D: interface of "Polygon Per Face" 2D algorithm
|
|
*/
|
|
interface StdMeshers_PolygonPerFace_2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_PolyhedronPerSolid_3D: interface of "Polyhedron Per Solid" 3D algorithm
|
|
*/
|
|
interface StdMeshers_PolyhedronPerSolid_3D : SMESH::SMESH_3D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Hexa_3D: interface of "Hexahedron (i,j,k)" algorithm
|
|
*/
|
|
interface StdMeshers_Hexa_3D : SMESH::SMESH_3D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Prism_3D: interface of "3D extrusion" algorithm
|
|
*/
|
|
interface StdMeshers_Prism_3D : SMESH::SMESH_3D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_RadialPrism_3D: interface of "Radial Prism" algorithm
|
|
*/
|
|
interface StdMeshers_RadialPrism_3D : SMESH::SMESH_3D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Projection_3D: interface of "Projection 3D" algorithm
|
|
*/
|
|
interface StdMeshers_Projection_3D : SMESH::SMESH_3D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Projection_2D: interface of "Projection 2D" algorithm
|
|
*/
|
|
interface StdMeshers_Projection_2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Projection_1D2D: interface of "Projection 1D-2D" algorithm
|
|
*/
|
|
interface StdMeshers_Projection_1D2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Projection_1D: interface of "Projection 1D" algorithm
|
|
*/
|
|
interface StdMeshers_Projection_1D : SMESH::SMESH_1D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_UseExisting_2D: interface of "UseExisting 2D" algorithm
|
|
* doing nothing to allow mesh generation by mesh edition functions in TUI mode
|
|
*/
|
|
interface StdMeshers_UseExisting_2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_UseExisting_1D: interface of "UseExisting 1D" algorithm
|
|
* doing nothing to allow mesh generation by mesh edition functions in TUI mode
|
|
*/
|
|
interface StdMeshers_UseExisting_1D : SMESH::SMESH_1D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_RadialQuadrangle_1D2D: interface of "Radial quadrangle" algorithm
|
|
*/
|
|
interface StdMeshers_RadialQuadrangle_1D2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
|
|
/*!
|
|
* StdMeshers_Import_1D2D: interface of "Use existing 2D elements" algorithm
|
|
*/
|
|
interface StdMeshers_Import_1D2D : SMESH::SMESH_2D_Algo
|
|
{
|
|
};
|
|
/*!
|
|
* StdMeshers_Import_1D: interface of "Use existing 1D elements" algorithm
|
|
*/
|
|
interface StdMeshers_Import_1D : SMESH::SMESH_1D_Algo
|
|
{
|
|
};
|
|
/*!
|
|
* StdMeshers_Cartesian_3D: interface of "Body fitting" algorithm
|
|
*/
|
|
interface StdMeshers_Cartesian_3D : SMESH::SMESH_3D_Algo
|
|
{
|
|
};
|
|
/*!
|
|
* StdMeshers_Cartesian_3D: interface of "ViscousLayerBuilder" algorithm
|
|
*/
|
|
interface StdMeshers_ViscousLayerBuilder : SMESH::SMESH_2D_Algo
|
|
{
|
|
/*!
|
|
* Set faces to exclude from the definition of face to shrink
|
|
*/
|
|
void SetIgnoreFaces(in SMESH::long_array faceIDs) raises (SALOME::SALOME_Exception);
|
|
// SMESH::long_array GetIgnoreFaces();
|
|
|
|
/*!
|
|
* Set faces either to exclude from treatment or to make the offset geometry on.
|
|
*/
|
|
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 );
|
|
void SetGroupName(in string name);
|
|
|
|
GEOM::GEOM_Object GetShrinkGeometry( in SMESH::SMESH_Mesh finalMesh, in GEOM::GEOM_Object theObject );
|
|
|
|
/*!
|
|
* Build the prismatic layer from the shrink mesh
|
|
*/
|
|
boolean AddLayers( in SMESH::SMESH_Mesh sourceMesh, in SMESH::SMESH_Mesh finalMesh, in GEOM::GEOM_Object theObject );
|
|
|
|
};
|
|
|
|
};
|
|
|
|
#endif
|