-# Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2022 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
COMPOSITE = "CompositeSegment_1D"
"""
-
Algorithm type: Composite segment 1D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_CompositeSegment`
"""
-MEFISTO = "MEFISTO_2D"
-"""
-Algorithm type: Triangle MEFISTO 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_Triangle_MEFISTO`
-"""
Hexa = "Hexa_3D"
"""
Algorithm type: Polygon Per Face 2D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_PolygonPerFace`
"""
+POLYHEDRON = "PolyhedronPerSolid_3D"
+"""
+Algorithm type: Polyhedron Per Solid 3D algorithm, see :class:`~StdMeshersBuilder.StdMeshersBuilder_PolyhedronPerSolid`
+"""
+
# import items of enums
for e in StdMeshers.QuadType._items: exec('%s = StdMeshers.%s'%(e,e))
for e in StdMeshers.VLExtrusionMethod._items: exec('%s = StdMeshers.%s'%(e,e))
of smeshBuilder.Mesh class
"""
- docHelper = "Creates segment 1D algorithm for edges"
+ docHelper = "Create segment 1D algorithm for edges"
"""
doc string of the method
"""
Parameters:
l : for the length of segments that cut an edge
UseExisting : if == true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
p : precision, used for calculation of the number of segments.
The precision should be a positive, meaningful value within the range [0,1].
In general, the number of segments is calculated with the formula:
length : is optional maximal allowed length of segment, if it is omitted
the preestimated length is used that depends on geometry size
UseExisting : if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Returns:
an instance of StdMeshers_MaxLength hypothesis
hyp = self.Hypothesis("MaxLength", [length], UseExisting=UseExisting)
- if length > 0.0:
+ if isinstance(length,str) or length > 0:
# set given length
hyp.SetLength(length)
if not UseExisting:
# set preestimated length
+ import SMESH
gen = self.mesh.smeshpyD
initHyp = gen.GetHypothesisParameterValues("MaxLength", "libStdMeshersEngine.so",
self.mesh.GetMesh(), self.mesh.GetShape(),
- False) # <- byMesh
+ SMESH.HypInitParams( 1, 1.0, False ))
preHyp = initHyp._narrow(StdMeshers.StdMeshers_MaxLength)
if preHyp:
hyp.SetPreestimatedLength( preHyp.GetPreestimatedLength() )
maxSize: defines the maximal allowed segment length
deflection: defines the maximal allowed distance from a segment to an edge
UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Returns:
an instance of StdMeshers_Adaptive1D hypothesis
reversedEdges: is a list of edges to mesh using reversed orientation.
A list item can also be a tuple (edge, 1st_vertex_of_edge)
UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Returns:
an instance of StdMeshers_Arithmetic1D hypothesis
reversedEdges: is a list of edges to mesh using reversed orientation.
A list item can also be a tuple (edge, 1st_vertex_of_edge)
UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Returns:
an instance of StdMeshers_Geometric1D hypothesis
reversedEdges: is a list of edges to mesh using reversed orientation.
A list item can also be a tuple (edge, 1st_vertex_of_edge)
UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Returns:
an instance of StdMeshers_FixedPoints1D hypothesis
reversedEdges: is a list of edges to mesh using reversed orientation.
A list item can also be a tuple (edge, 1st_vertex_of_edge)
UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Returns:
an instance of StdMeshers_StartEndLength hypothesis
hyp.SetFineness( fineness )
return hyp
- def LengthNearVertex(self, length, vertex=0, UseExisting=0):
+ def LengthNearVertex(self, length, vertex=-1, UseExisting=0):
"""
Defines "SegmentLengthAroundVertex" hypothesis
Any other integer value means that the hypothesis will be set on the
whole 1D shape, where Mesh_Segment algorithm is assigned.
UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
import types
of smeshBuilder.Mesh class
"""
- docHelper = "Creates segment 1D algorithm for edges"
+ docHelper = "Create segment 1D algorithm for edges"
"""
doc string of the method
"""
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates segment 1D algorithm for edges"
+ docHelper = "Create segment 1D algorithm for edges"
"""
doc string of the method
"""
n: for the number of segments that cut an edge
func: for the python function that calculates the length of all segments
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
compFun = lambda hyp, args: False
pass # end of StdMeshersBuilder_Segment_Python class
-class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
- """
- Triangle MEFISTO 2D algorithm.
- It is created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MEFISTO,geom=0)
- """
-
-
- meshMethod = "Triangle"
- """
- name of the dynamic method in smeshBuilder.Mesh class
- """
- algoType = MEFISTO
- """
- type of algorithm used with helper function in smeshBuilder.Mesh class
- """
- isDefault = True
- """
- flag pointing whether this algorithm should be used by default in dynamic method
- of smeshBuilder.Mesh class
- """
- docHelper = "Creates triangle 2D algorithm for faces"
- """
- doc string of the method
- """
-
- def __init__(self, mesh, geom=0):
- """
- Private constructor.
-
- Parameters:
- mesh: parent mesh object algorithm is assigned to
- geom: geometry (shape/sub-shape) algorithm is assigned to;
- if it is :code:`0` (default), the algorithm is assigned to the main shape
- """
- Mesh_Algorithm.__init__(self)
- self.Create(mesh, geom, self.algoType)
- pass
-
- def MaxElementArea(self, area, UseExisting=0):
- """
- Defines "MaxElementArea" hypothesis basing on the definition of the maximum area of each triangle
-
- Parameters:
- area: for the maximum area of each triangle
- UseExisting: if ==true - searches for an existing hypothesis created with the
- same parameters, else (default) - creates a new one
- """
-
- from salome.smesh.smeshBuilder import IsEqual
- comparator = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
- hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
- CompareMethod=comparator)
- hyp.SetMaxElementArea(area)
- return hyp
-
- def LengthFromEdges(self):
- """
- Defines "LengthFromEdges" hypothesis to build triangles
- based on the length of the edges taken from the wire
- """
-
- hyp = self.Hypothesis("LengthFromEdges", UseExisting=1, CompareMethod=self.CompareEqualHyp)
- return hyp
-
- pass # end of StdMeshersBuilder_Triangle_MEFISTO class
-
class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
"""
Defines a quadrangle 2D algorithm.
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates quadrangle 2D algorithm for faces"
+ docHelper = "Create quadrangle 2D algorithm for faces"
"""
doc string of the method
"""
pass
def QuadrangleParameters(self, quadType=StdMeshers.QUAD_STANDARD, triangleVertex=0,
- enfVertices=[],enfPoints=[],UseExisting=0):
+ enfVertices=[],enfPoints=[],corners=[],UseExisting=0):
"""
Defines "QuadrangleParameters" hypothesis
quadType defines the algorithm of transition between differently descretized
or triples of values ([[x1,y1,z1], [x2,y2,z2], ...]).
In the case if the defined QuadrangleParameters() refer to a sole face,
all given points must lie on this face, else the mesher fails.
+ corners: list of vertices that should be used as quadrangle corners.
+ The parameter can be useful for faces with more than four vertices,
+ since in some cases Quadrangle Mapping algorithm chooses corner vertices
+ differently than it is desired.
+ A hypothesis can be global and define corners for all CAD faces that
+ require it, but be sure that each specified vertex is a corner in all
+ faces the hypothesis will be applied to.
UseExisting: if *True* - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
if isinstance( enfVertices, int ) and not enfPoints and not UseExisting:
# a call of old syntax, before inserting enfVertices and enfPoints before UseExisting
UseExisting, enfVertices = enfVertices, []
+
pStructs, xyz = [], []
for p in enfPoints:
if isinstance( p, SMESH.PointStruct ):
self.params = self.Hypothesis("QuadrangleParams", [quadType,vertexID,entries,xyz],
UseExisting = UseExisting, CompareMethod=compFun)
pass
+
+ if corners and isinstance( corners[0], GEOM._objref_GEOM_Object ):
+ corners = [ self.mesh.geompyD.GetSubShapeID( self.mesh.geom, v ) for v in corners ]
+
if self.params.GetQuadType() != quadType:
self.params.SetQuadType(quadType)
if vertexID > 0:
for v in enfVertices:
AssureGeomPublished( self.mesh, v )
self.params.SetEnforcedNodes( enfVertices, pStructs )
+ self.params.SetCorners( corners )
return self.params
def QuadranglePreference(self, reversed=False, UseExisting=0):
Parameters:
reversed: if True, transition area is located along the coarser meshed sides.
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
if reversed:
Parameters:
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
return self.QuadrangleParameters(QUAD_TRIANGLE_PREF,UseExisting=UseExisting)
Parameters:
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
return self.QuadrangleParameters(QUAD_REDUCED,UseExisting=UseExisting)
Vertex can be either a GEOM_Object or a vertex ID within the
shape to mesh
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
return self.QuadrangleParameters(QUAD_STANDARD,vertex,UseExisting)
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates hexahedron 3D algorithm for volumes"
+ docHelper = "Create hexahedron 3D algorithm for volumes"
"""
doc string of the method
"""
"""
Mesh_Algorithm.__init__(self)
self.Create(mesh, geom, Hexa)
+ self.renumHypothesis = 0
pass
+ def Renumber(self, blockCSList=[] ):
+ if isinstance( blockCSList, StdMeshers.BlockCS ):
+ blockCSList = [blockCSList]
+ if not self.renumHypothesis:
+ self.renumHypothesis = self.Hypothesis("BlockRenumber", blockCSList, UseExisting=0)
+ self.renumHypothesis.SetBlocksOrientation( blockCSList )
+ return self.renumHypothesis
+
pass # end of StdMeshersBuilder_Hexahedron class
class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates projection 1D algorithm for edges"
+ docHelper = "Create projection 1D algorithm for edges"
"""
doc string of the method
"""
srcV: a vertex of *edge* to associate with *tgtV* (optional)
tgtV: a vertex of *the edge* to which the algorithm is assigned, to associate with *srcV* (optional)
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
from salome.smesh.smeshBuilder import AssureGeomPublished, Mesh
AssureGeomPublished( self.mesh, edge )
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates projection 2D algorithm for faces"
+ docHelper = "Create projection 2D algorithm for faces"
"""
doc string of the method
"""
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates projection 1D-2D algorithm for faces"
+ docHelper = "Create projection 1D-2D algorithm for faces"
"""
doc string of the method
"""
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates projection 3D algorithm for volumes"
+ docHelper = "Create projection 3D algorithm for volumes"
"""
doc string of the method
"""
srcV2: a vertex of *solid* to associate with *tgtV1* (optional)
tgtV2: a vertex of *the solid* to which the algorithm is assigned,to associate with *srcV2* (optional)
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
Note:
association vertices must belong to one edge of a solid
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates prism 3D algorithm for volumes"
+ docHelper = "Create prism 3D algorithm for volumes"
"""
doc string of the method
"""
Parameters:
n: number of layers
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
if self.algoType != "RadialPrism_3D":
print("Prism_3D algorithm doesn't support any hypothesis")
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates Raial Prism 3D algorithm for volumes"
+ docHelper = "Create Raial Prism 3D algorithm for volumes"
"""
doc string of the method
"""
Parameters:
n: number of layers
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
if self.distribHyp:
self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
+ docHelper = "Create quadrangle 1D-2D algorithm for faces having a shape of disk or a disk segment"
"""
doc string of the method
"""
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates quadrangle 1D-2D algorithm for faces"
+ docHelper = "Create quadrangle 1D-2D algorithm for faces"
"""
doc string of the method
"""
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates polygon 2D algorithm for faces"
+ docHelper = "Create polygon 2D algorithm for faces"
+ """
+ doc string of the method
+ """
+
+ def __init__(self, mesh, geom=0):
+ """
+ Private constructor.
+
+ Parameters:
+ mesh: parent mesh object algorithm is assigned to
+ geom: geometry (shape/sub-shape) algorithm is assigned to;
+ if it is :code:`0` (default), the algorithm is assigned to the main shape
+ """
+ Mesh_Algorithm.__init__(self)
+ self.Create(mesh, geom, self.algoType)
+ pass
+
+ pass
+
+class StdMeshersBuilder_PolyhedronPerSolid(Mesh_Algorithm):
+ """ Defines a Polyhedron Per Solid 3D algorithm.
+ It is created by calling smeshBuilder.Mesh.Polyhedron(geom=0)
+ """
+
+ meshMethod = "Polyhedron"
+ """
+ name of the dynamic method in smeshBuilder.Mesh class
+ """
+ algoType = POLYHEDRON
+ """
+ type of algorithm used with helper function in smeshBuilder.Mesh class
+ """
+ isDefault = True
+ """
+ flag pointing whether this algorithm should be used by default in dynamic method
+ of smeshBuilder.Mesh class
+ """
+ docHelper = "Create polyhedron 3D algorithm for solids"
"""
doc string of the method
"""
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates 1D algorithm for edges with reusing of existing mesh elements"
+ docHelper = "Create 1D algorithm for edges with reusing of existing mesh elements"
"""
doc string of the method
"""
toCopyMesh: if True, the whole mesh *groups* belong to is imported
toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
for group in groups:
from salome.smesh.smeshBuilder import AssureGeomPublished
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates 1D-2D algorithm for faces with reusing of existing mesh elements"
+ docHelper = "Create 1D-2D algorithm for faces with reusing of existing mesh elements"
"""
doc string of the method
"""
toCopyMesh: if True, the whole mesh *groups* belong to is imported
toCopyGroups: if True, all groups of the mesh *groups* belong to are imported
UseExisting: if ==true - searches for the existing hypothesis created with
- the same parameters, else (default) - creates a new one
+ the same parameters, else (default) - Create a new one
"""
import SMESH
compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
flag pointing whether this algorithm should be used by default in dynamic method
of smeshBuilder.Mesh class
"""
- docHelper = "Creates Body Fitting 3D algorithm for volumes"
+ docHelper = "Create Body Fitting 3D algorithm for volumes"
"""
doc string of the method
"""
- Functions f(t) defining grid spacing at each point on grid axis. If there are
several functions, they must be accompanied by relative coordinates of
points dividing the whole shape into ranges where the functions apply; points
- coodrinates should vary within (0.0, 1.0) range. Parameter *t* of the spacing
+ coordinates should vary within (0.0, 1.0) range. Parameter *t* of the spacing
function f(t) varies from 0.0 to 1.0 within a shape range.
+ Note:
+ The actual grid spacing can slightly differ from the defined one. This is done for the
+ best fitting of polyhedrons and for a better mesh quality on the interval boundaries.
+ For example, if a constant **Spacing** is defined along an axis, the actual grid will
+ fill the shape's dimension L along this axis with round number of equal cells:
+ Spacing_actual = L / round( L / Spacing_defined ).
Examples:
"10.5" - defines a grid with a constant spacing
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates 1D algorithm allowing batch meshing of edges"
+ docHelper = "Create 1D algorithm allowing batch meshing of edges"
"""
doc string of the method
"""
"""
type of algorithm used with helper function in smeshBuilder.Mesh class
"""
- docHelper = "Creates 2D algorithm allowing batch meshing of faces"
+ docHelper = "Create 2D algorithm allowing batch meshing of faces"
"""
doc string of the method
"""