-# Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
-# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2016 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
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
+# Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#
-# 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.
+# 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.
#
-# 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
+# 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.
#
-# See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
+# 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.py
# Author : Francis KLOSS, OCC
# Module : SMESH
-
-"""
- \namespace smesh
+#
+"""@package smesh
\brief Module smesh
"""
import salome
-import geompy
-import StdMeshers
-import SMESH
-
-# Public variables
-# ----------------
-
-REGULAR = 1
-PYTHON = 2
-
-NETGEN = 3
-GHS3D = 4
-
-smesh = salome.lcc.FindOrLoadComponent("FactoryServer", "SMESH")
-smesh.SetCurrentStudy(salome.myStudy)
-
-# Private functions
-# -----------------
-
-NO_NAME = "NoName"
-
-def GetName(obj):
- ior = salome.orb.object_to_string(obj)
- sobj = salome.myStudy.FindObjectIOR(ior)
- if sobj is None:
- return NO_NAME
- else:
- attr = sobj.FindAttribute("AttributeName")[1]
- return attr.Value()
-
-def SetName(obj, name):
- ior = salome.orb.object_to_string(obj)
- sobj = salome.myStudy.FindObjectIOR(ior)
- attr = sobj.FindAttribute("AttributeName")[1]
- attr.SetValue(name)
-
-# Algorithms and hypothesis
-# =========================
-
-# Private class: Mesh_Algorithm
-# -----------------------------
-
-class Mesh_Algorithm:
- """
- Mother class to define algorithm, recommended to don't use directly
- """
-
- mesh = 0
- geom = 0
- subm = 0
- algo = 0
-
- def GetSubMesh(self):
- """
- If the algorithm is global, return 0
- else return the submesh associated to this algorithm
- """
- return self.subm
-
- def GetAlgorithm(self):
- """
- Return the wrapped mesher
- """
- return self.algo
-
- def TreatHypoStatus(self, status, hypName, geomName, isAlgo):
- """
- Private method. Print error message if a hypothesis was not assigned
- """
- if isAlgo:
- hypType = "algorithm"
- else:
- hypType = "hypothesis"
- if status == SMESH.HYP_UNKNOWN_FATAL :
- reason = "for unknown reason"
- elif status == SMESH.HYP_INCOMPATIBLE :
- reason = "this hypothesis mismatches algorithm"
- elif status == SMESH.HYP_NOTCONFORM :
- reason = "not conform mesh would be built"
- elif status == SMESH.HYP_ALREADY_EXIST :
- reason = hypType + " of the same dimension already assigned to this shape"
- elif status == SMESH.HYP_BAD_DIM :
- reason = hypType + " mismatches shape"
- elif status == SMESH.HYP_CONCURENT :
- reason = "there are concurrent hypotheses on sub-shapes"
- elif status == SMESH.HYP_BAD_SUBSHAPE :
- reason = "shape is neither the main one, nor its subshape, nor a valid group"
- else:
- return
- hypName = '"' + hypName + '"'
- geomName= '"' + geomName+ '"'
- if status < SMESH.HYP_UNKNOWN_FATAL:
- print hypName, "was assigned to", geomName,"but", reason
- else:
- print hypName, "was not assigned to",geomName,":", reason
- pass
-
- def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
- """
- Private method
- """
- self.mesh = mesh
- piece = mesh.geom
- if geom==0:
- self.geom = piece
- name = GetName(piece)
- else:
- self.geom = geom
- name = GetName(geom)
- if name==NO_NAME:
- name = geompy.SubShapeName(geom, piece)
- geompy.addToStudyInFather(piece, geom, name)
- self.subm = mesh.mesh.GetSubMesh(geom, hypo)
-
- self.algo = smesh.CreateHypothesis(hypo, so)
- SetName(self.algo, name + "/" + hypo)
- status = mesh.mesh.AddHypothesis(self.geom, self.algo)
- self.TreatHypoStatus( status, hypo, name, 1 )
-
- def Hypothesis(self, hyp, args=[], so="libStdMeshersEngine.so"):
- """
- Private method
- """
- hypo = smesh.CreateHypothesis(hyp, so)
- a = ""
- s = "="
- i = 0
- n = len(args)
- while i<n:
- a = a + s + str(args[i])
- s = ","
- i = i + 1
- name = GetName(self.geom)
- SetName(hypo, name + "/" + hyp + a)
- status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
- self.TreatHypoStatus( status, hyp, name, 0 )
- return hypo
-
-# Public class: Mesh_Segment
-# --------------------------
-
-class Mesh_Segment(Mesh_Algorithm):
- """
- Class to define a segment 1D algorithm for discretization
- """
-
- def __init__(self, mesh, geom=0):
- """
- Private constructor
- """
- self.Create(mesh, geom, "Regular_1D")
-
- def LocalLength(self, l):
- """
- Define "LocalLength" hypothesis to cut an edge in several segments with the same length
- \param l for the length of segments that cut an edge
- """
- hyp = self.Hypothesis("LocalLength", [l])
- hyp.SetLength(l)
- return hyp
-
- def NumberOfSegments(self, n, s=[]):
- """
- Define "NumberOfSegments" hypothesis to cut an edge in several fixed number of segments
- \param n for the number of segments that cut an edge
- \param s for the scale factor (optional)
- """
- if s == []:
- hyp = self.Hypothesis("NumberOfSegments", [n])
- else:
- hyp = self.Hypothesis("NumberOfSegments", [n,s])
- hyp.SetDistrType( 1 )
- hyp.SetScaleFactor(s)
- hyp.SetNumberOfSegments(n)
- return hyp
-
- def Arithmetic1D(self, start, end):
- """
- Define "Arithmetic1D" hypothesis to cut an edge in several segments with arithmetic length increasing
- \param start for the length of the first segment
- \param end for the length of the last segment
- """
- hyp = self.Hypothesis("Arithmetic1D", [start, end])
- hyp.SetLength(start, 1)
- hyp.SetLength(end , 0)
- return hyp
-
- def StartEndLength(self, start, end):
- """
- Define "StartEndLength" hypothesis to cut an edge in several segments with geometric length increasing
- \param start for the length of the first segment
- \param end for the length of the last segment
- """
- hyp = self.Hypothesis("StartEndLength", [start, end])
- hyp.SetLength(start, 1)
- hyp.SetLength(end , 0)
- return hyp
-
- def Deflection1D(self, d):
- """
- Define "Deflection1D" hypothesis
- \param d for the deflection
- """
- hyp = self.Hypothesis("Deflection1D", [d])
- hyp.SetDeflection(d)
- return hyp
-
- def Propagation(self):
- """
- Define "Propagation" hypothesis that propagate all other hypothesis on all others edges that are in
- the opposite side in the case of quadrangular faces
- """
- return self.Hypothesis("Propagation")
-
- def AutomaticLength(self, fineness=0):
- """
- Define "AutomaticLength" hypothesis
- \param fineness for the fineness [0-1]
- """
- hyp = self.Hypothesis("AutomaticLength")
- hyp.SetFineness( fineness )
- return hyp
-
- def QuadraticMesh(self):
- """
- Define "QuadraticMesh" hypothesis, forcing 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.
- """
- hyp = self.Hypothesis("QuadraticMesh")
- return hyp
-
-# Public class: Mesh_Segment_Python
-# ---------------------------------
-
-class Mesh_Segment_Python(Mesh_Segment):
- """
- Class to define a segment 1D algorithm for discretization with python function
- """
-
- def __init__(self, mesh, geom=0):
- """
- Private constructor
- """
- import Python1dPlugin
- self.Create(mesh, geom, "Python_1D", "libPython1dEngine.so")
-
- 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")
+from salome import *
- 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")
-
- def QuadranglePreference(self):
- """
- Define "QuadranglePreference" hypothesis, forcing 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
- """
- hyp = self.Hypothesis("QuadranglePreference")
- return hyp
-
-# 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 MeshDimension(self):
- """
- Returns mesh dimension depending on shape one
- """
- shells = geompy.SubShapeAllIDs( self.geom, geompy.ShapeType["SHELL"] )
- if len( shells ) > 0 :
- return 3
- elif geompy.NumberOfFaces( self.geom ) > 0 :
- return 2
- elif geompy.NumberOfEdges( self.geom ) > 0 :
- return 1
- else:
- return 0;
- pass
-
- 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 Segment(geom) is called by mistake
- if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
- algo, geom = geom, algo
- pass
- if algo == REGULAR:
- return Mesh_Segment(self, geom)
- elif algo == PYTHON:
- return Mesh_Segment_Python(self, geom)
- else:
- return Mesh_Segment(self, geom)
-
- 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
- """
- ## if Tetrahedron(geom) is called by mistake
- if ( isinstance( algo, geompy.GEOM._objref_GEOM_Object)):
- algo, geom = geom, algo
- pass
- 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)
+import geompy
- def Compute(self):
- """
- Compute the mesh and return the status of the computation
- """
- ok = smesh.Compute(self.mesh, self.geom)
- if not ok:
- errors = smesh.GetAlgoState( self.mesh, self.geom )
- allReasons = ""
- for err in errors:
- if err.isGlobalAlgo:
- glob = " global "
- else:
- glob = " local "
- pass
- dim = str(err.algoDim)
- if err.name == SMESH.MISSING_ALGO:
- reason = glob + dim + "D algorithm is missing"
- elif err.name == SMESH.MISSING_HYPO:
- name = '"' + err.algoName + '"'
- reason = glob + dim + "D algorithm " + name + " misses " + dim + "D hypothesis"
- else:
- reason = "Global \"Not Conform mesh allowed\" hypothesis is missing"
- pass
- if allReasons != "":
- allReasons += "\n"
- pass
- allReasons += reason
- pass
- if allReasons != "":
- print '"' + GetName(self.mesh) + '"',"not computed:"
- print allReasons
+import SMESH, SALOMEDS
+from salome.smesh import smeshBuilder
+
+# retrieve SMESH engine in try/except block
+# to avoid problems in some cases, e.g. when generating documentation
+try:
+ # get instance of class smeshBuilder
+ engineSmesh = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" )
+ smesh = smeshBuilder.New(salome.myStudy, engineSmesh)
+except:
+ print "exception in smesh.py: instance creation failed"
+ smesh = None
+ pass
+
+# load plugins and add dynamically generated methods to Mesh class,
+# the same for for global variables declared by plug-ins
+from salome.smesh.smeshBuilder import *
+from salome.smesh.smeshBuilder import Mesh, algoCreator
+for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
+ #
+ #print "pluginName: ", pluginName
+ pluginBuilderName = pluginName + "Builder"
+ try:
+ exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
+ except Exception, e:
+ from salome_utils import verbose
+ if verbose(): print "Exception while loading %s: %s" % ( pluginBuilderName, e )
+ continue
+ exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
+ plugin = eval( pluginBuilderName )
+
+ # add methods creating algorithms to Mesh
+ for k in dir( plugin ):
+ if k[0] == '_': continue
+ algo = getattr( plugin, k )
+ if type( algo ).__name__ == 'classobj' and hasattr( algo, "meshMethod" ):
+ if not hasattr( Mesh, algo.meshMethod ):
+ setattr( Mesh, algo.meshMethod, algoCreator() )
pass
- pass
- if salome.sg.hasDesktop():
- smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init(salome.myStudyId)
- smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok )
- salome.sg.updateObjBrowser(1)
- pass
- return ok
-
- def AutomaticTetrahedralization(self, fineness=0):
- """
- Compute tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
- The parameter \a fineness [0.-1.] defines mesh fineness
- """
- dim = self.MeshDimension()
- # assign hypotheses
- self.RemoveGlobalHypotheses()
- self.Segment().AutomaticLength(fineness)
- if dim > 1 :
- self.Triangle().LengthFromEdges()
- pass
- if dim > 2 :
- self.Tetrahedron(NETGEN)
- pass
- return self.Compute()
-
- def AutomaticHexahedralization(self, fineness=0):
- """
- Compute hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
- The parameter \a fineness [0.-1.] defines mesh fineness
- """
- dim = self.MeshDimension()
- # assign hypotheses
- self.RemoveGlobalHypotheses()
- self.Segment().AutomaticLength(fineness)
- if dim > 1 :
- self.Quadrangle()
- pass
- if dim > 2 :
- self.Hexahedron()
- pass
- return self.Compute()
-
- def RemoveGlobalHypotheses(self):
- """
- Removes all global hypotheses
- """
- current_hyps = self.mesh.GetHypothesisList( self.geom )
- for hyp in current_hyps:
- self.mesh.RemoveHypothesis( self.geom, hyp )
+ getattr( Mesh, algo.meshMethod ).add( algo )
pass
pass
+ pass
+del pluginName
+
+# export the methods of smeshBuilder
+if smesh:
+ for k in dir( smesh ):
+ if k[0] == '_': continue
+ globals()[k] = getattr( smesh, k )
+ del k
+ pass
+
+print """
+===============================================================================
+WARNING:
+Usage of smesh.py is deprecated in SALOME V7.2!
+smesh.py will be removed in a future version!
+TODO:
+The following changes in your scripts are required to avoid this message:
+
+replace
+-------
+
+import smesh, SMESH
+smesh.SetCurrentStudy(theStudy)
+
+with
+----
- 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)
+import SMESH
+from salome.smesh import smeshBuilder
+smesh = smeshBuilder.New(salome.myStudy)
- 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)
+you also need to modify some lines where smeshBuilder is used instead of smesh
- def ExportMED(self, f, opt=0):
- """
- Export the mesh in a file with the MED format
- \param f is the file name
- """
- self.mesh.ExportMED(f, opt)
+algo=smesh.xxxx ==> algo=smeshBuilder.xxxx
- def ExportDAT(self, f):
- """
- Export the mesh in a file with the DAT format
- \param f is the file name
- """
- self.mesh.ExportDAT(f)
+See also SMESH User's Guide for more details
- def ExportUNV(self, f):
- """
- Export the mesh in a file with the UNV format
- \param f is the file name
- """
- self.mesh.ExportUNV(f)
+WARNING:
+The smesh.py module works correctly only in the first created study.
+It does not work in the second, third, etc studies!
- def ExportSTL(self, f, ascii=1):
- """
- Export the mesh in a file with the STL format
- \param f is the file name
- \param ascii defined the kind of file contents
- """
- self.mesh.ExportSTL(f, ascii)
+===============================================================================
+"""
