-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2019 CEA/DEN, EDF R&D, OPEN CASCADE
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
Note:
This class should not be used directly, it is supposed to be sub-classed
- for implementing Python API for specific meshing algorithms
+ for implementing Python API for specific meshing algorithms
- For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
+ For each meshing algorithm, a python class inheriting from class *Mesh_Algorithm*
should be defined. This descendant class should have two attributes defining the way
- it is created by class Mesh (see e.g. class :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment`
- in StdMeshersBuilder package):
+ it is created by class :class:`~smeshBuilder.Mesh` (see e.g. class :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment`):
- - :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the
- python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
- in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as
- ::
+ - :code:`meshMethod` attribute defines name of method of class :class:`~smeshBuilder.Mesh` by calling which the
+ python class of algorithm is created; this method is dynamically added to the :class:`~smeshBuilder.Mesh` class
+ in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as::
- meshMethod = "MyAlgorithm"
+ meshMethod = "MyAlgorithm"
- then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
- of smesh.Mesh class:
- ::
+ then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
+ of :class:`~smeshBuilder.Mesh` class::
- my_algo = mesh.MyAlgorithm()
+ my_algo = mesh.MyAlgorithm()
- - :code:`algoType` defines type of algorithm and is used mostly to discriminate
- algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
- is specified in :code:`MyPlugin_Algorithm` class as
- ::
+ - :code:`algoType` defines type of algorithm and is used mostly to discriminate
+ algorithms that are created by the same method of class :class:`~smeshBuilder.Mesh`. For example, if this attribute
+ is specified in :code:`MyPlugin_Algorithm` class as::
- algoType = "MyPLUGIN"
+ algoType = "MyPLUGIN"
- then it's creation code can be:
- ::
+ then it's creation code can be::
- my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
+ my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
"""
def __init__(self):
"""
- Private constuctor
+ Private constructor
"""
self.mesh = None
self.geom = None
def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD):
"""
Finds a hypothesis in the study by its type name and parameters.
- Finds only the hypotheses created in smeshpyD engine.
+ Finds only the hypotheses created in smeshBuilder engine.
+
Returns:
- SMESH.SMESH_Hypothesis
+ :class:`~SMESH.SMESH_Hypothesis`
"""
study = salome.myStudy
if not study: return None
def FindAlgorithm (self, algoname, smeshpyD):
"""
Finds the algorithm in the study by its type name.
- Finds only the algorithms, which have been created in smeshpyD engine.
+ Finds only the algorithms, which have been created in smeshBuilder engine.
Returns:
SMESH.SMESH_Algo
def GetSubMesh(self):
"""
If the algorithm is global, returns 0;
- else returns the submesh associated to this algorithm.
+ else returns the :class:`~SMESH.SMESH_subMesh` associated to this algorithm.
"""
return self.subm
return shape.GetStudyEntry()
def ViscousLayers(self, thickness, numberOfLayers, stretchFactor,
- faces=[], isFacesToIgnore=True, extrMethod=StdMeshers.SURF_OFFSET_SMOOTH ):
+ faces=[], isFacesToIgnore=True,
+ extrMethod=StdMeshers.SURF_OFFSET_SMOOTH, groupName=""):
"""
Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
near mesh boundary. This hypothesis can be used by several 3D algorithms:
- StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
surrounding mesh faces by the layers thickness. Thickness of
layers can be limited to avoid creation of invalid prisms.
+ groupName: name of a group to contain elements of layers. If not provided,
+ no group is created. The group is created upon mesh generation.
+ It can be retrieved by calling
+ ::
+
+ group = mesh.GetGroupByName( groupName, SMESH.VOLUME )[0]
+
+ Returns:
+ StdMeshers.StdMeshers_ViscousLayers hypothesis
"""
-
+
if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo):
raise TypeError("ViscousLayers are supported by 3D algorithms only")
if not "ViscousLayers" in self.GetCompatibleHypothesis():
hyp.SetStretchFactor( stretchFactor )
hyp.SetFaces( faces, isFacesToIgnore )
hyp.SetMethod( extrMethod )
+ hyp.SetGroupName( groupName )
self.mesh.AddHypothesis( hyp, self.geom )
return hyp
def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor,
- edges=[], isEdgesToIgnore=True ):
+ edges=[], isEdgesToIgnore=True, groupName="" ):
"""
Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
the value of **isEdgesToIgnore** parameter.
isEdgesToIgnore: if *True*, the Viscous layers are not generated on the
edges specified by the previous parameter (**edges**).
+ groupName: name of a group to contain elements of layers. If not provided,
+ no group is created. The group is created upon mesh generation.
+ It can be retrieved by calling
+ ::
+
+ group = mesh.GetGroupByName( groupName, SMESH.FACE )[0]
+
+ Returns:
+ StdMeshers.StdMeshers_ViscousLayers2D hypothesis
"""
if not isinstance(self.algo, SMESH._objref_SMESH_2D_Algo):
hyp.SetNumberLayers(numberOfLayers)
hyp.SetStretchFactor(stretchFactor)
hyp.SetEdges(edges, isEdgesToIgnore)
+ hyp.SetGroupName( groupName )
self.mesh.AddHypothesis( hyp, self.geom )
return hyp
into a list acceptable to SetReversedEdges() of some 1D hypotheses
"""
- from salome.smesh.smeshBuilder import FirstVertexOnCurve
resList = []
geompy = self.mesh.geompyD
for i in reverseList:
if isinstance( i, int ):
- s = geompy.SubShapes(self.mesh.geom, [i])[0]
+ s = geompy.GetSubShape(self.mesh.geom, [i])
if s.GetShapeType() != geomBuilder.GEOM.EDGE:
raise TypeError("Not EDGE index given")
resList.append( i )
if e.GetShapeType() != geomBuilder.GEOM.EDGE or \
v.GetShapeType() != geomBuilder.GEOM.VERTEX:
raise TypeError("A list item must be a tuple (edge, 1st_vertex_of_edge)")
- vFirst = FirstVertexOnCurve( self.mesh, e )
+ vFirst = geompy.GetVertexByIndex( e, 0, False )
tol = geompy.Tolerance( vFirst )[-1]
if geompy.MinDistance( v, vFirst ) > 1.5*tol:
resList.append( geompy.GetSubShapeID(self.mesh.geom, e ))
