- def PythonSplit1D(self, n, func):
- """
- Define "PythonSplit1D" hypothesis based on the Erwan Adam patch, awaiting equivalent SALOME functionality
- \param n for the number of segments that cut an edge
- \param func for the python function that calculate the length of all segments
- """
- hyp = self.Hypothesis("PythonSplit1D", [n], "libPython1dEngine.so")
- hyp.SetNumberOfSegments(n)
- hyp.SetPythonLog10RatioFunction(func)
- return hyp
-
-# Public class: Mesh_Triangle
-# ---------------------------
-
-class Mesh_Triangle(Mesh_Algorithm):
- """
- Class to define a triangle 2D algorithm
- """
-
- def __init__(self, mesh, geom=0):
- """
- Private constructor
- """
- self.Create(mesh, geom, "MEFISTO_2D")
-
- def MaxElementArea(self, area):
- """
- Define "MaxElementArea" hypothesis to give the maximun area of each triangles
- \param area for the maximum area of each triangles
- """
- hyp = self.Hypothesis("MaxElementArea", [area])
- hyp.SetMaxElementArea(area)
- return hyp
-
- def LengthFromEdges(self):
- """
- Define "LengthFromEdges" hypothesis to build triangles based on the length of the edges taken from the wire
- """
- return self.Hypothesis("LengthFromEdges")
-
-# Public class: Mesh_Quadrangle
-# -----------------------------
-
-class Mesh_Quadrangle(Mesh_Algorithm):
- """
- Class to define a quadrangle 2D algorithm
- """
-
- def __init__(self, mesh, geom=0):
- """
- Private constructor
- """
- self.Create(mesh, geom, "Quadrangle_2D")
-
-# Public class: Mesh_Tetrahedron
-# ------------------------------
-
-class Mesh_Tetrahedron(Mesh_Algorithm):
- """
- Class to define a tetrahedron 3D algorithm
- """
-
- def __init__(self, mesh, algo, geom=0):
- """
- Private constructor
- """
- if algo == NETGEN:
- self.Create(mesh, geom, "NETGEN_3D", "libNETGENEngine.so")
- elif algo == GHS3D:
- import GHS3DPlugin
- self.Create(mesh, geom, "GHS3D_3D" , "libGHS3DEngine.so")
-
- def MaxElementVolume(self, vol):
- """
- Define "MaxElementVolume" hypothesis to give the maximun volume of each tetrahedral
- \param vol for the maximum volume of each tetrahedral
- """
- hyp = self.Hypothesis("MaxElementVolume", [vol])
- hyp.SetMaxElementVolume(vol)
- return hyp
-
-# Public class: Mesh_Hexahedron
-# ------------------------------
-
-class Mesh_Hexahedron(Mesh_Algorithm):
- """
- Class to define a hexahedron 3D algorithm
- """
-
- def __init__(self, mesh, geom=0):
- """
- Private constructor
- """
- self.Create(mesh, geom, "Hexa_3D")
-
-# Public class: Mesh
-# ==================
-
-class Mesh:
- """
- Class to define a mesh
- """
-
- geom = 0
- mesh = 0
-
- def __init__(self, geom, name=0):
- """
- Constructor
-
- Creates mesh on the shape \a geom,
- sets GUI name of this mesh to \a name.
- \param geom Shape to be meshed
- \param name Study name of the mesh
- """
- self.geom = geom
- self.mesh = smesh.CreateMesh(geom)
- if name == 0:
- SetName(self.mesh, GetName(geom))
- else:
- SetName(self.mesh, name)
-
- def GetMesh(self):
- """
- Method that returns the mesh
- """
- return self.mesh
-
- def GetShape(self):
- """
- Method that returns the shape associated to the mesh
- """
- return self.geom
-
- def Segment(self, algo=REGULAR, geom=0):
- """
- Creates a segment discretization 1D algorithm.
- If the optional \a algo parameter is not sets, this algorithm is REGULAR.
- If the optional \a geom parameter is not sets, this algorithm is global.
- Otherwise, this algorithm define a submesh based on \a geom subshape.
- \param algo values are smesh.REGULAR or smesh.PYTHON for discretization via python function
- \param geom If defined, subshape to be meshed
- """
- if algo == REGULAR:
- return Mesh_Segment(self, geom)
- elif algo == PYTHON:
- return Mesh_Segment_Python(self, geom)
- else:
- return Mesh_Segment(self, algo)
-
- def Triangle(self, geom=0):
- """
- Creates a triangle 2D algorithm for faces.
- If the optional \a geom parameter is not sets, this algorithm is global.
- Otherwise, this algorithm define a submesh based on \a geom subshape.
- \param geom If defined, subshape to be meshed
- """
- return Mesh_Triangle(self, geom)
-
- def Quadrangle(self, geom=0):
- """
- Creates a quadrangle 2D algorithm for faces.
- If the optional \a geom parameter is not sets, this algorithm is global.
- Otherwise, this algorithm define a submesh based on \a geom subshape.
- \param geom If defined, subshape to be meshed
- """
- return Mesh_Quadrangle(self, geom)
-
- def Tetrahedron(self, algo, geom=0):
- """
- Creates a tetrahedron 3D algorithm for solids.
- The parameter \a algo permits to choice the algorithm: NETGEN or GHS3D
- If the optional \a geom parameter is not sets, this algorithm is global.
- Otherwise, this algorithm define a submesh based on \a geom subshape.
- \param algo values are: smesh.NETGEN, smesh.GHS3D
- \param geom If defined, subshape to be meshed
- """
- return Mesh_Tetrahedron(self, algo, geom)
-
- def Hexahedron(self, geom=0):
- """
- Creates a hexahedron 3D algorithm for solids.
- If the optional \a geom parameter is not sets, this algorithm is global.
- Otherwise, this algorithm define a submesh based on \a geom subshape.
- \param geom If defined, subshape to be meshed
- """
- return Mesh_Hexahedron(self, geom)
-
- def Compute(self):
- """
- Compute the mesh and return the status of the computation
- """
- b = smesh.Compute(self.mesh, self.geom)
- if salome.sg.hasDesktop():
- smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init(salome.myStudyId)
- smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), b )
- salome.sg.updateObjBrowser(1)
- return b
-
- def Group(self, grp, name=""):
- """
- Create a mesh group based on geometric object \a grp
- and give a \a name, if this parameter is not defined
- the name is the same as the geometric group name
- \param grp is a geometric group, a vertex, an edge, a face or a solid
- \param name is the name of the mesh group
- """
- if name == "":
- name = grp.GetName()
-
- type = []
- tgeo = str(grp.GetShapeType())
- if tgeo == "VERTEX":
- type = SMESH.NODE
- elif tgeo == "EDGE":
- type = SMESH.EDGE
- elif tgeo == "FACE":
- type = SMESH.FACE
- elif tgeo == "SOLID":
- type = SMESH.VOLUME
- elif tgeo == "SHELL":
- type = SMESH.VOLUME
- elif tgeo == "COMPOUND":
- tgeo = geompy.GetType(grp)
- if tgeo == geompy.ShapeType["VERTEX"]:
- type = SMESH.NODE
- elif tgeo == geompy.ShapeType["EDGE"]:
- type = SMESH.EDGE
- elif tgeo == geompy.ShapeType["FACE"]:
- type = SMESH.FACE
- elif tgeo == geompy.ShapeType["SOLID"]:
- type = SMESH.VOLUME
-
- if type == []:
- print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
- return 0
- else:
- return self.mesh.CreateGroupFromGEOM(type, name, grp)
-
- def ExportToMED(self, f, version, opt=0):
- """
- Export the mesh in a file with the MED format and choice the \a version of MED format
- \param f is the file name
- \param version values are smesh.MED_V2_1, smesh.MED_V2_2
- """
- self.mesh.ExportToMED(f, opt, version)