# Python API for the standard meshing plug-in module.
from salome.smesh.smesh_algorithm import Mesh_Algorithm
-from salome.smesh.smeshBuilder import AssureGeomPublished, IsEqual, ParseParameters
-from salome.smesh.smeshBuilder import GetName, TreatHypoStatus
-from salome.smesh.smeshBuilder import Mesh
-
import StdMeshers
#----------------------------
## Defines segment 1D algorithm for edges discretization.
#
-# It can be created by calling smesh.Mesh.Segment(geom=0)
+# It can be created by calling smeshBuilder.Mesh.Segment(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_Segment(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Segment"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = REGULAR
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
# @return an instance of StdMeshers_LocalLength hypothesis
# @ingroup l3_hypos_1dhyps
def LocalLength(self, l, UseExisting=0, p=1e-07):
+ from salome.smesh.smeshBuilder import IsEqual
comFun=lambda hyp, args: IsEqual(hyp.GetLength(), args[0]) and IsEqual(hyp.GetPrecision(), args[1])
hyp = self.Hypothesis("LocalLength", [l,p], UseExisting=UseExisting, CompareMethod=comFun)
hyp.SetLength(l)
if not args[1] or hyp.GetObjectEntry() == args[2]:
return True
else:
+ from salome.smesh.smeshBuilder import IsEqual
if hyp.GetReversedEdges() == args[2]:
if not args[2] or hyp.GetObjectEntry() == args[3]:
if hyp.GetDistrType() == 1:
return True
return False
+ ## Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
+ # within the given range and considering (1) deflection of segments from the edge
+ # and (2) distance from segments to closest edges and faces to have segment length
+ # not longer than two times shortest distances to edges and faces.
+ # @param minSize defines the minimal allowed segment length
+ # @param maxSize defines the maximal allowed segment length
+ # @param deflection defines the maximal allowed distance from a segment to an edge
+ # @param UseExisting if ==true - searches for an existing hypothesis created with
+ # the same parameters, else (default) - creates a new one
+ # @return an instance of StdMeshers_Adaptive1D hypothesis
+ # @ingroup l3_hypos_1dhyps
+ def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
+ from salome.smesh.smeshBuilder import IsEqual
+ compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
+ IsEqual(hyp.GetMaxSize(), args[1]) and \
+ IsEqual(hyp.GetDeflection(), args[2]))
+ hyp = self.Hypothesis("Adaptive1D", [minSize, maxSize, deflection],
+ UseExisting=UseExisting, CompareMethod=compFun)
+ hyp.SetMinSize(minSize)
+ hyp.SetMaxSize(maxSize)
+ hyp.SetDeflection(deflection)
+ return hyp
+
## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with increasing arithmetic length
# @param start defines the length of the first segment
# @param end defines the length of the last segment
reversedEdges, UseExisting = [], reversedEdges
reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
entry = self.MainShapeEntry()
+ from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
IsEqual(hyp.GetLength(0), args[1]) and \
hyp.GetReversedEdges() == args[2] and \
reversedEdges, UseExisting = [], reversedEdges
reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
entry = self.MainShapeEntry()
+ from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: ( IsEqual(hyp.GetLength(1), args[0]) and \
IsEqual(hyp.GetLength(0), args[1]) and \
hyp.GetReversedEdges() == args[2] and \
# the same parameters, else (default) - create a new one
# @ingroup l3_hypos_1dhyps
def Deflection1D(self, d, UseExisting=0):
+ from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0])
hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun)
hyp.SetDeflection(d)
# same parameters, else (default) - create a new one
# @ingroup l3_hypos_1dhyps
def AutomaticLength(self, fineness=0, UseExisting=0):
+ from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0])
hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting,
CompareMethod=compFun)
if type(vertex) is types.IntType:
if vertex == 0 or vertex == 1:
from salome.geom import geomBuilder
- vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.ShapeType["VERTEX"],True)[vertex]
+ vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.geomBuilder.ShapeType["VERTEX"],True)[vertex]
self.geom = vertex
pass
pass
# 0D algorithm
if self.geom is None:
raise RuntimeError, "Attemp to create SegmentAroundVertex_0D algoritm on None shape"
+ from salome.smesh.smeshBuilder import AssureGeomPublished, GetName, TreatHypoStatus
AssureGeomPublished( self.mesh, self.geom )
name = GetName(self.geom)
status = self.mesh.mesh.AddHypothesis(self.geom, algo)
TreatHypoStatus(status, "SegmentAroundVertex_0D", name, True)
#
+ from salome.smesh.smeshBuilder import IsEqual
comFun = lambda hyp, args: IsEqual(hyp.GetLength(), args[0])
hyp = self.Hypothesis("SegmentLengthAroundVertex", [length], UseExisting=UseExisting,
CompareMethod=comFun)
## Segment 1D algorithm for discretization of a set of adjacent edges as one edge.
#
-# It is created by calling smesh.Mesh.Segment(smesh.COMPOSITE,geom=0)
+# It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.COMPOSITE,geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_CompositeSegment(StdMeshersBuilder_Segment):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Segment"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = COMPOSITE
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = False
## doc string of the method
## Defines a segment 1D algorithm for discretization of edges with Python function
#
-# It is created by calling smesh.Mesh.Segment(smesh.PYTHON,geom=0)
+# It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Segment"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = PYTHON
## doc string of the method
## Triangle MEFISTO 2D algorithm
#
-# It is created by calling smesh.Mesh.Triangle(smesh.MEFISTO,geom=0)
+# It is created by calling smeshBuilder.Mesh.Triangle(smeshBuilder.MEFISTO,geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_Triangle_MEFISTO(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Triangle"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = MEFISTO
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
#
# @ingroup l3_hypos_2dhyps
def MaxElementArea(self, area, UseExisting=0):
+ from salome.smesh.smeshBuilder import IsEqual
comparator = lambda hyp, args: IsEqual(hyp.GetMaxElementArea(), args[0])
hyp = self.Hypothesis("MaxElementArea", [area], UseExisting=UseExisting,
CompareMethod=comparator)
## Defines a quadrangle 2D algorithm
#
-# It is created by calling smesh.Mesh.Quadrangle(geom=0)
+# It is created by calling smeshBuilder.Mesh.Quadrangle(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_Quadrangle(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Quadrangle"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = QUADRANGLE
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
## Defines a hexahedron 3D algorithm
#
-# It is created by calling smesh.Mesh.Hexahedron(geom=0)
+# It is created by calling smeshBuilder.Mesh.Hexahedron(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_Hexahedron(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Hexahedron"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = Hexa
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
## Defines a projection 1D algorithm
#
-# It is created by calling smesh.Mesh.Projection1D(geom=0)
+# It is created by calling smeshBuilder.Mesh.Projection1D(geom=0)
#
# @ingroup l3_algos_proj
class StdMeshersBuilder_Projection1D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Projection1D"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Projection_1D"
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
# @param UseExisting if ==true - searches for the existing hypothesis created with
# the same parameters, else (default) - creates a new one
def SourceEdge(self, edge, mesh=None, srcV=None, tgtV=None, UseExisting=0):
+ from salome.smesh.smeshBuilder import AssureGeomPublished
AssureGeomPublished( self.mesh, edge )
AssureGeomPublished( self.mesh, srcV )
AssureGeomPublished( self.mesh, tgtV )
## Defines a projection 2D algorithm
#
-# It is created by calling smesh.Mesh.Projection2D(geom=0)
+# It is created by calling smeshBuilder.Mesh.Projection2D(geom=0)
#
# @ingroup l3_algos_proj
class StdMeshersBuilder_Projection2D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Projection2D"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Projection_2D"
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
if isinstance(mesh, Mesh):
mesh = mesh.GetMesh()
for geom in [ face, srcV1, tgtV1, srcV2, tgtV2 ]:
+ from salome.smesh.smeshBuilder import AssureGeomPublished
AssureGeomPublished( self.mesh, geom )
hyp = self.Hypothesis("ProjectionSource2D", [face,mesh,srcV1,tgtV1,srcV2,tgtV2],
UseExisting=0)
## Defines a projection 1D-2D algorithm
#
-# It is created by calling smesh.Mesh.Projection1D2D(geom=0)
+# It is created by calling smeshBuilder.Mesh.Projection1D2D(geom=0)
#
# @ingroup l3_algos_proj
class StdMeshersBuilder_Projection1D2D(StdMeshersBuilder_Projection2D):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Projection1D2D"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Projection_1D2D"
## doc string of the method
## Defines a projection 3D algorithm
#
-# It is created by calling smesh.Mesh.Projection3D(geom=0)
+# It is created by calling smeshBuilder.Mesh.Projection3D(geom=0)
#
# @ingroup l3_algos_proj
class StdMeshersBuilder_Projection3D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Projection3D"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Projection_3D"
## doc string of the method
def SourceShape3D(self, solid, mesh=0, srcV1=0, tgtV1=0,
srcV2=0, tgtV2=0, UseExisting=0):
for geom in [ solid, srcV1, tgtV1, srcV2, tgtV2 ]:
+ from salome.smesh.smeshBuilder import AssureGeomPublished
AssureGeomPublished( self.mesh, geom )
hyp = self.Hypothesis("ProjectionSource3D",
[solid,mesh,srcV1,tgtV1,srcV2,tgtV2],
## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism"
# depending on geometry
#
-# It is created by calling smesh.Mesh.Prism(geom=0)
+# It is created by calling smeshBuilder.Mesh.Prism(geom=0)
#
# @ingroup l3_algos_3dextr
class StdMeshersBuilder_Prism3D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Prism"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Prism_3D"
## doc string of the method
shape = geom
if not shape:
shape = mesh.geom
- from geompy import SubShapeAll, ShapeType
- nbSolids = len( SubShapeAll( shape, ShapeType["SOLID"] ))
- nbShells = len( SubShapeAll( shape, ShapeType["SHELL"] ))
+ from salome.geom import geomBuilder
+ nbSolids = len( geomBuilder.geom.SubShapeAll( shape, geomBuilder.geomBuilder.ShapeType["SOLID"] ))
+ nbShells = len( geomBuilder.geom.SubShapeAll( shape, geomBuilder.geomBuilder.ShapeType["SHELL"] ))
if nbSolids == 0 or nbSolids == nbShells:
self.Create(mesh, geom, "Prism_3D")
pass
print "Prism_3D algorith doesn't support any hyposesis"
return None
self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
+ from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
self.nbLayers = self.Hypothesis("NumberOfLayers", [n], UseExisting=UseExisting,
CompareMethod=compFun)
## Defines a Prism 3D algorithm, which is either "Extrusion 3D" or "Radial Prism"
# depending on geometry
#
-# It is created by calling smesh.Mesh.Prism(geom=0)
+# It is created by calling smeshBuilder.Mesh.Prism(geom=0)
#
# @ingroup l3_algos_3dextr
class StdMeshersBuilder_RadialPrism3D(StdMeshersBuilder_Prism3D):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Prism"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "RadialPrism_3D"
## doc string of the method
## Defines a Radial Quadrangle 1D-2D algorithm
#
-# It is created by calling smesh.Mesh.Quadrangle(smesh.RADIAL_QUAD,geom=0)
+# It is created by calling smeshBuilder.Mesh.Quadrangle(smeshBuilder.RADIAL_QUAD,geom=0)
#
# @ingroup l2_algos_radialq
class StdMeshersBuilder_RadialQuadrangle1D2D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "Quadrangle"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = RADIAL_QUAD
## doc string of the method
def NumberOfLayers(self, n, UseExisting=0):
if self.distribHyp:
self.mesh.GetMesh().RemoveHypothesis( self.geom, self.distribHyp )
+ from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: IsEqual(hyp.GetNumberOfLayers(), args[0])
self.nbLayers = self.Hypothesis("NumberOfLayers2D", [n], UseExisting=UseExisting,
CompareMethod=compFun)
## Defines a Use Existing Elements 1D algorithm
#
-# It is created by calling smesh.Mesh.UseExisting1DElements(geom=0)
+# It is created by calling smeshBuilder.Mesh.UseExisting1DElements(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_UseExistingElements_1D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "UseExisting1DElements"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Import_1D"
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
# the same parameters, else (default) - creates a new one
def SourceEdges(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
for group in groups:
+ from salome.smesh.smeshBuilder import AssureGeomPublished
AssureGeomPublished( self.mesh, group )
compFun = lambda hyp, args: ( hyp.GetSourceEdges() == args[0] and \
hyp.GetCopySourceMesh() == args[1], args[2] )
## Defines a Use Existing Elements 1D-2D algorithm
#
-# It is created by calling smesh.Mesh.UseExisting2DElements(geom=0)
+# It is created by calling smeshBuilder.Mesh.UseExisting2DElements(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_UseExistingElements_1D2D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "UseExisting2DElements"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Import_1D2D"
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
# the same parameters, else (default) - creates a new one
def SourceFaces(self, groups, toCopyMesh=False, toCopyGroups=False, UseExisting=False):
for group in groups:
+ from salome.smesh.smeshBuilder import AssureGeomPublished
AssureGeomPublished( self.mesh, group )
compFun = lambda hyp, args: ( hyp.GetSourceFaces() == args[0] and \
hyp.GetCopySourceMesh() == args[1], args[2] )
## Defines a Body Fitting 3D algorithm
#
-# It is created by calling smesh.Mesh.BodyFitted(geom=0)
+# It is created by calling smeshBuilder.Mesh.BodyFitted(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_Cartesian_3D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "BodyFitted"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "Cartesian_3D"
## flag pointing either this algorithm should be used by default in dynamic method
- # of smesh.Mesh class
+ # of smeshBuilder.Mesh class
# @internal
isDefault = True
## doc string of the method
## Defines a stub 1D algorithm, which enables "manual" creation of nodes and
# segments usable by 2D algoritms
#
-# It is created by calling smesh.Mesh.UseExistingSegments(geom=0)
+# It is created by calling smeshBuilder.Mesh.UseExistingSegments(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_UseExisting_1D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "UseExistingSegments"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "UseExisting_1D"
## doc string of the method
## Defines a stub 2D algorithm, which enables "manual" creation of nodes and
# faces usable by 3D algoritms
#
-# It is created by calling smesh.Mesh.UseExistingFaces(geom=0)
+# It is created by calling smeshBuilder.Mesh.UseExistingFaces(geom=0)
#
# @ingroup l3_algos_basic
class StdMeshersBuilder_UseExisting_2D(Mesh_Algorithm):
- ## name of the dynamic method in smesh.Mesh class
+ ## name of the dynamic method in smeshBuilder.Mesh class
# @internal
meshMethod = "UseExistingFaces"
- ## type of algorithm used with helper function in smesh.Mesh class
+ ## type of algorithm used with helper function in smeshBuilder.Mesh class
# @internal
algoType = "UseExisting_2D"
## doc string of the method